node ipc
10.1.0
um módulo nodejs para comunicação entre processos local e remota com suporte total para Linux, Mac e Windows. Ele também suporta todas as formas de comunicação de soquete, desde soquetes Unix e Windows de baixo nível até UDP e soquetes TLS e TCP seguros.
Uma ótima solução para redes neurais multiprocessos complexas em 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 ;
informações npm: veja tendências e estatísticas npm para node-ipc
Informações do GitHub:
Informações de cobertura de código:
Execute npm run coverage para hospedar uma versão local do relatório de cobertura em localhost:8080 Este é o mesmo formato de Istambul e Nova York. Deve ser muito familiar.
Teste feito com vanilla-test
vanilla-test integra-se ao c8 para cobertura ESM nativa sem a necessidade de transpilar seu código. No momento em que este artigo foi escrito, esta era a única maneira de testar o ESM nativamente, e é incrível!
Sites de detalhes do pacote:
Este trabalho está licenciado através da Licença MIT.
as versões mais recentes do node-ipc podem funcionar com o sinalizador --harmony. Oficialmente, porém, oferecemos suporte ao nó v4 e mais recente com es5 e es6
npm test executará os testes jasmine com Istambul para node-ipc e gerará um relatório de cobertura na pasta de especificações.
Você pode querer instalar jasmine e istanbul globalmente com sudo npm install -g jasmine istanbul
| Tipo | Estabilidade | Definição |
|---|---|---|
| Soquete Unix ou Soquete Windows | Estável | Fornece comunicação extremamente rápida para Linux, Mac e Windows e evita a placa de rede para reduzir a sobrecarga e a latência. Exemplos locais de Unix e Windows Socket |
| Soquete TCP | Estável | Oferece a comunicação mais confiável em toda a rede. Também pode ser usado para IPC local, mas é mais lento que a implementação de soquete Unix nº 1 porque os soquetes TCP passam pela placa de rede, enquanto os soquetes Unix e Windows não. Exemplos de soquete TCP de rede local ou remota |
| Soquete TLS | Estável | Soquete de rede configurável e seguro sobre SSL. Equivalente a https. Documentação TLS/SSL |
| Soquetes UDP | Estável | Oferece a comunicação de rede mais rápida . O UDP é menos confiável, mas muito mais rápido que o TCP. É melhor usado para transmitir dados não críticos, como som, vídeo ou dados de jogos multijogador, pois pode descartar pacotes dependendo da conectividade da rede e de outros fatores. O UDP também pode ser usado para IPC local, mas é mais lento que o Unix Socket ou Windows Socket Implementation do nº 1 porque os soquetes UDP passam pela placa de rede, enquanto os soquetes Unix e Windows não. Exemplos de soquete UDP de rede local ou remota |
| SO | Soquetes Suportados |
|---|---|
| Linux | Unix, Posix, TCP, TLS, UDP |
| Mac | Unix, Posix, TCP, TLS, UDP |
| Ganhar | Windows, TCP, TLS, UDP |
ipc.config
Defina essas variáveis no escopo ipc.config para substituir ou definir valores padrão.
{
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
}
}| variável | documentação |
|---|---|
| espaço de aplicativos | usado para namespace Unix Socket (Unix Domain Socket). Se não for definido especificamente, o soquete de domínio Unix combinará socketRoot, appspace e id para formar o caminho do soquete Unix para criação ou ligação. Isso está disponível caso você tenha muitos aplicativos em execução em seu sistema, você pode ter vários soquetes com o mesmo ID, mas se alterar o appspace, ainda terá soquetes exclusivos específicos do aplicativo. |
| soqueteRoot | o diretório no qual criar ou vincular a um soquete Unix |
| eu ia | o id deste soquete ou serviço |
| host de rede | o host local ou remoto no qual os soquetes TCP, TLS ou UDP devem se conectar |
| porta de rede | a porta padrão na qual os soquetes TCP, TLS ou UDP devem se conectar |
| legívelTudo | torna o pipe legível para todos os usuários, incluindo serviços do Windows |
| gravávelTudo | torna o pipe gravável para todos os usuários, incluindo serviços do Windows |
| codificação | a codificação padrão para dados enviados em soquetes. Usado principalmente se rawBuffer estiver definido como verdadeiro. Os valores válidos são: ascii utf8 utf16le ucs2 base64 hex . |
| buffer bruto | se for verdade, os dados serão enviados e recebidos como um Buffer de nó bruto, NÃO um Object como JSON. Isso é ótimo para IPC binário ou hexadecimal e para comunicação com outros processos em linguagens como C e C++ |
| delimitador | o delimitador no final de cada pacote de dados. |
| sincronizar | solicitações síncronas. Os clientes não enviarão novas solicitações até que o servidor responda. |
| silencioso | ativar/desativar o registro em log padrão é falso, o que significa que o registro em log está ativado |
| loginColor | ativar/desativar cores do util.inspect para ipc.log |
| profundidade do log | defina a profundidade para util.inspect durante ipc.log |
| registrador | a função que recebe a saída do ipc.log; deve receber um único argumento de string |
| maxConexões | este é o número máximo de conexões permitidas em um soquete. Atualmente está sendo configurado apenas em soquetes Unix. Outros tipos de soquete usam os padrões do sistema. |
| tente novamente | este é o tempo em milissegundos que um cliente esperará antes de tentar se reconectar a um servidor se a conexão for perdida. Isso não afeta os soquetes UDP, pois eles não possuem um relacionamento cliente-servidor como os soquetes Unix e os soquetes TCP. |
| maxRetries | se definido, representa o número máximo de novas tentativas após cada desconexão antes de desistir e encerrar completamente uma conexão específica |
| parar de tentar novamente | O padrão é falso, o que significa que os clientes continuarão tentando se conectar aos servidores indefinidamente no intervalo de novas tentativas. Se definido como qualquer número, o cliente irá parar de tentar novamente quando esse número for excedido após cada desconexão. Se definido como verdadeiro em tempo real, ele irá parar imediatamente de tentar se conectar, independentemente de maxRetries. Se definido como 0, o cliente NÃO tentará se reconectar. |
| desvincular | O padrão é verdadeiro, o que significa que o módulo cuidará da exclusão do soquete IPC antes da inicialização. Se você usar node-ipc em um ambiente de cluster onde haverá vários ouvintes no mesmo soquete, você deverá definir isso como false e, em seguida, excluir o soquete em seu próprio código. |
| interfaces | usado principalmente ao especificar por qual interface um cliente deve se conectar. veja a documentação do socket.connect na API node.js |
Esses métodos estão disponíveis no Escopo IPC.
ipc.log(a,b,c,d,e...);
ipc.log aceitará qualquer número de argumentos e se ipc.config.silent não estiver definido, ele irá concatenar todos eles com um único espaço '' entre eles e então registrá-los no console. Isso é rápido porque evita que qualquer concatenação aconteça se ipc.config.silent estiver definido true . Dessa forma, se você deixar o registro em vigor, ele quase não terá efeito no desempenho.
O log também usa util.inspect Você pode controlar se deve registrar em cores, a profundidade do log e o destino via 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);
Usado para conectar-se como cliente a soquetes Unix e soquetes Windows locais. Esta é a maneira mais rápida de comunicação entre processos na mesma máquina , pois ignora a placa de rede que o TCP e o UDP devem usar.
| variável | obrigatório | definição |
|---|---|---|
| eu ia | obrigatório | é o ID da string do soquete ao qual está sendo conectado. O soquete com este ID é adicionado ao objeto ipc.of quando criado. |
| caminho | opcional | é o caminho do arquivo de soquete de domínio Unix, se o sistema for Windows, ele será automaticamente convertido em um canal apropriado com as mesmas informações do arquivo de soquete de domínio Unix. Se não for definido, o padrão será ipc.config.socketRoot + ipc.config.appspace + id |
| ligar de volta | opcional | esta é a função a ser executada quando o soquete for criado. |
exemplos de argumentos podem ser omitidos desde que ainda estejam em ordem.
ipc . connectTo ( 'world' ) ;ou usando apenas um id e um retorno de chamada
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
}
)
}
) ;ou definindo explicitamente o caminho
ipc . connectTo (
'world' ,
'myapp.world'
) ;ou definir explicitamente o caminho com retorno de chamada
ipc . connectTo (
'world' ,
'myapp.world' ,
function ( ) {
...
}
) ; ipc.connectToNet(id,host,port,callback)
Usado para conectar-se como cliente a um soquete TCP ou TLS por meio da placa de rede. Isso pode ser local ou remoto; se for local, é recomendável usar a implementação de soquete Unix e Windows de connectTo , pois é muito mais rápido, pois evita completamente a placa de rede.
Para soquetes TLS e SSL, consulte os documentos TLS e SSL do node-ipc. Eles têm alguns requisitos adicionais e coisas a saber e, portanto, têm seu próprio documento.
| variável | obrigatório | definição |
|---|---|---|
| eu ia | obrigatório | é o ID da string do soquete ao qual está sendo conectado. Para soquetes TCP e TLS, esse ID é adicionado ao objeto ipc.of quando o soquete é criado com uma referência ao soquete. |
| hospedar | opcional | é o host no qual reside o soquete TCP ou TLS. O padrão será ipc.config.networkHost se não for especificado. |
| porta | opcional | a porta na qual reside o soquete TCP ou TLS. |
| ligar de volta | opcional | esta é a função a ser executada quando o soquete for criado. |
exemplos de argumentos podem ser omitidos desde que ainda estejam em ordem.
Portanto, embora o padrão seja: (id,host,port,callback), os exemplos a seguir ainda funcionarão porque ainda estão em ordem (id,port,callback) ou (id,host,callback) ou (id,port) etc. .
ipc . connectToNet ( 'world' ) ;ou usando apenas um id e um retorno de chamada
ipc . connectToNet (
'world' ,
function ( ) {
...
}
) ;ou definir explicitamente o host e o caminho
ipc . connectToNet (
'world' ,
'myapp.com' , serve ( path , callback )
3435
) ;ou apenas definindo explicitamente a porta e o retorno de chamada
ipc . connectToNet (
'world' ,
3435 ,
function ( ) {
...
}
) ; ipc.disconnect(id)
Usado para desconectar um cliente de um soquete Unix, Windows, TCP ou TLS. O soquete e sua referência serão removidos da memória e do escopo ipc.of Isso pode ser local ou remoto. Os clientes UDP não mantêm conexões e portanto não existem Clientes e este método não tem valor para eles.
| variável | obrigatório | definição |
|---|---|---|
| eu ia | obrigatório | é o ID da string do soquete do qual será desconectado. |
exemplos
ipc . disconnect ( 'world' ) ; ipc.serve(path,callback);
Usado para criar um servidor de soquete Unix local ou um servidor de soquete do Windows ao qual os clientes podem se vincular. O servidor pode emit eventos para Client Sockets específicos ou broadcast eventos para todos os Client Sockets conhecidos.
| variável | obrigatório | definição |
|---|---|---|
| caminho | opcional | Este é o caminho do Arquivo de Socket de Domínio Unix, se o Sistema for Windows, este será automaticamente convertido para um pipe apropriado com as mesmas informações do Arquivo de Socket de Domínio Unix. Se não for definido, o padrão será ipc.config.socketRoot + ipc.config.appspace + id |
| ligar de volta | opcional | Esta é uma função a ser chamada após o servidor ser iniciado. Isso também pode ser feito vinculando um evento ao evento inicial como ipc.server.on('start',function(){}); |
argumentos de exemplos podem ser omitidos, desde que ainda estejam em ordem.
ipc . serve ( ) ;ou especificando retorno de chamada
ipc . serve (
function ( ) { ... }
) ;ou especifique o caminho
ipc . serve (
'/tmp/myapp.myservice'
) ;ou especificando tudo
ipc . serve (
'/tmp/myapp.myservice' ,
function ( ) { ... }
) ; serveNet(host,port,UDPType,callback)
Usado para criar servidores de soquete TCP, TLS ou UDP aos quais os clientes podem se vincular ou outros servidores podem enviar dados. O servidor pode emit eventos para Client Sockets específicos ou broadcast eventos para todos os Client Sockets conhecidos.
| variável | obrigatório | definição |
|---|---|---|
| hospedar | opcional | Se não for especificado, o padrão é o primeiro endereço em os.networkInterfaces(). Para servidores TCP, TLS e UDP, provavelmente será 127.0.0.1 ou ::1 |
| porta | opcional | A porta na qual o servidor de soquete TCP, UDP ou TLS será vinculado; o padrão é 8000 se não for especificado |
| Tipo UDP | opcional | Se definido, isso criará o servidor como um soquete UDP. 'udp4' ou 'udp6' são valores válidos. O padrão é não ser definido. Ao usar o udp6, certifique-se de especificar um host IPv6 válido, como ::1 |
| ligar de volta | opcional | Função a ser chamada quando o servidor for criado |
exemplos de argumentos podem ser omitidos desde que ainda estejam em ordem.
servidor tcp padrão
ipc . serveNet ( ) ;servidor udp padrão
ipc . serveNet ( 'udp4' ) ;ou especificando servidor TCP com retorno de chamada
ipc . serveNet (
function ( ) { ... }
) ;ou especificando servidor UDP com retorno de chamada
ipc . serveNet (
'udp4' ,
function ( ) { ... }
) ;ou especifique a porta
ipc . serveNet (
3435
) ;ou especificando tudo TCP
ipc . serveNet (
'MyMostAwesomeApp.com' ,
3435 ,
function ( ) { ... }
) ;ou especificando tudo UDP
ipc . serveNet (
'MyMostAwesomeApp.com' ,
3435 ,
'udp4' ,
function ( ) { ... }
) ;| variável | definição |
|---|---|
| ipc.de | É aqui que as referências de conexão de soquete serão armazenadas ao conectar-se a eles como um cliente por meio de ipc.connectTo ou iupc.connectToNet . Eles serão armazenados com base no ID usado para criá-los, por exemplo: ipc.of.mySocket |
| ipc.servidor | Esta é uma referência ao servidor criado por ipc.serve ou ipc.serveNet |
| método | definição |
|---|---|
| começar | começar a servir precisa ligar para serve ou serveNet primeiro para configurar o servidor |
| parar | feche o servidor e pare de servir |
| nome do evento | parâmetros | definição |
|---|---|---|
| erro | err obj | acionado quando ocorreu um erro |
| conectar | acionado quando o soquete está conectado | |
| desconectar | acionado pelo cliente quando o soquete foi desconectado do servidor | |
| soquete.desconectado | soquete destruídoSocketID | acionado pelo servidor quando um soquete do cliente é desconectado |
| destruir | acionado quando o soquete for totalmente destruído, nenhuma nova tentativa automática acontecerá e todas as referências desaparecerão. | |
| dados | buffer | acionado quando ipc.config.rawBuffer é verdadeiro e uma mensagem é recebida. |
| seu tipo de evento | dados do seu evento | acionado quando uma mensagem JSON é recebida. O nome do evento será a string do tipo da sua mensagem e o parâmetro será o objeto de dados da sua mensagem, por exemplo: { type:'myEvent',data:{a:1}} |
Às vezes você pode precisar de instâncias explícitas e independentes de node-ipc. Apenas para esses cenários, expusemos a classe IPC principal no singleton 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' ;Você pode encontrar Exemplos Avançados na pasta de exemplos. Nos exemplos você encontrará demonstrações mais complexas, incluindo exemplos de vários clientes.
O servidor é o processo que mantém um soquete para IPC aberto. Vários soquetes podem se conectar a este servidor e conversar com ele. Também pode transmitir para todos os clientes ou emitir para um cliente específico. Este é o exemplo mais básico que funcionará para soquetes Unix e Windows locais, bem como para soquetes TCP de rede local ou 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 ( ) ; O cliente se conecta ao soquete do servidor para comunicação entre processos. O soquete receberá eventos emitidos especificamente para ele, bem como eventos que são transmitidos no soquete pelo servidor. Este é o exemplo mais básico que funcionará tanto para soquetes Unix locais quanto para soquetes TCP de rede local ou 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 ) ;
}
) ;
}
) ; Os soquetes UDP são diferentes dos soquetes Unix, Windows e TCP porque devem estar vinculados a uma porta exclusiva em sua máquina para receber mensagens. Por exemplo, um cliente TCP, Unix ou Windows Socket pode simplesmente conectar-se a um servidor TCP, Unix ou Windows Socket separado. Esse cliente poderia então trocar, enviar e receber dados na porta ou local do servidor. Os soquetes UDP não podem fazer isso. Eles devem se vincular a uma porta para receber ou enviar dados.
Isso significa que um cliente e um servidor UDP são a mesma coisa porque, para receber dados, um soquete UDP deve ter sua própria porta para receber dados, e apenas um processo pode usar essa porta por vez. Isso também significa que para emit ou broadcast dados o servidor UDP precisará conhecer o host e a porta do Socket para o qual pretende transmitir os dados.
Este é o exemplo mais básico que funcionará para soquetes UDP locais e 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 ( ) ; observe que definimos a porta aqui como 8001 porque o servidor mundial já está usando o ipc.config.networkPort padrão de 8000. Portanto, não podemos vincular a 8000 enquanto o mundo o estiver 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 ( ) ; Soquetes binários ou buffer podem ser usados com qualquer um dos tipos de soquete acima, porém a forma como os eventos de dados são emitidos é um pouco diferente. Eles podem ser úteis ao trabalhar com sistemas embarcados ou processos C/C++. Você pode até certificar-se de combinar a digitação de string C ou C++.
Ao configurar um soquete rawBuffer, você deve especificá-lo da seguinte forma:
ipc . config . rawBuffer = true ; Você também pode especificar seu tipo de codificação. O padrão é utf8
ipc . config . encoding = 'utf8' ;emitir buffer de string:
//server
ipc . server . emit (
socket ,
'hello'
) ;
//client
ipc . of . world . emit (
'hello'
)emitir buffer 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 buffer de array binário ou hexadecimal, isso é melhor para transferência de dados em tempo real, especialmente ao conectar-se a processos C ou C++ ou sistemas embarcados:
ipc . config . encoding = 'hex' ;
//server
ipc . server . emit (
socket ,
[ 0x05 , 0x6d , 0x5c ]
) ;
//client
ipc . server . emit (
[ 0x05 , 0x6d , 0x5c ]
) ;Escrever buffers explícitos, tipos int, doubles, floats etc., bem como dados big endian e little endian em buffer bruto, extremamente valioso ao conectar-se a processos C ou C++ ou sistemas embarcados (veja informações mais detalhadas sobre buffers, bem como UInt, Int , duplo etc. aqui)[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 pode ser usado com o módulo de cluster do Node.js para fornecer a capacidade de ter vários leitores para um único soquete. Fazer isso requer simplesmente que você defina a propriedade unlink na configuração como false e tome cuidado para desvincular o caminho do soquete no processo mestre:
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' ) ;
}
) ;
} Veja o arquivo de licença do MIT.
Desculpe.
