node ipc
10.1.0
un módulo nodejs para comunicación entre procesos local y remota con soporte completo para Linux, Mac y Windows. También admite todas las formas de comunicación de sockets, desde sockets Unix y Windows de bajo nivel hasta UDP y sockets seguros TLS y TCP.
Una gran solución para redes neuronales multiproceso complejas en Node.JS
npm install node-ipc
npm install node-ipc@^9.0.0
//es6
import ipc from 'node-ipc'
//commonjs
const ipc = require ( 'node-ipc' ) . default ;
Información de npm: consulte las tendencias y estadísticas de npm para node-ipc
Información de GitHub:
Información de cobertura del código:
Ejecute npm run coverage para alojar una versión local del informe de cobertura en localhost:8080. Este es el mismo formato que Estambul y Nueva York. Debería resultarle muy familiar.
Prueba realizada con prueba de vainilla.
vanilla-test se integra con c8 para cobertura ESM nativa sin la necesidad de transpilar su código. Al momento de escribir este artículo, esta es la única forma de probar ESM de forma nativa, ¡y es increíble!
Sitios web de detalles del paquete:
Este trabajo tiene licencia a través de la Licencia MIT.
las últimas versiones de node-ipc pueden funcionar con el indicador --harmony. Sin embargo, oficialmente admitimos el nodo v4 y versiones posteriores con es5 y es6.
npm test ejecutará las pruebas de jasmine con istanbul para node-ipc y generará un informe de cobertura en la carpeta de especificaciones.
Es posible que desees instalar jasmine y istanbul globalmente con sudo npm install -g jasmine istanbul
| Tipo | Estabilidad | Definición |
|---|---|---|
| Zócalo Unix o Zócalo Windows | Estable | Proporciona una comunicación ultrarrápida para Linux, Mac y Windows y evita la tarjeta de red para reducir la sobrecarga y la latencia. Ejemplos de sockets locales de Unix y Windows |
| Conector TCP | Estable | Proporciona la comunicación más confiable a través de la red. También se puede utilizar para IPC local, pero es más lento que la implementación de sockets Unix número 1 porque los sockets TCP pasan a través de la tarjeta de red, mientras que los sockets Unix y Windows no lo hacen. Ejemplos de socket TCP de red local o remota |
| Zócalo TLS | Estable | Toma de red configurable y segura sobre SSL. Equivalente a https. Documentación TLS/SSL |
| Zócalos UDP | Estable | Proporciona la comunicación de red más rápida . UDP es menos confiable pero mucho más rápido que TCP. Se utiliza mejor para transmitir datos no críticos como sonido, video o datos de juegos multijugador, ya que puede descartar paquetes dependiendo de la conectividad de la red y otros factores. UDP también se puede utilizar para IPC local, pero es más lento que la implementación de sockets Unix o Windows Socket de #1 porque los sockets UDP pasan a través de la tarjeta de red, mientras que los sockets Unix y Windows no. Ejemplos de socket UDP de red local o remota |
| SO | Enchufes compatibles |
|---|---|
| linux | Unix, Posix, TCP, TLS, UDP |
| Impermeable | Unix, Posix, TCP, TLS, UDP |
| Ganar | Windows, TCP, TLS, UDP |
ipc.config
Configure estas variables en el alcance ipc.config para sobrescribir o establecer valores predeterminados.
{
appspace : 'app.' ,
socketRoot : '/tmp/' ,
id : os . hostname ( ) ,
networkHost : 'localhost' , //should resolve to 127.0.0.1 or ::1 see the table below related to this
networkPort : 8000 ,
readableAll : false ,
writableAll : false ,
encoding : 'utf8' ,
rawBuffer : false ,
delimiter : 'f' ,
sync : false ,
silent : false ,
logInColor : true ,
logDepth : 5 ,
logger : console . log ,
maxConnections : 100 ,
retry : 500 ,
maxRetries : false ,
stopRetrying : false ,
unlink : true ,
interfaces : {
localAddress : false ,
localPort : false ,
family : false ,
hints : false ,
lookup : false
}
}| variable | documentación |
|---|---|
| espacio de aplicaciones | utilizado para el espacio de nombres de Unix Socket (Unix Domain Socket). Si no se establece específicamente, el socket de dominio Unix combinará socketRoot, appspace e id para formar la ruta del socket Unix para su creación o enlace. Esto está disponible en caso de que tenga muchas aplicaciones ejecutándose en su sistema, es posible que tenga varios sockets con la misma identificación, pero si cambia el espacio de aplicaciones, aún tendrá sockets únicos y específicos de la aplicación. |
| raíz del zócalo | el directorio en el que crear o vincularse a un socket Unix |
| identificación | la identificación de este socket o servicio |
| redAnfitrión | el host local o remoto en el que se deben conectar los sockets TCP, TLS o UDP |
| redPuerto | el puerto predeterminado en el que se deben conectar los sockets TCP, TLS o UDP |
| legibleTodo | hace que la tubería sea legible para todos los usuarios, incluidos los servicios de Windows |
| grabableTodo | hace que la tubería sea escribible para todos los usuarios, incluidos los servicios de Windows |
| codificación | la codificación predeterminada para los datos enviados en sockets. Se utiliza principalmente si rawBuffer está configurado en verdadero. Los valores válidos son: ascii utf8 utf16le ucs2 base64 hex . |
| rawBuffer | si es verdadero, los datos se enviarán y recibirán como un Buffer de nodo sin formato, NO como un Object como JSON. Esto es excelente para IPC binario o hexadecimal y para comunicarse con otros procesos en lenguajes como C y C++. |
| delimitador | el delimitador al final de cada paquete de datos. |
| sincronizar | solicitudes sincrónicas. Los clientes no enviarán nuevas solicitudes hasta que el servidor responda. |
| silencioso | activar/desactivar el registro predeterminado es falso, lo que significa que el registro está activado |
| iniciar sesiónColor | activar/desactivar util.inspect colores para ipc.log |
| profundidad de registro | establecer la profundidad para util.inspect durante ipc.log |
| registrador | la función que recibe la salida de ipc.log; debería tomar un argumento de una sola cadena |
| maxConexiones | este es el número máximo de conexiones permitidas a un socket. Actualmente sólo se está configurando en sockets Unix. Otros tipos de socket utilizan los valores predeterminados del sistema. |
| rever | este es el tiempo en milisegundos que un cliente esperará antes de intentar volver a conectarse a un servidor si se pierde la conexión. Esto no afecta a los sockets UDP ya que no tienen una relación cliente-servidor como los sockets Unix y los sockets TCP. |
| maxRetries | si está configurado, representa el número máximo de reintentos después de cada desconexión antes de darse por vencido y eliminar por completo una conexión específica |
| detenerReintentar | El valor predeterminado es falso, lo que significa que los clientes seguirán intentando conectarse a los servidores indefinidamente en el intervalo de reintento. Si se establece en cualquier número, el cliente dejará de reintentar cuando se exceda ese número después de cada desconexión. Si se establece en verdadero en tiempo real, dejará de intentar conectarse inmediatamente independientemente de maxRetries. Si se establece en 0, el cliente NO intentará volver a conectarse. |
| desconectar | El valor predeterminado es verdadero, lo que significa que el módulo se encargará de eliminar el socket IPC antes del inicio. Si usa node-ipc en un entorno agrupado donde habrá varios oyentes en el mismo socket, debe configurarlo en false y luego encargarse de eliminar el socket en su propio código. |
| interfaces | Se utiliza principalmente para especificar a través de qué interfaz debe conectarse un cliente. consulte la documentación de socket.connect en la API de node.js |
Estos métodos están disponibles en el alcance de la IPC.
ipc.log(a,b,c,d,e...);
ipc.log aceptará cualquier número de argumentos y si ipc.config.silent no está configurado, los concatenará todos con un único espacio " " entre ellos y luego los registrará en la consola. Esto es rápido porque evita que se produzca cualquier concatenación si ipc.config.silent está configurado true . De esa manera, si deja el registro en su lugar, casi no debería tener ningún efecto en el rendimiento.
El registro también usa util.inspect. Puede controlar si debe iniciar sesión en color, la profundidad del registro y el destino a través de ipc.config
ipc . config . logInColor = true ; //default
ipc . config . logDepth = 5 ; //default
ipc . config . logger = console . log . bind ( console ) ; // default ipc.connectTo(id,path,callback);
Se utiliza para conectarse como cliente a sockets Unix y Windows locales. Esta es la forma más rápida para que los procesos en la misma máquina se comuniquen porque omite la tarjeta de red que deben usar tanto TCP como UDP.
| variable | requerido | definición |
|---|---|---|
| identificación | requerido | es la identificación de la cadena del socket al que se está conectando. El socket con esta identificación se agrega al objeto ipc.of cuando se crea. |
| camino | opcional | es la ruta del archivo de socket de dominio Unix; si el sistema es Windows, se convertirá automáticamente en una tubería adecuada con la misma información que el archivo de socket de dominio Unix. Si no se configura, el valor predeterminado será ipc.config.socketRoot + ipc.config.appspace + id |
| llamar de vuelta | opcional | esta es la función a ejecutar cuando se ha creado el socket. |
Los argumentos de los ejemplos se pueden omitir siempre que sigan en orden.
ipc . connectTo ( 'world' ) ;o usando solo una identificación y una devolución de llamada
ipc . connectTo (
'world' ,
function ( ) {
ipc . of . world . on (
'hello' ,
function ( data ) {
ipc . log ( data . debug ) ;
//if data was a string, it would have the color set to the debug style applied to it
}
)
}
) ;o estableciendo explícitamente la ruta
ipc . connectTo (
'world' ,
'myapp.world'
) ;o establecer explícitamente la ruta con devolución de llamada
ipc . connectTo (
'world' ,
'myapp.world' ,
function ( ) {
...
}
) ; ipc.connectToNet(id,host,port,callback)
Se utiliza para conectarse como cliente a un socket TCP o TLS a través de la tarjeta de red. Esto puede ser local o remoto; si es local, se recomienda utilizar la implementación de connectTo para Unix y Windows Socket, ya que es mucho más rápido ya que evita la tarjeta de red por completo.
Para sockets TLS y SSL, consulte los documentos TLS y SSL de node-ipc. Tienen algunos requisitos adicionales y cosas que deben saber, por lo que tienen su propio documento.
| variable | requerido | definición |
|---|---|---|
| identificación | requerido | es la identificación de la cadena del socket al que se está conectando. Para sockets TCP y TLS, esta identificación se agrega al objeto ipc.of cuando se crea el socket con una referencia al socket. |
| anfitrión | opcional | es el host en el que reside el socket TCP o TLS. El valor predeterminado será ipc.config.networkHost si no se especifica. |
| puerto | opcional | el puerto en el que reside el socket TCP o TLS. |
| llamar de vuelta | opcional | esta es la función a ejecutar cuando se ha creado el socket. |
Los argumentos de los ejemplos se pueden omitir siempre que sigan en orden.
Entonces, aunque el valor predeterminado es: (id,host,puerto,devolución de llamada), los siguientes ejemplos seguirán funcionando porque todavía están en orden (id,puerto,devolución de llamada) o (id,host,devolución de llamada) o (id,puerto), etc. .
ipc . connectToNet ( 'world' ) ;o usando solo una identificación y una devolución de llamada
ipc . connectToNet (
'world' ,
function ( ) {
...
}
) ;o establecer explícitamente el host y la ruta
ipc . connectToNet (
'world' ,
'myapp.com' , serve ( path , callback )
3435
) ;o solo configurar explícitamente el puerto y la devolución de llamada
ipc . connectToNet (
'world' ,
3435 ,
function ( ) {
...
}
) ; ipc.disconnect(id)
Se utiliza para desconectar un cliente de un socket Unix, Windows, TCP o TLS. El socket y su referencia se eliminarán de la memoria y del alcance ipc.of Este puede ser local o remoto. Los clientes UDP no mantienen conexiones, por lo que no hay Clientes y este método no tiene valor para ellos.
| variable | requerido | definición |
|---|---|---|
| identificación | requerido | es la identificación de la cadena del socket del cual desconectarse. |
ejemplos
ipc . disconnect ( 'world' ) ; ipc.serve(path,callback);
Se utiliza para crear un servidor Unix Socket local o un servidor Windows Socket al que los clientes pueden vincularse. El servidor puede emit eventos a Client Sockets específicos o broadcast eventos a todos los Client Sockets conocidos.
| variable | requerido | definición |
|---|---|---|
| camino | opcional | Esta es la ruta del archivo de socket de dominio Unix; si el sistema es Windows, se convertirá automáticamente en una tubería adecuada con la misma información que el archivo de socket de dominio Unix. Si no se configura, el valor predeterminado será ipc.config.socketRoot + ipc.config.appspace + id |
| llamar de vuelta | opcional | Esta es una función que se llamará después de que se haya iniciado el servidor. Esto también se puede hacer vinculando un evento al evento de inicio como ipc.server.on('start',function(){}); |
Los argumentos de los ejemplos se pueden omitir siempre que sigan en orden.
ipc . serve ( ) ;o especificando devolución de llamada
ipc . serve (
function ( ) { ... }
) ;o especificar ruta
ipc . serve (
'/tmp/myapp.myservice'
) ;o especificando todo
ipc . serve (
'/tmp/myapp.myservice' ,
function ( ) { ... }
) ; serveNet(host,port,UDPType,callback)
Se utiliza para crear un servidor de socket TCP, TLS o UDP al que los clientes pueden vincularse u otros servidores pueden enviar datos. El servidor puede emit eventos a Client Sockets específicos o broadcast eventos a todos los Client Sockets conocidos.
| variable | requerido | definición |
|---|---|---|
| anfitrión | opcional | Si no se especifica, el valor predeterminado es la primera dirección en os.networkInterfaces(). Para servidores TCP, TLS y UDP, lo más probable es que sea 127.0.0.1 o ::1 |
| puerto | opcional | El puerto al que se vinculará el servidor TCP, UDP o TLS Socket; el valor predeterminado es 8000 si no se especifica |
| Tipo UDP | opcional | Si se configura, esto creará el servidor como un socket UDP. 'udp4' o 'udp6' son valores válidos. De forma predeterminada, esto no está configurado. Cuando utilice udp6, asegúrese de especificar un host IPv6 válido, como ::1 |
| llamar de vuelta | opcional | Función que se llamará cuando se cree el servidor. |
Los argumentos de los ejemplos se pueden omitir siempre que todavía estén en orden.
servidor tcp predeterminado
ipc . serveNet ( ) ;servidor udp predeterminado
ipc . serveNet ( 'udp4' ) ;o especificando el servidor TCP con devolución de llamada
ipc . serveNet (
function ( ) { ... }
) ;o especificando un servidor UDP con devolución de llamada
ipc . serveNet (
'udp4' ,
function ( ) { ... }
) ;o especificar puerto
ipc . serveNet (
3435
) ;o especificando todo TCP
ipc . serveNet (
'MyMostAwesomeApp.com' ,
3435 ,
function ( ) { ... }
) ;o especificando todo UDP
ipc . serveNet (
'MyMostAwesomeApp.com' ,
3435 ,
'udp4' ,
function ( ) { ... }
) ;| variable | definición |
|---|---|
| ipc.de | Aquí es donde se almacenarán las referencias de conexión de socket cuando se conecte a ellos como cliente a través de ipc.connectTo o iupc.connectToNet . Se almacenarán según el ID utilizado para crearlos, por ejemplo: ipc.of.mySocket |
| servidor.ipc | Esta es una referencia al servidor creado por ipc.serve o ipc.serveNet |
| método | definición |
|---|---|
| comenzar | comenzar a servir necesita llamar serve o serveNet primero para configurar el servidor |
| detener | cerrar el servidor y dejar de servir |
| nombre del evento | parámetros | definición |
|---|---|---|
| error | errar objeto | Se activa cuando ocurre un error. |
| conectar | Se activa cuando se conecta el enchufe. | |
| desconectar | activado por el cliente cuando el socket se ha desconectado del servidor | |
| enchufe.desconectado | socket destruidoSocketID | activado por el servidor cuando un socket de cliente se ha desconectado |
| destruir | Se activa cuando el socket ha sido totalmente destruido, no se realizarán más reintentos automáticos y todas las referencias desaparecerán. | |
| datos | buffer | Se activa cuando ipc.config.rawBuffer es verdadero y se recibe un mensaje. |
| tu tipo de evento | los datos de tu evento | Se activa cuando se recibe un mensaje JSON. El nombre del evento será el tipo de cadena de su mensaje y el parámetro será el objeto de datos de su mensaje, por ejemplo: { type:'myEvent',data:{a:1}} |
A veces es posible que necesites instancias explícitas e independientes de node-ipc. Sólo para tales escenarios hemos expuesto la clase IPC principal en el singleton de IPC.
import { IPCModule } from 'node-ipc' ;
const ipc = new RawIPC ;
const someOtherExplicitIPC = new RawIPC ;
//OR
const ipc = from 'node-ipc' ) ;
const someOtherExplicitIPC = new ipc . IPC ;
//setting explicit configs
//keep one silent and the other verbose
ipc . config . silent = true ;
someOtherExplicitIPC . config . silent = true ;
//make one a raw binary and the other json based ipc
ipc . config . rawBuffer = false ;
someOtherExplicitIPC . config . rawBuffer = true ;
someOtherExplicitIPC . config . encoding = 'hex' ;Puede encontrar ejemplos avanzados en la carpeta de ejemplos. En los ejemplos encontrará demostraciones más complejas que incluyen ejemplos de múltiples clientes.
El servidor es el proceso que mantiene abierto un socket para IPC. Se pueden conectar varios sockets a este servidor y hablar con él. También puede transmitir a todos los clientes o emitir a un cliente específico. Este es el ejemplo más básico que funcionará para sockets locales de Unix y Windows, así como para sockets TCP de red local o remota.
import ipc from 'node-ipc' ;
ipc . config . id = 'world' ;
ipc . config . retry = 1500 ;
ipc . serve (
function ( ) {
ipc . server . on (
'message' ,
function ( data , socket ) {
ipc . log ( 'got a message : ' . debug , data ) ;
ipc . server . emit (
socket ,
'message' , //this can be anything you want so long as
//your client knows.
data + ' world!'
) ;
}
) ;
ipc . server . on (
'socket.disconnected' ,
function ( socket , destroyedSocketID ) {
ipc . log ( 'client ' + destroyedSocketID + ' has disconnected!' ) ;
}
) ;
}
) ;
ipc . server . start ( ) ; El cliente se conecta al socket del servidor para la comunicación entre procesos. El socket recibirá los eventos que se le emitan específicamente, así como los eventos que el servidor transmita al socket. Este es el ejemplo más básico que funcionará tanto para sockets Unix locales como para sockets TCP de red local o remota.
import ipc from 'node-ipc' ;
ipc . config . id = 'hello' ;
ipc . config . retry = 1500 ;
ipc . connectTo (
'world' ,
function ( ) {
ipc . of . world . on (
'connect' ,
function ( ) {
ipc . log ( '## connected to world ##' . rainbow , ipc . config . delay ) ;
ipc . of . world . emit (
'message' , //any event or message type your server listens for
'hello'
)
}
) ;
ipc . of . world . on (
'disconnect' ,
function ( ) {
ipc . log ( 'disconnected from world' . notice ) ;
}
) ;
ipc . of . world . on (
'message' , //any event or message type your server listens for
function ( data ) {
ipc . log ( 'got a message from world : ' . debug , data ) ;
}
) ;
}
) ; Los sockets UDP son diferentes a los sockets Unix, Windows y TCP porque deben estar vinculados a un puerto único en su máquina para recibir mensajes. Por ejemplo, un cliente TCP, Unix o Windows Socket podría simplemente conectarse a un servidor TCP, Unix o Windows Socket independiente. Ese cliente podría luego intercambiar, tanto enviar como recibir, datos en el puerto o la ubicación del servidor. Los sockets UDP no pueden hacer esto. Deben vincularse a un puerto para recibir o enviar datos.
Esto significa que un Cliente y un Servidor UDP son lo mismo porque para recibir datos, un Socket UDP debe tener su propio puerto para recibir datos, y solo un proceso puede usar este puerto a la vez. También significa que para emit o broadcast datos, el servidor UDP necesitará conocer el host y el puerto del Socket al que pretende transmitir los datos.
Este es el ejemplo más básico que funcionará para sockets UDP tanto locales como remotos.
import ipc from 'node-ipc' ;
ipc . config . id = 'world' ;
ipc . config . retry = 1500 ;
ipc . serveNet (
'udp4' ,
function ( ) {
console . log ( 123 ) ;
ipc . server . on (
'message' ,
function ( data , socket ) {
ipc . log ( 'got a message from ' . debug , data . from . variable , ' : ' . debug , data . message . variable ) ;
ipc . server . emit (
socket ,
'message' ,
{
from : ipc . config . id ,
message : data . message + ' world!'
}
) ;
}
) ;
console . log ( ipc . server ) ;
}
) ;
ipc . server . start ( ) ; Tenga en cuenta que configuramos el puerto aquí en 8001 porque el servidor mundial ya está usando el ipc.config.networkPort predeterminado de 8000. Por lo tanto, no podemos vincularnos a 8000 mientras el mundo lo está usando.
ipc . config . id = 'hello' ;
ipc . config . retry = 1500 ;
ipc . serveNet (
8001 ,
'udp4' ,
function ( ) {
ipc . server . on (
'message' ,
function ( data ) {
ipc . log ( 'got Data' ) ;
ipc . log ( 'got a message from ' . debug , data . from . variable , ' : ' . debug , data . message . variable ) ;
}
) ;
ipc . server . emit (
{
address : '127.0.0.1' , //any hostname will work
port : ipc . config . networkPort
} ,
'message' ,
{
from : ipc . config . id ,
message : 'Hello'
}
) ;
}
) ;
ipc . server . start ( ) ; Los sockets binarios o de búfer se pueden usar con cualquiera de los tipos de sockets anteriores; sin embargo, la forma en que se emiten los eventos de datos es ligeramente diferente. Estos pueden resultar útiles si se trabaja con sistemas integrados o procesos C/C++. Incluso puedes asegurarte de que coincida con la escritura de cadenas C o C++.
Al configurar un socket rawBuffer, debes especificarlo como tal:
ipc . config . rawBuffer = true ; También puede especificar su tipo de codificación. El valor predeterminado es utf8
ipc . config . encoding = 'utf8' ;emitir buffer de cadena:
//server
ipc . server . emit (
socket ,
'hello'
) ;
//client
ipc . of . world . emit (
'hello'
)emitir búfer de matriz de bytes:
//hex encoding may work best for this.
ipc . config . encoding = 'hex' ;
//server
ipc . server . emit (
socket ,
[ 10 , 20 , 30 ]
) ;
//client
ipc . server . emit (
[ 10 , 20 , 30 ]
) ;emitir un búfer de matriz binaria o hexadecimal, esto es mejor para la transferencia de datos en tiempo real, especialmente cuando se conecta a procesos C o C++, o sistemas integrados:
ipc . config . encoding = 'hex' ;
//server
ipc . server . emit (
socket ,
[ 0x05 , 0x6d , 0x5c ]
) ;
//client
ipc . server . emit (
[ 0x05 , 0x6d , 0x5c ]
) ;Escribir buffers explícitos, tipos int, dobles, flotantes, etc., así como datos big endian y little endian en buffers sin procesar, es muy valioso cuando se conecta a procesos C o C++, o sistemas integrados (consulte información más detallada sobre buffers y UInt, Int). , doble, etc. aquí)[https://nodejs.org/api/buffer.html]:
ipc . config . encoding = 'hex' ;
//make a 6 byte buffer for example
const myBuffer = Buffer . alloc ( 6 ) . fill ( 0 ) ;
//fill the first 2 bytes with a 16 bit (2 byte) short unsigned int
//write a UInt16 (2 byte or short) as Big Endian
myBuffer . writeUInt16BE (
2 , //value to write
0 //offset in bytes
) ;
//OR
myBuffer . writeUInt16LE ( 0x2 , 0 ) ;
//OR
myBuffer . writeUInt16LE ( 0x02 , 0 ) ;
//fill the remaining 4 bytes with a 32 bit (4 byte) long unsigned int
//write a UInt32 (4 byte or long) as Big Endian
myBuffer . writeUInt32BE (
16772812 , //value to write
2 //offset in bytes
) ;
//OR
myBuffer . writeUInt32BE ( 0xffeecc , 0 )
//server
ipc . server . emit (
socket ,
myBuffer
) ;
//client
ipc . server . emit (
myBuffer
) ; cluster node-ipc se puede usar con el módulo de clúster de Node.js para brindar la capacidad de tener múltiples lectores para un solo socket. Hacerlo simplemente requiere que establezca la propiedad unlink en la configuración en false y se encargue de desvincular la ruta del socket en el proceso maestro:
import fs from 'fs' ;
import ipc from 'node-ipc' ;
import { cpus } from 'os' ;
import cluster from 'cluster' ;
const cpuCount = cpus ( ) . length ;
const socketPath = '/tmp/ipc.sock' ;
ipc . config . unlink = false ;
if ( cluster . isMaster ) {
if ( fs . existsSync ( socketPath ) ) {
fs . unlinkSync ( socketPath ) ;
}
for ( let i = 0 ; i < cpuCount ; i ++ ) {
cluster . fork ( ) ;
}
} else {
ipc . serve (
socketPath ,
function ( ) {
ipc . server . on (
'currentDate' ,
function ( data , socket ) {
console . log ( `pid ${ process . pid } got: ` , data ) ;
}
) ;
}
) ;
ipc . server . start ( ) ;
console . log ( `pid ${ process . pid } listening on ${ socketPath } ` ) ;
} import fs from 'fs' ;
import ipc from 'node-ipc' ;
const socketPath = '/tmp/ipc.sock' ;
//loop forever so you can see the pid of the cluster sever change in the logs
setInterval (
function ( ) {
ipc . connectTo (
'world' ,
socketPath ,
connecting
) ;
} ,
2000
) ;
function connecting ( socket ) {
ipc . of . world . on (
'connect' ,
function ( ) {
ipc . of . world . emit (
'currentDate' ,
{
message : new Date ( ) . toISOString ( )
}
) ;
ipc . disconnect ( 'world' ) ;
}
) ;
} Consulte el archivo de licencia del MIT.
Lo lamento.
