node ipc
10.1.0
un module nodejs pour la communication inter-processus locale et distante avec prise en charge complète de Linux, Mac et Windows. Il prend également en charge toutes les formes de communication par socket, depuis les sockets Unix et Windows de bas niveau jusqu'aux sockets UDP et sécurisés TLS et TCP.
Une excellente solution pour les réseaux neuronaux multiprocessus complexes dans 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 ;
infos npm : voir les tendances et les statistiques npm pour node-ipc
Informations GitHub :
Informations sur la couverture du code :
Exécutez npm run coverage pour héberger une version locale du rapport de couverture sur localhost:8080 Il s'agit du même format qu'Istanbul et New York. Cela devrait être très familier.
Test effectué avec vanilla-test
vanilla-test s'intègre à c8 pour une couverture ESM native sans avoir besoin de transpiler votre code. Au moment de la rédaction de cet article, c’est le seul moyen de tester nativement ESM, et c’est incroyable !
Sites Web de détails du forfait :
Ce travail est sous licence via la licence MIT.
les dernières versions de node-ipc peuvent fonctionner avec l'indicateur --harmony. Officiellement, nous prenons en charge les nœuds v4 et plus récents avec es5 et es6
npm test exécutera les tests jasmine avec istanbul pour node-ipc et générera un rapport de couverture dans le dossier spec.
Vous souhaiterez peut-être installer Jasmine et Istanbul à l'échelle mondiale avec sudo npm install -g jasmine istanbul
| Taper | Stabilité | Définition |
|---|---|---|
| Socket Unix ou Windows Socket | Écurie | Offre une communication ultra-rapide à Linux, Mac et Windows et évite la carte réseau pour réduire les frais généraux et la latence. Exemples de sockets Unix et Windows locaux |
| Prise TCP | Écurie | Offre la communication la plus fiable sur le réseau. Peut également être utilisé pour l'IPC local, mais est plus lent que l'implémentation de socket Unix de #1 car les sockets TCP passent par la carte réseau, contrairement aux sockets Unix et Windows. Exemples de sockets TCP de réseau local ou distant |
| Prise TLS | Écurie | Socket réseau configurable et sécurisé sur SSL. Équivalent à https. Documentation TLS/SSL |
| Prises UDP | Écurie | Offre la communication réseau la plus rapide . UDP est moins fiable mais beaucoup plus rapide que TCP. Il est préférable de l'utiliser pour diffuser des données non critiques telles que des données audio, vidéo ou de jeu multijoueur, car il peut supprimer des paquets en fonction de la connectivité réseau et d'autres facteurs. UDP peut également être utilisé pour l'IPC local, mais il est plus lent que l'implémentation Unix Socket ou Windows Socket de #1, car les sockets UDP passent par la carte réseau, contrairement aux sockets Unix et Windows. Exemples de sockets UDP de réseau local ou distant |
| Système d'exploitation | Prises prises en charge |
|---|---|
| Linux | Unix, Posix, TCP, TLS, UDP |
| Mac | Unix, Posix, TCP, TLS, UDP |
| Gagner | Windows, TCP, TLS, UDP |
ipc.config
Définissez ces variables dans la portée ipc.config pour écraser ou définir les valeurs par défaut.
{
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 | documentation |
|---|---|
| espace d'application | utilisé pour l'espace de noms Unix Socket (Unix Domain Socket). S'il n'est pas défini spécifiquement, le socket de domaine Unix combinera socketRoot, appspace et id pour former le chemin de socket Unix pour la création ou la liaison. Ceci est disponible dans le cas où de nombreuses applications sont en cours d'exécution sur votre système, vous pouvez avoir plusieurs sockets avec le même identifiant, mais si vous modifiez l'espace d'application, vous aurez toujours des sockets uniques spécifiques à l'application. |
| socketRoot | le répertoire dans lequel créer ou lier à un socket Unix |
| identifiant | l'identifiant de ce socket ou de ce service |
| réseauHôte | l'hôte local ou distant sur lequel les sockets TCP, TLS ou UDP doivent se connecter |
| port réseau | le port par défaut sur lequel les sockets TCP, TLS ou UDP doivent se connecter |
| lisibleTout | rend le canal lisible pour tous les utilisateurs, y compris les services Windows |
| inscriptibleTout | rend le canal accessible en écriture pour tous les utilisateurs, y compris les services Windows |
| codage | l'encodage par défaut pour les données envoyées sur les sockets. Principalement utilisé si rawBuffer est défini sur true. Les valeurs valides sont : ascii utf8 utf16le ucs2 base64 hex . |
| tampon brut | si c'est vrai, les données seront envoyées et reçues en tant que nœud brut Buffer PAS un Object en tant que JSON. C'est idéal pour l'IPC binaire ou hexadécimal et pour communiquer avec d'autres processus dans des langages comme C et C++. |
| délimiteur | le délimiteur à la fin de chaque paquet de données. |
| synchroniser | requêtes synchrones. Les clients n'enverront pas de nouvelles requêtes tant que le serveur n'aura pas répondu. |
| silencieux | activer/désactiver la journalisation par défaut est faux, ce qui signifie que la journalisation est activée |
| connexionCouleur | activer/désactiver les couleurs util.inspect pour ipc.log |
| journalProfondeur | définir la profondeur de util.inspect pendant ipc.log |
| enregistreur | la fonction qui reçoit la sortie de ipc.log ; devrait prendre un seul argument de chaîne |
| maxConnexions | c'est le nombre maximum de connexions autorisées à un socket. Il n’est actuellement configuré que sur les sockets Unix. D'autres types de socket utilisent les valeurs par défaut du système. |
| réessayer | c'est le temps en millisecondes qu'un client attendra avant d'essayer de se reconnecter à un serveur si la connexion est perdue. Cela n'affecte pas les sockets UDP car ils n'ont pas de relation client-serveur comme les sockets Unix et les sockets TCP. |
| maxRetries | s'il est défini, il représente le nombre maximum de tentatives après chaque déconnexion avant d'abandonner et de tuer complètement une connexion spécifique |
| arrêter de réessayer | La valeur par défaut est false, ce qui signifie que les clients continueront à réessayer de se connecter aux serveurs indéfiniment selon l'intervalle de nouvelle tentative. S'il est défini sur n'importe quel nombre, le client cessera de réessayer lorsque ce nombre est dépassé après chaque déconnexion. S'il est défini sur true en temps réel, il cessera immédiatement d'essayer de se connecter, quels que soient les maxRetries. S'il est défini sur 0, le client n'essaiera PAS de se reconnecter. |
| dissocier | La valeur par défaut est true, ce qui signifie que le module se chargera de supprimer le socket IPC avant le démarrage. Si vous utilisez node-ipc dans un environnement en cluster où il y aura plusieurs écouteurs sur le même socket, vous devez définir ceci sur false puis prendre soin de supprimer le socket dans votre propre code. |
| interfaces | principalement utilisé pour spécifier l'interface via laquelle un client doit se connecter. voir la documentation socket.connect dans l'API node.js |
Ces méthodes sont disponibles dans le champ d'application IPC.
ipc.log(a,b,c,d,e...);
ipc.log acceptera n'importe quel nombre d'arguments et si ipc.config.silent n'est pas défini, il les concatènera tous avec un seul espace « » entre eux, puis les enregistrera dans la console. C'est rapide car cela empêche toute concaténation si ipc.config.silent est défini sur true . De cette façon, si vous laissez votre connexion en place, cela ne devrait avoir presque aucun effet sur les performances.
Le journal utilise également util.inspect Vous pouvez contrôler s'il doit se connecter en couleur, la profondeur du journal et la destination 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);
Utilisé pour se connecter en tant que client aux sockets Unix et Windows locaux. Il s'agit du moyen le plus rapide pour communiquer entre les processus d'une même machine, car il contourne la carte réseau que TCP et UDP doivent tous deux utiliser.
| variable | requis | définition |
|---|---|---|
| identifiant | requis | est l'identifiant de chaîne du socket auquel vous êtes connecté. Le socket avec cet identifiant est ajouté à l'objet ipc.of lors de sa création. |
| chemin | facultatif | est le chemin du fichier de socket de domaine Unix. Si le système est Windows, il sera automatiquement converti en un canal approprié avec les mêmes informations que le fichier de socket de domaine Unix. S'il n'est pas défini, la valeur par défaut sera ipc.config.socketRoot + ipc.config.appspace + id |
| rappel | facultatif | c'est la fonction à exécuter lorsque le socket a été créé. |
Les exemples d'arguments peuvent être omis tant qu'ils sont toujours en ordre.
ipc . connectTo ( 'world' ) ;ou en utilisant simplement un identifiant et un rappel
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 en définissant explicitement le chemin
ipc . connectTo (
'world' ,
'myapp.world'
) ;ou définir explicitement le chemin avec rappel
ipc . connectTo (
'world' ,
'myapp.world' ,
function ( ) {
...
}
) ; ipc.connectToNet(id,host,port,callback)
Utilisé pour se connecter en tant que client à un socket TCP ou TLS via la carte réseau. Cela peut être local ou distant, si local, il est recommandé d'utiliser plutôt l'implémentation de socket Unix et Windows de connectTo car elle est beaucoup plus rapide car elle évite complètement la carte réseau.
Pour les sockets TLS et SSL, consultez la documentation node-ipc TLS et SSL. Ils ont quelques exigences supplémentaires et des choses à savoir et ont donc leur propre document.
| variable | requis | définition |
|---|---|---|
| identifiant | requis | est l'identifiant de chaîne du socket auquel vous êtes connecté. Pour les sockets TCP et TLS, cet identifiant est ajouté à l'objet ipc.of lorsque le socket est créé avec une référence au socket. |
| hôte | facultatif | est l'hôte sur lequel réside le socket TCP ou TLS. La valeur par défaut sera ipc.config.networkHost si elle n'est pas spécifiée. |
| port | facultatif | le port sur lequel réside le socket TCP ou TLS. |
| rappel | facultatif | c'est la fonction à exécuter lorsque le socket a été créé. |
Les exemples d'arguments peuvent être omis tant qu'ils sont toujours en ordre.
Ainsi, même si la valeur par défaut est : (id,host,port,callback), les exemples suivants fonctionneront toujours car ils sont toujours dans l'ordre (id,port,callback) ou (id,host,callback) ou (id,port) etc. .
ipc . connectToNet ( 'world' ) ;ou en utilisant simplement un identifiant et un rappel
ipc . connectToNet (
'world' ,
function ( ) {
...
}
) ;ou en définissant explicitement l'hôte et le chemin
ipc . connectToNet (
'world' ,
'myapp.com' , serve ( path , callback )
3435
) ;ou uniquement en définissant explicitement le port et le rappel
ipc . connectToNet (
'world' ,
3435 ,
function ( ) {
...
}
) ; ipc.disconnect(id)
Utilisé pour déconnecter un client d'un socket Unix, Windows, TCP ou TLS. Le socket et sa référence seront supprimés de la mémoire et de la portée ipc.of Cela peut être local ou distant. Les clients UDP ne maintiennent pas de connexions et il n'y a donc pas de clients et cette méthode n'a aucune valeur pour eux.
| variable | requis | définition |
|---|---|---|
| identifiant | requis | est l'identifiant de chaîne du socket à partir duquel se déconnecter. |
exemples
ipc . disconnect ( 'world' ) ; ipc.serve(path,callback);
Utilisé pour créer un serveur Socket Unix local ou un serveur Socket Windows auquel les clients peuvent se lier. Le serveur peut emit des événements vers des sockets client spécifiques ou broadcast des événements vers tous les sockets client connus.
| variable | requis | définition |
|---|---|---|
| chemin | facultatif | Il s'agit du chemin du fichier de socket de domaine Unix. Si le système est Windows, il sera automatiquement converti en un canal approprié avec les mêmes informations que le fichier de socket de domaine Unix. S'il n'est pas défini, la valeur par défaut sera ipc.config.socketRoot + ipc.config.appspace + id |
| rappel | facultatif | Il s'agit d'une fonction à appeler après le démarrage du serveur. Cela peut également être fait en liant un événement à l'événement de démarrage comme ipc.server.on('start',function(){}); |
Les exemples d'arguments peuvent être omis tant qu'ils sont toujours en ordre.
ipc . serve ( ) ;ou en spécifiant le rappel
ipc . serve (
function ( ) { ... }
) ;ou spécifiez le chemin
ipc . serve (
'/tmp/myapp.myservice'
) ;ou en précisant tout
ipc . serve (
'/tmp/myapp.myservice' ,
function ( ) { ... }
) ; serveNet(host,port,UDPType,callback)
Utilisé pour créer un serveur Socket TCP, TLS ou UDP auquel les clients peuvent se lier ou auquel d'autres serveurs peuvent envoyer des données. Le serveur peut emit des événements vers des sockets client spécifiques ou broadcast des événements vers tous les sockets client connus.
| variable | requis | définition |
|---|---|---|
| hôte | facultatif | Si non spécifié, la valeur par défaut est la première adresse dans os.networkInterfaces(). Pour les serveurs TCP, TLS et UDP, il s'agira probablement de 127.0.0.1 ou ::1 |
| port | facultatif | Le port sur lequel le serveur TCP, UDP ou TLS Socket sera lié, la valeur par défaut est 8000 s'il n'est pas spécifié |
| TypeUDP | facultatif | Si défini, cela créera le serveur en tant que socket UDP. « udp4 » ou « udp6 » sont des valeurs valides. Par défaut, cela n'est pas défini. Lorsque vous utilisez udp6, assurez-vous de spécifier un hôte IPv6 valide, comme ::1 |
| rappel | facultatif | Fonction à appeler lors de la création du serveur |
Les exemples d'arguments peuvent être omis tant qu'ils sont toujours en ordre.
serveur TCP par défaut
ipc . serveNet ( ) ;serveur UDP par défaut
ipc . serveNet ( 'udp4' ) ;ou en spécifiant le serveur TCP avec rappel
ipc . serveNet (
function ( ) { ... }
) ;ou en spécifiant le serveur UDP avec rappel
ipc . serveNet (
'udp4' ,
function ( ) { ... }
) ;ou spécifiez le port
ipc . serveNet (
3435
) ;ou en spécifiant tout TCP
ipc . serveNet (
'MyMostAwesomeApp.com' ,
3435 ,
function ( ) { ... }
) ;ou en spécifiant tout UDP
ipc . serveNet (
'MyMostAwesomeApp.com' ,
3435 ,
'udp4' ,
function ( ) { ... }
) ;| variable | définition |
|---|---|
| ipc.de | C'est ici que les références de connexion aux sockets seront stockées lors de la connexion à celles-ci en tant que client via ipc.connectTo ou iupc.connectToNet . Ils seront stockés en fonction de l'ID utilisé pour les créer, par exemple : ipc.of.mySocket |
| ipc.server | Ceci est une référence au serveur créé par ipc.serve ou ipc.serveNet |
| méthode | définition |
|---|---|
| commencer | commencer à servir, vous devez d'abord appeler serve ou serveNet pour configurer le serveur |
| arrêt | fermez le serveur et arrêtez de servir |
| nom de l'événement | paramètres | définition |
|---|---|---|
| erreur | erreur obj | déclenché lorsqu'une erreur s'est produite |
| connecter | déclenché lorsque la prise est connectée | |
| déconnecter | déclenché par le client lorsque le socket s'est déconnecté du serveur | |
| socket.déconnecté | socket détruitSocketID | déclenché par le serveur lorsqu'un socket client s'est déconnecté |
| détruire | déclenché lorsque le socket a été totalement détruit, aucune autre tentative automatique ne se produira et toutes les références auront disparu. | |
| données | tampon | déclenché lorsque ipc.config.rawBuffer est vrai et qu'un message est reçu. |
| votre type d'événement | les données de votre événement | déclenché lorsqu'un message JSON est reçu. Le nom de l'événement sera la chaîne de type de votre message et le paramètre sera l'objet de données de votre message, par exemple : { type:'myEvent',data:{a:1}} |
Parfois, vous pourriez avoir besoin d'instances explicites et indépendantes de node-ipc. Juste pour de tels scénarios, nous avons exposé la classe IPC principale sur le 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' ;Vous pouvez trouver des exemples avancés dans le dossier des exemples. Dans les exemples, vous trouverez des démos plus complexes comprenant des exemples multi-clients.
Le serveur est le processus qui maintient un socket pour IPC ouvert. Plusieurs sockets peuvent se connecter à ce serveur et lui parler. Il peut également diffuser à tous les clients ou émettre vers un client spécifique. Il s'agit de l'exemple le plus basique qui fonctionnera pour les sockets Unix et Windows locaux ainsi que pour les sockets TCP de réseau local ou distant.
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 ( ) ; Le client se connecte au socket des serveurs pour Inter Process Communication. Le socket recevra les événements qui lui sont spécifiquement émis ainsi que les événements qui sont diffusés sur le socket par le serveur. Il s'agit de l'exemple le plus basique qui fonctionnera à la fois pour les sockets Unix locaux et les sockets TCP du réseau local ou distant.
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 ) ;
}
) ;
}
) ; Les sockets UDP sont différents des sockets Unix, Windows et TCP car ils doivent être liés à un port unique sur leur machine pour recevoir des messages. Par exemple, un client TCP, Unix ou Windows Socket peut simplement se connecter à un serveur TCP, Unix ou Windows Socket distinct. Ce client pourrait alors échanger, envoyer et recevoir, des données sur le port ou l'emplacement du serveur. Les sockets UDP ne peuvent pas faire cela. Ils doivent se lier à un port pour recevoir ou envoyer des données.
Cela signifie qu'un client et un serveur UDP sont la même chose car pour recevoir des données, un socket UDP doit avoir son propre port sur lequel recevoir des données, et un seul processus peut utiliser ce port à la fois. Cela signifie également que pour emit ou broadcast des données, le serveur UDP devra connaître l'hôte et le port du Socket vers lequel il a l'intention de diffuser les données.
Il s'agit de l'exemple le plus basique qui fonctionnera pour les sockets UDP locaux et distants.
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 ( ) ; Notez que nous définissons ici le port sur 8001 car le serveur mondial utilise déjà le port ipc.config.networkPort par défaut de 8000. Nous ne pouvons donc pas nous lier à 8000 pendant que le monde l'utilise.
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 ( ) ; Les sockets binaires ou tampons peuvent être utilisés avec n'importe lequel des types de sockets ci-dessus, mais la manière dont les événements de données sont émis est légèrement différente. Ceux-ci peuvent s'avérer utiles si vous travaillez avec des systèmes embarqués ou des processus C/C++. Vous pouvez même vous assurer de faire correspondre le typage de chaîne C ou C++.
Lors de la configuration d'un socket rawBuffer vous devez le spécifier comme tel :
ipc . config . rawBuffer = true ; Vous pouvez également spécifier son type d'encodage. La valeur par défaut est utf8
ipc . config . encoding = 'utf8' ;émettre un tampon de chaîne :
//server
ipc . server . emit (
socket ,
'hello'
) ;
//client
ipc . of . world . emit (
'hello'
)émettre un tampon de tableau d'octets :
//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 ]
) ;émet un tampon de tableau binaire ou hexadécimal, ce qui est idéal pour le transfert de données en temps réel, en particulier lors de la connexion à des processus C ou C++, ou à des systèmes embarqués :
ipc . config . encoding = 'hex' ;
//server
ipc . server . emit (
socket ,
[ 0x05 , 0x6d , 0x5c ]
) ;
//client
ipc . server . emit (
[ 0x05 , 0x6d , 0x5c ]
) ;L'écriture de tampons explicites, de types int, de doubles, de flottants, etc. ainsi que de données big endian et little endian dans un tampon brut est extrêmement utile lors de la connexion à des processus C ou C++ ou à des systèmes embarqués (voir des informations plus détaillées sur les tampons ainsi que UInt, Int , double etc. ici)[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 peut être utilisé avec le module de cluster de Node.js pour offrir la possibilité d'avoir plusieurs lecteurs pour un seul socket. Pour ce faire, vous devez simplement définir la propriété unlink dans la configuration sur false et prendre soin de dissocier le chemin du socket dans le processus maître :
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' ) ;
}
) ;
} Voir le fichier de licence MIT.
Je suis désolé.
