First Commit of new way of building the Platform

TaskServer/node_modules/node-ipc/example/TCPSocket/Multi-Client-Broadcast/goodbye-client.js

@@ -0,0 +1,44 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'goodbye';
+ipc.config.retry= 1500;
+ipc.config.maxRetries= 10;
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : 'goodbye'
+                    }
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'kill.connection',
+            function(data){
+                ipc.log('world requested kill.connection');
+                ipc.disconnect('world');
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TCPSocket/Multi-Client-Broadcast/hello-client.js

@@ -0,0 +1,50 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.maxRetries=10;
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : 'hello'
+                    }
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'app.message',
+            function(data){
+                ipc.log('got a message from world : ', data.message);
+            }
+        );
+        ipc.of.world.on(
+            'kill.connection',
+            function(data){
+                ipc.log('world requested kill.connection');
+                ipc.disconnect('world');
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TCPSocket/Multi-Client-Broadcast/world-server.js

@@ -0,0 +1,51 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+
+var messages={
+    goodbye:false,
+    hello:false
+};
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'app.message',
+            function(data,socket){
+                ipc.log('got a message from', (data.id), (data.message));
+                messages[data.id]=true;
+                ipc.server.emit(
+                    socket,
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : data.message+' world!'
+                    }
+                );
+
+                if(messages.hello && messages.goodbye){
+                    ipc.log('got all required events, telling clients to kill connection');
+                    ipc.server.broadcast(
+                        'kill.connection',
+                        {
+                            id:ipc.config.id
+                        }
+                    );
+                }
+            }
+        );
+    }
+);
+
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/TCPSocket/basic/hello-client.js

@@ -0,0 +1,39 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'message',
+                    'hello'
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'message',
+            function(data){
+                ipc.log('got a message from world : ', data);
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TCPSocket/basic/world-server.js

@@ -0,0 +1,44 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.maxConnections=1;
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'message',
+            function(data,socket){
+                ipc.log('got a message : ', data);
+                ipc.server.emit(
+                    socket,
+                    'message',
+                    data+' world!'
+                );
+            }
+        );
+
+        ipc.server.on(
+            'socket.disconnected',
+            function(data,socket){
+                console.log('DISCONNECTED\n\n',arguments);
+            }
+        );
+    }
+);
+
+ipc.server.on(
+    'error',
+    function(err){
+        ipc.log('Got an ERROR!',err);
+    }
+);
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/TCPSocket/basicSync/hello-client.js

@@ -0,0 +1,46 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.sync= true;
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+
+                //queue up a bunch of requests to be sent synchronously
+                for(var i=0; i<10; i++){
+                    ipc.of.world.emit(
+                        'message',
+                        'hello'+i
+                    );
+                }
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'message',
+            function(data){
+                ipc.log('got a message from world : ', data,'\n\n');
+            }
+        );
+    }
+);
+
+console.log(ipc);

TaskServer/node_modules/node-ipc/example/TCPSocket/basicSync/world-server.js

@@ -0,0 +1,45 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.sync = true;
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'message',
+            function(data,socket){
+                ipc.log('got a message : ', data);
+                //fake some synch procedural code
+                setTimeout(
+                    function(){
+                        ipc.server.emit(
+                            socket,
+                            'message',
+                            data+' world!'
+                        );
+                    },
+                    3000
+                );
+            }
+        );
+
+        ipc.server.on(
+            'socket.disconnected',
+            function(data,socket){
+                console.log(arguments);
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/TCPSocket/rawBuffer/hello-client.js

@@ -0,0 +1,35 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.rawBuffer=true;
+ipc.config.encoding='ascii';
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'hello'
+                );
+            }
+        );
+
+        ipc.of.world.on(
+            'data',
+            function(data){
+                ipc.log('got a message from world : ', data,data.toString());
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TCPSocket/rawBuffer/world.server.js

@@ -0,0 +1,40 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.rawBuffer=true;
+ipc.config.encoding='ascii';
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'connect',
+            function(socket){
+                ipc.server.emit(
+                    socket,
+                    'hello'
+                );
+            }
+        );
+
+        ipc.server.on(
+            'data',
+            function(data,socket){
+                ipc.log('got a message', data,data.toString());
+                ipc.server.emit(
+                    socket,
+                    'goodbye'
+                );
+            }
+        );
+    }
+);
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/TLSSocket/Multi-Client-Broadcast-basic/goodbye-client.js

@@ -0,0 +1,47 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'goodbye';
+ipc.config.retry= 1500;
+ipc.config.maxRetries= 10;
+ipc.config.tls={
+    rejectUnauthorized:false
+};
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : 'goodbye'
+                    }
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'kill.connection',
+            function(data){
+                ipc.log('world requested kill.connection');
+                ipc.disconnect('world');
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TLSSocket/Multi-Client-Broadcast-basic/hello-client.js

@@ -0,0 +1,53 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.maxRetries=10;
+ipc.config.tls={
+    rejectUnauthorized:false
+};
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : 'hello'
+                    }
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'app.message',
+            function(data){
+                ipc.log('got a message from world : ', data.message);
+            }
+        );
+        ipc.of.world.on(
+            'kill.connection',
+            function(data){
+                ipc.log('world requested kill.connection');
+                ipc.disconnect('world');
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TLSSocket/Multi-Client-Broadcast-basic/world-server.js

@@ -0,0 +1,55 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.tls={
+    public: __dirname+'/../../../local-node-ipc-certs/server.pub',
+    private: __dirname+'/../../../local-node-ipc-certs/private/server.key'
+};
+
+var messages={
+    goodbye:false,
+    hello:false
+};
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'app.message',
+            function(data,socket){
+                ipc.log('got a message from', (data.id), (data.message));
+                messages[data.id]=true;
+                ipc.server.emit(
+                    socket,
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : data.message+' world!'
+                    }
+                );
+
+                if(messages.hello && messages.goodbye){
+                    ipc.log('got all required events, telling clients to kill connection');
+                    ipc.server.broadcast(
+                        'kill.connection',
+                        {
+                            id:ipc.config.id
+                        }
+                    );
+                }
+            }
+        );
+    }
+);
+
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/TLSSocket/basic-local-only/hello-client.js

@@ -0,0 +1,42 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.tls={
+    rejectUnauthorized:false
+};
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'message',
+                    'hello'
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'message',
+            function(data){
+                ipc.log('got a message from world : ', data);
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TLSSocket/basic-local-only/world-server.js

@@ -0,0 +1,42 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+//node-ipc will default to its local certs
+ipc.config.tls={
+    rejectUnauthorized:false
+};
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'message',
+            function(data,socket){
+                ipc.log('got a message : ', data);
+                ipc.server.emit(
+                    socket,
+                    'message',
+                    data+' world!'
+                );
+            }
+        );
+
+        ipc.server.on(
+            'socket.disconnected',
+            function(data,socket){
+                console.log(arguments);
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/TLSSocket/basic-more-secure/hello-client.js

@@ -0,0 +1,47 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.tls={
+    private: __dirname+'/../../../local-node-ipc-certs/private/client.key',
+    public: __dirname+'/../../../local-node-ipc-certs/client.pub',
+    rejectUnauthorized:false,
+    trustedConnections: [
+        __dirname+'/../../../local-node-ipc-certs/server.pub'
+    ]
+};
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'message',
+                    'hello'
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'message',
+            function(data){
+                ipc.log('got a message from world : ', data);
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TLSSocket/basic-more-secure/world-server.js

@@ -0,0 +1,48 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.tls={
+    public: __dirname+'/../../../local-node-ipc-certs/server.pub',
+    private: __dirname+'/../../../local-node-ipc-certs/private/server.key',
+    dhparam: __dirname+'/../../../local-node-ipc-certs/private/dhparam.pem',
+    requestCert: true,
+    rejectUnauthorized:false,
+    trustedConnections: [
+        __dirname+'/../../../local-node-ipc-certs/client.pub'
+    ]
+};
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'message',
+            function(data,socket){
+                ipc.log('got a message : ', data);
+                ipc.server.emit(
+                    socket,
+                    'message',
+                    data+' world!'
+                );
+            }
+        );
+
+        ipc.server.on(
+            'socket.disconnected',
+            function(data,socket){
+                console.log(arguments);
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/TLSSocket/basic-most-secure/hello-client.js

@@ -0,0 +1,48 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.networkHost='localhost';
+ipc.config.tls={
+    private: __dirname+'/../../../local-node-ipc-certs/private/client.key',
+    public: __dirname+'/../../../local-node-ipc-certs/client.pub',
+    rejectUnauthorized:true,
+    trustedConnections: [
+        __dirname+'/../../../local-node-ipc-certs/server.pub'
+    ]
+};
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'message',
+                    'hello'
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'message',
+            function(data){
+                ipc.log('got a message from world : ', data);
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TLSSocket/basic-most-secure/world-server.js

@@ -0,0 +1,49 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.networkHost='localhost';
+ipc.config.tls={
+    public: __dirname+'/../../../local-node-ipc-certs/server.pub',
+    private: __dirname+'/../../../local-node-ipc-certs/private/server.key',
+    dhparam: __dirname+'/../../../local-node-ipc-certs/private/dhparam.pem',
+    requestCert: true,
+    rejectUnauthorized:true,
+    trustedConnections: [
+        __dirname+'/../../../local-node-ipc-certs/client.pub'
+    ]
+};
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'message',
+            function(data,socket){
+                ipc.log('got a message : ', data);
+                ipc.server.emit(
+                    socket,
+                    'message',
+                    data+' world!'
+                );
+            }
+        );
+
+        ipc.server.on(
+            'socket.disconnected',
+            function(data,socket){
+                console.log(arguments);
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/TLSSocket/basic/hello-client.js

@@ -0,0 +1,42 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.tls={
+    rejectUnauthorized:false
+};
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'message',
+                    'hello'
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'message',
+            function(data){
+                ipc.log('got a message from world : ', data);
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TLSSocket/basic/world-server.js

@@ -0,0 +1,42 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.tls={
+    public: __dirname+'/../../../local-node-ipc-certs/server.pub',
+    private: __dirname+'/../../../local-node-ipc-certs/private/server.key'
+};
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'message',
+            function(data,socket){
+                ipc.log('got a message : ', data);
+                ipc.server.emit(
+                    socket,
+                    'message',
+                    data+' world!'
+                );
+            }
+        );
+
+        ipc.server.on(
+            'socket.disconnected',
+            function(data,socket){
+                console.log(arguments);
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/TLSSocket/basicSync/hello-client.js

@@ -0,0 +1,47 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.sync= true;
+ipc.config.tls={
+    rejectUnauthorized:false
+};
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+
+                //queue up a bunch of requests to be sent synchronously
+                for(var i=0; i<10; i++){
+                    ipc.of.world.emit(
+                        'message',
+                        'hello'+i
+                    );
+                }
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'message',
+            function(data){
+                ipc.log('got a message from world : ', data);
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TLSSocket/basicSync/world-server.js

@@ -0,0 +1,48 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.sync= true;
+ipc.config.tls={
+    public: __dirname+'/../../../local-node-ipc-certs/server.pub',
+    private: __dirname+'/../../../local-node-ipc-certs/private/server.key'
+};
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'message',
+            function(data,socket){
+                ipc.log('got a message : ', data);
+                setTimeout(
+                    function(){
+                        ipc.server.emit(
+                            socket,
+                            'message',
+                            data+' world!'
+                        );
+                    },
+                    3000
+                );
+            }
+        );
+
+        ipc.server.on(
+            'socket.disconnected',
+            function(data,socket){
+                console.log(arguments);
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/TLSSocket/rawBuffer-only-works-with-most-secure/hello-client.js

@@ -0,0 +1,45 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.rawBuffer=true;
+ipc.config.encoding='ascii';
+ipc.config.networkHost='localhost';
+
+ipc.config.tls={
+    private: __dirname+'/../../../local-node-ipc-certs/private/client.key',
+    public: __dirname+'/../../../local-node-ipc-certs/client.pub',
+    rejectUnauthorized:true,
+    trustedConnections: [
+        __dirname+'/../../../local-node-ipc-certs/server.pub'
+    ]
+};
+
+ipc.connectToNet(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'hello'
+                );
+            }
+        );
+
+        ipc.of.world.on(
+            'data',
+            function(data){
+                ipc.log('got a message from world : ', data,data.toString());
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/TLSSocket/rawBuffer-only-works-with-most-secure/world.server.js

@@ -0,0 +1,53 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.rawBuffer=true;
+ipc.config.encoding='ascii';
+ipc.config.networkHost='localhost';
+
+ipc.config.tls={
+    public: __dirname+'/../../../local-node-ipc-certs/server.pub',
+    private: __dirname+'/../../../local-node-ipc-certs/private/server.key',
+    dhparam: __dirname+'/../../../local-node-ipc-certs/private/dhparam.pem',
+    requestCert: true,
+    rejectUnauthorized:true,
+    trustedConnections: [
+        __dirname+'/../../../local-node-ipc-certs/client.pub'
+    ]
+};
+
+ipc.serveNet(
+    function(){
+        ipc.server.on(
+            'connect',
+            function(socket){
+                console.log('connection detected');
+                ipc.server.emit(
+                    socket,
+                    'hello'
+                );
+            }
+        );
+
+        ipc.server.on(
+            'data',
+            function(data,socket){
+                ipc.log('got a message', data,data.toString());
+                ipc.server.emit(
+                    socket,
+                    'goodbye'
+                );
+            }
+        );
+    }
+);
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/UDPSocket/Multi-Client-Broadcast/goodbye-client.js

@@ -0,0 +1,48 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * Since there is no client relationship
+ * with UDP sockets sockets are not kept
+ * open.
+ *
+ * This means the order sockets are opened
+ * is important.
+ *
+ * Start World first. Then you can start
+ * hello or goodbye in any order you
+ * choose.
+ *
+ * *************************************/
+
+ipc.config.id = 'goodbye';
+ipc.config.retry= 1500;
+
+ipc.serveNet(
+    8002, //we set the port here because the hello client and world server are already using the default of 8000 and the port 8001. So we can not bind to those while hello and world are connected to them.
+    'udp4',
+    function(){
+        ipc.server.on(
+            'message',
+            function(data){
+                ipc.log('got Data');
+                ipc.log('got a message from ', data.id ,' : ', data.message);
+            }
+        );
+        ipc.server.emit(
+            {
+                address : 'localhost',
+                port    : ipc.config.networkPort
+            },
+            'message',
+            {
+                id      : ipc.config.id,
+                message : 'Goodbye'
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/UDPSocket/Multi-Client-Broadcast/hello-client.js

@@ -0,0 +1,48 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * Since there is no client relationship
+ * with UDP sockets sockets are not kept
+ * open.
+ *
+ * This means the order sockets are opened
+ * is important.
+ *
+ * Start World first. Then you can start
+ * hello or goodbye in any order you
+ * choose.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+
+ipc.serveNet(
+    8001, //we set the port here because the world server is already using the default of 8000. So we can not bind to 8000 while world is using it.
+    'udp4',
+    function(){
+        ipc.server.on(
+            'message',
+            function(data){
+                ipc.log('got Data');
+                ipc.log('got a message from ', data.id ,' : ', data.message);
+            }
+        );
+        ipc.server.emit(
+            {
+                address : 'localhost',
+                port    : ipc.config.networkPort
+            },
+            'message',
+            {
+                id      : ipc.config.id,
+                message : 'Hello'
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/UDPSocket/Multi-Client-Broadcast/world-server.js

@@ -0,0 +1,63 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * Since there is no client relationship
+ * with UDP sockets sockets are not kept
+ * open.
+ *
+ * This means the order sockets are opened
+ * is important.
+ *
+ * Start World first. Then you can start
+ * hello or goodbye in any order you
+ * choose.
+ *
+ ***************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+
+var messages={
+    goodbye:false,
+    hello:false
+};
+
+ipc.serveNet(
+    'udp4',
+    function(){
+        console.log(123);
+        ipc.server.on(
+            'message',
+            function(data,socket){
+                ipc.log('got a message from ', data.id ,' : ', data.message);
+                messages[data.id]=true;
+                ipc.server.emit(
+                    socket,
+                    'message',
+                    {
+                        id      : ipc.config.id,
+                        message : data.message+' world!'
+                    }
+                );
+
+                if(messages.hello && messages.goodbye){
+                    ipc.log('got all required events, telling evryone how muchg I am loved!');
+                    ipc.server.broadcast(
+                        'message',
+                        {
+                            id      : ipc.config.id,
+                            message : 'Everybody Loves The World! Got messages from hello and goodbye!'
+                        }
+                    );
+                }
+            }
+        );
+
+        console.log(ipc.server);
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/UDPSocket/basic/hello-client.js

@@ -0,0 +1,52 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * UDP Client is really a UDP server
+ *
+ * Dedicated UDP sockets on the same
+ * machine can not be bound to in the
+ * traditional client/server method
+ *
+ * Every UDP socket is it's own UDP server
+ * And so must have a unique port on its
+ * machine, unlike TCP or Unix Sockts
+ * which can share on the same machine.
+ *
+ * Since there is no open client server
+ * relationship, you should start world
+ * first and then hello.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+
+ipc.serveNet(
+    8001, //we set the port here because the world server is already using the default of 8000. So we can not bind to 8000 while world is using it.
+    'udp4',
+    function(){
+        ipc.server.on(
+            'message',
+            function(data){
+                ipc.log('got Data');
+                ipc.log('got a message from ', data.id ,' : ', data.message);
+            }
+        );
+        ipc.server.emit(
+            {
+                address : 'localhost',
+                port    : ipc.config.networkPort
+            },
+            'message',
+            {
+                id      : ipc.config.id,
+                message : 'Hello'
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/UDPSocket/basic/world-server.js

@@ -0,0 +1,47 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * UDP Client is really a UDP server
+ *
+ * Dedicated UDP sockets on the same
+ * machine can not be bound to in the
+ * traditional client/server method
+ *
+ * Every UDP socket is it's own UDP server
+ * And so must have a unique port on its
+ * machine, unlike TCP or Unix Sockts
+ * which can share on the same machine.
+ *
+ * Since there is no open client server
+ * relationship, you should start world
+ * first and then hello.
+ *
+ ***************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+
+ipc.serveNet(
+    'udp4',
+    function(){
+        ipc.server.on(
+            'message',
+            function(data,socket){
+                ipc.log('got a message from ', data.id ,' : ', data.message);
+                ipc.server.emit(
+                    socket,
+                    'message',
+                    {
+                        id      : ipc.config.id,
+                        message : data.message+' world!'
+                    }
+                );
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/UDPSocket/rawBuffer/hello-client.js

@@ -0,0 +1,35 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.rawBuffer=true;
+ipc.config.encoding='ascii';
+
+ipc.serveNet(
+    8001, //we set the port here because the world server is already using the default of 8000. So we can not bind to 8000 while world is using it.
+    'udp4',
+    function(){
+        ipc.server.on(
+            'data',
+            function(data){
+                ipc.log('got a message from world ', data, data.toString());
+            }
+        );
+        ipc.server.emit(
+            {
+                address : 'localhost',
+                port    : ipc.config.networkPort
+            },
+            'hello'
+        );
+    }
+);
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/UDPSocket/rawBuffer/world.server.js

@@ -0,0 +1,43 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * UDP Client is really a UDP server
+ *
+ * Dedicated UDP sockets on the same
+ * machine can not be bound to in the
+ * traditional client/server method
+ *
+ * Every UDP socket is it's own UDP server
+ * And so must have a unique port on its
+ * machine, unlike TCP or Unix Sockts
+ * which can share on the same machine.
+ *
+ * Since there is no open client server
+ * relationship, you should start world
+ * first and then hello.
+ *
+ ***************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.rawBuffer=true;
+ipc.config.encoding='ascii';
+
+ipc.serveNet(
+    'udp4',
+    function(){
+        ipc.server.on(
+            'data',
+            function(data,socket){
+                ipc.log('got a message', data,data.toString());
+                ipc.server.emit(
+                    socket,
+                    'goodbye'
+                );
+            }
+        );
+    }
+);
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/clusterUnixSocket/cluster-client.js

@@ -0,0 +1,31 @@
+const fs = require('fs');
+const ipc = require('../../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');
+    }
+  );
+}

TaskServer/node_modules/node-ipc/example/clusterUnixSocket/cluster-server.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+const ipc=require('../../../node-ipc');
+const cpuCount = require('os').cpus().length;
+const cluster = require('cluster');
+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}`);
+}

TaskServer/node_modules/node-ipc/example/rawBuffer/hello-client.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.rawBuffer=true;
+ipc.config.encoding='hex';
+
+ipc.connectTo(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                //make a 6 byte buffer for example
+                const myBuffer=new Buffer(6).fill(0);
+
+                myBuffer.writeUInt16BE(0x02,0);
+                myBuffer.writeUInt32BE(0xffeecc,2);
+
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    myBuffer
+                );
+            }
+        );
+
+        ipc.of.world.on(
+            'data',
+            function(data){
+                ipc.log('got a message from world : ', data);
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/rawBuffer/world.server.js

@@ -0,0 +1,40 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.rawBuffer=true;
+ipc.config.encoding='hex';
+
+ipc.serve(
+    function(){
+        ipc.server.on(
+            'connect',
+            function(socket){
+                ipc.server.emit(
+                    socket,
+                    [0xaa]
+                );
+            }
+        );
+
+        ipc.server.on(
+            'data',
+            function(data,socket){
+                ipc.log('got a message', data);
+                ipc.server.emit(
+                    socket,
+                    [0x0d,0xee]
+                );
+            }
+        );
+    }
+);
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/unixWindowsSocket/Multi-Client-Broadcast/goodbye-client.js

@@ -0,0 +1,43 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ * 
+ * You should start both hello and world
+ * then you will see them communicating.
+ * 
+ * *************************************/
+
+ipc.config.id = 'goodbye';
+ipc.config.retry= 1500;
+
+ipc.connectTo(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : 'goodbye'
+                    }
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'kill.connection',
+            function(data){
+                ipc.log('world requested kill.connection');
+                ipc.disconnect('world');
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/unixWindowsSocket/Multi-Client-Broadcast/hello-client.js

@@ -0,0 +1,49 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ * 
+ * You should start both hello and world
+ * then you will see them communicating.
+ * 
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+
+ipc.connectTo(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : 'hello'
+                    }
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'app.message',
+            function(data){
+                ipc.log('got a message from world : ', data);
+            }
+        );
+        ipc.of.world.on(
+            'kill.connection',
+            function(data){
+                ipc.log('world requested kill.connection');
+                ipc.disconnect('world');
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/unixWindowsSocket/Multi-Client-Broadcast/world-server.js

@@ -0,0 +1,51 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+
+var messages={
+    goodbye:false,
+    hello:false
+};
+
+ipc.serve(
+    function(){
+        ipc.server.on(
+            'app.message',
+            function(data,socket){
+                ipc.log('got a message from', (data.id), (data.message));
+                messages[data.id]=true;
+                ipc.server.emit(
+                    socket,
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : data.message+' world!'
+                    }
+                );
+
+                if(messages.hello && messages.goodbye){
+                    ipc.log('got all required events, telling clients to kill connection');
+                    ipc.server.broadcast(
+                        'kill.connection',
+                        {
+                            id:ipc.config.id
+                        }
+                    );
+                }
+            }
+        );
+    }
+);
+
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/unixWindowsSocket/basic/hello-client.js

@@ -0,0 +1,44 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry = 1000;
+
+ipc.connectTo(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : 'hello'
+                    }
+                );
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'app.message',
+            function(data){
+                ipc.log('got a message from world : ', data);
+            }
+        );
+
+        console.log(ipc.of.world.destroy);
+    }
+);

TaskServer/node_modules/node-ipc/example/unixWindowsSocket/basic/world-server.js

@@ -0,0 +1,33 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+
+ipc.serve(
+    function(){
+        ipc.server.on(
+            'app.message',
+            function(data,socket){
+                ipc.server.emit(
+                    socket,
+                    'app.message',
+                    {
+                        id      : ipc.config.id,
+                        message : data.message+' world!'
+                    }
+                );
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/unixWindowsSocket/basicSync/hello-client.js

@@ -0,0 +1,49 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry = 1000;
+ipc.config.sync= true;
+
+ipc.connectTo(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+
+                //queue up a bunch of requests to be sent synchronously
+                for(var i=0; i<10; i++){
+                    ipc.of.world.emit(
+                        'app.message',
+                        {
+                            id      : ipc.config.id,
+                            message : 'hello'+i
+                        }
+                    );
+                }
+            }
+        );
+        ipc.of.world.on(
+            'disconnect',
+            function(){
+                ipc.log('disconnected from world');
+            }
+        );
+        ipc.of.world.on(
+            'app.message',
+            function(data){
+                ipc.log('got a message from world : ', data);
+            }
+        );
+
+        console.log(ipc.of.world.destroy);
+    }
+);

TaskServer/node_modules/node-ipc/example/unixWindowsSocket/basicSync/world-server.js

@@ -0,0 +1,39 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.sync= true;
+
+ipc.serve(
+    function(){
+        ipc.server.on(
+            'app.message',
+            function(data,socket){
+                setTimeout(
+                    function(){
+                        ipc.server.emit(
+                            socket,
+                            'app.message',
+                            {
+                                id      : ipc.config.id,
+                                message : data.message+' world!'
+                            }
+                        );
+                    },
+                    2000
+                );
+            }
+        );
+    }
+);
+
+
+
+ipc.server.start();

TaskServer/node_modules/node-ipc/example/unixWindowsSocket/rawBuffer/hello-client.js

@@ -0,0 +1,35 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'hello';
+ipc.config.retry= 1500;
+ipc.config.rawBuffer=true;
+ipc.config.encoding='ascii';
+
+ipc.connectTo(
+    'world',
+    function(){
+        ipc.of.world.on(
+            'connect',
+            function(){
+                ipc.log('## connected to world ##', ipc.config.delay);
+                ipc.of.world.emit(
+                    'hello'
+                );
+            }
+        );
+
+        ipc.of.world.on(
+            'data',
+            function(data){
+                ipc.log('got a message from world : ', data,data.toString());
+            }
+        );
+    }
+);

TaskServer/node_modules/node-ipc/example/unixWindowsSocket/rawBuffer/world.server.js

@@ -0,0 +1,40 @@
+const ipc=require('../../../node-ipc');
+
+/***************************************\
+ *
+ * You should start both hello and world
+ * then you will see them communicating.
+ *
+ * *************************************/
+
+ipc.config.id = 'world';
+ipc.config.retry= 1500;
+ipc.config.rawBuffer=true;
+ipc.config.encoding='ascii';
+
+ipc.serve(
+    function(){
+        ipc.server.on(
+            'connect',
+            function(socket){
+                ipc.server.emit(
+                    socket,
+                    'hello'
+                );
+            }
+        );
+
+        ipc.server.on(
+            'data',
+            function(data,socket){
+                ipc.log('got a message', data,data.toString());
+                ipc.server.emit(
+                    socket,
+                    'goodbye'
+                );
+            }
+        );
+    }
+);
+
+ipc.server.start();