@weave-js/core 0.11.0 → 0.12.1

package/lib/transport/adapters/tcp/tcpReader.js

@@ -1,69 +1,69 @@
-const net = require('net')
-const { EventEmitter } = require('events')
-const TCPWriteStream = require('./tcpWriteStream')
+const net = require('net');
+const { EventEmitter } = require('events');
+const TCPWriteStream = require('./tcpWriteStream');
 
 module.exports = (adapter, options) => {
-  const self = Object.assign({}, EventEmitter.prototype)
-  let sockets = []
-  let server
+  const self = Object.assign({}, EventEmitter.prototype);
+  let sockets = [];
+  let server;
 
-  self.isConnected = false
+  self.isConnected = false;
 
   self.listen = () => {
     return new Promise((resolve, reject) => {
-      server = net.createServer(socket => onTCPClientConnected(socket))
+      server = net.createServer(socket => onTCPClientConnected(socket));
 
       server.on('error', error => {
-        adapter.log.error('TCP server error', error)
-        reject(error)
-      })
+        adapter.log.error('TCP server error', error);
+        reject(error);
+      });
 
       server.listen(options, () => {
-        const port = server.address().port
-        self.isConnected = true
-        adapter.log.info(`TCP server is listening on port ${port}`)
-        resolve(port)
-      })
-    })
-  }
+        const port = server.address().port;
+        self.isConnected = true;
+        adapter.log.info(`TCP server is listening on port ${port}`);
+        resolve(port);
+      });
+    });
+  };
 
   self.close = () => {
     if (server && self.isConnected) {
-      server.close()
-      sockets.forEach(socket => socket.destroy())
-      sockets = []
+      server.close();
+      sockets.forEach(socket => socket.destroy());
+      sockets = [];
     }
-  }
+  };
 
   function onTCPClientConnected (socket) {
-    sockets.push(socket)
+    sockets.push(socket);
 
-    const parser = new TCPWriteStream(adapter, socket, options.maxPacketSize)
-    socket.pipe(parser)
+    const parser = new TCPWriteStream(adapter, socket, options.maxPacketSize);
+    socket.pipe(parser);
 
     parser.on('error', error => {
-      adapter.log.warn('Packet parser error!', error)
-      closeSocket(socket)
-    })
+      adapter.log.warn('Packet parser error!', error);
+      closeSocket(socket);
+    });
 
     parser.on('data', (type, message) => {
-      self.emit('message', type, message)
-    })
+      self.emit('message', type, message);
+    });
 
     socket.on('error', error => {
-      adapter.log.warn('TCP connection error!', error)
-      closeSocket(socket)
-    })
+      adapter.log.warn('TCP connection error!', error);
+      closeSocket(socket);
+    });
 
     socket.on('close', (isError) => {
-      closeSocket(socket)
-    })
+      closeSocket(socket);
+    });
   }
 
   function closeSocket (socket) {
-    socket.destroy()
-    sockets.splice(sockets.indexOf(socket), 1)
+    socket.destroy();
+    sockets.splice(sockets.indexOf(socket), 1);
   }
 
-  return self
-}
+  return self;
+};

package/lib/transport/adapters/tcp/tcpWriteStream.js

@@ -1,54 +1,54 @@
 
-const { Writable } = require('stream')
-const MessageTypes = require('../../messageTypes')
-const TCPMessageTypeHelper = require('./tcp-messagetypes')
+const { Writable } = require('stream');
+const MessageTypes = require('../../messageTypes');
+const TCPMessageTypeHelper = require('./tcp-messagetypes');
 
 module.exports = class TCPWriteStream extends Writable {
   constructor (adapter, socket, maxPacketSize) {
-    super()
-    this.buffer = null
-    this.adapter = adapter
-    this.socket = socket
-    this.messageTypeHelper = TCPMessageTypeHelper(MessageTypes)
-    this.maxPacketSize = maxPacketSize
+    super();
+    this.buffer = null;
+    this.adapter = adapter;
+    this.socket = socket;
+    this.messageTypeHelper = TCPMessageTypeHelper(MessageTypes);
+    this.maxPacketSize = maxPacketSize;
   }
 
   _write (chunk, encoding, callback) {
-    let packet = chunk
+    let packet = chunk;
 
     if (this.buffer && this.buffer.length > 0) {
-      packet = Buffer.concat([this.buffer, chunk])
-      this.buffer = null
+      packet = Buffer.concat([this.buffer, chunk]);
+      this.buffer = null;
     }
 
     while (packet.length > 0) {
       if (packet.length < 6) {
-        this.buffer = Buffer.from(packet)
-        return callback()
+        this.buffer = Buffer.from(packet);
+        return callback();
       }
 
       if (packet.length > this.maxPacketSize) {
-        return callback(new Error(`Incoming packet is larger than the 'maxPacketSize' limit (${packet.length} > ${this.maxPacketSize})!`))
+        return callback(new Error(`Incoming packet is larger than the 'maxPacketSize' limit (${packet.length} > ${this.maxPacketSize})!`));
       }
 
-      const crc = packet[1] ^ packet[2] ^ packet[3] ^ packet[4] ^ packet[5]
+      const crc = packet[1] ^ packet[2] ^ packet[3] ^ packet[4] ^ packet[5];
 
       if (crc !== packet[0]) {
-        return callback(new Error('Invalid cyclic redundancy check.'))
+        return callback(new Error('Invalid cyclic redundancy check.'));
       }
 
-      const length = packet.readInt32BE(1)
+      const length = packet.readInt32BE(1);
       if (packet.length >= length) {
-        const message = packet.slice(6, length)
-        const type = this.messageTypeHelper.getTypeByIndex(packet[5]) // resolveMessageType(packet[5])
+        const message = packet.slice(6, length);
+        const type = this.messageTypeHelper.getTypeByIndex(packet[5]); // resolveMessageType(packet[5])
 
-        this.emit('data', type, message, this.socket)
-        packet = packet.slice(length)
+        this.emit('data', type, message, this.socket);
+        packet = packet.slice(length);
       } else {
-        this.buffer = Buffer.from(packet)
-        return callback()
+        this.buffer = Buffer.from(packet);
+        return callback();
       }
     }
-    callback()
+    callback();
   }
-}
+};

package/lib/transport/adapters/tcp/tcpWriter.js

@@ -1,119 +1,119 @@
-const net = require('net')
-const { EventEmitter } = require('events')
-const MessageTypes = require('../../messageTypes')
-const TCPMessageTypeHelper = require('./tcp-messagetypes')
+const net = require('net');
+const { EventEmitter } = require('events');
+const MessageTypes = require('../../messageTypes');
+const TCPMessageTypeHelper = require('./tcp-messagetypes');
 
 module.exports = (adapter) => {
-  const self = Object.assign({}, EventEmitter.prototype)
-  const sockets = new Map()
-  const messageTypeHelper = TCPMessageTypeHelper(MessageTypes)
-  const headerSize = 6
+  const self = Object.assign({}, EventEmitter.prototype);
+  const sockets = new Map();
+  const messageTypeHelper = TCPMessageTypeHelper(MessageTypes);
+  const headerSize = 6;
 
   const connect = nodeId => {
-    const node = adapter.broker.registry.nodeCollection.get(nodeId)
+    const node = adapter.broker.registry.nodeCollection.get(nodeId);
     if (!node) {
-      return Promise.reject(new Error(`Missing node info for '${nodeId}'!`))
+      return Promise.reject(new Error(`Missing node info for '${nodeId}'!`));
     }
 
-    const host = node.IPList[0]
-    const port = node.port
+    const host = node.IPList[0];
+    const port = node.port;
 
     return new Promise((resolve, reject) => {
       try {
         const socket = net.connect({ host, port }, () => {
           // send hello
-          socket.setNoDelay(true)
-          socket.nodeId = nodeId
-          socket.lastUsage = Date.now()
+          socket.setNoDelay(true);
+          socket.nodeId = nodeId;
+          socket.lastUsage = Date.now();
 
-          addSocket(nodeId, socket, true)
+          addSocket(nodeId, socket, true);
 
           adapter.sendHello(nodeId)
             .then(() => resolve(socket))
-            .catch(error => reject(error))
-        })
+            .catch(error => reject(error));
+        });
 
         socket.on('error', error => {
-          removeSocket(nodeId)
+          removeSocket(nodeId);
 
-          self.emit('error', error, nodeId)
+          self.emit('error', error, nodeId);
 
           if (error) {
-            reject(error)
+            reject(error);
           }
-        })
+        });
 
-        socket.unref()
+        socket.unref();
       } catch (error) {
         if (error) {
-          reject(error)
+          reject(error);
         }
       }
-    })
-  }
+    });
+  };
 
   const addSocket = (nodeId, socket, force) => {
-    const s = sockets.get(nodeId)
+    const s = sockets.get(nodeId);
 
     if (!force && s && !s.destroyed) {
-      return
+      return;
     }
 
-    sockets.set(nodeId, socket)
-  }
+    sockets.set(nodeId, socket);
+  };
 
   const removeSocket = nodeId => {
-    const socket = sockets.get(nodeId)
+    const socket = sockets.get(nodeId);
     if (socket && !socket.destroyed) {
-      socket.destroy()
+      socket.destroy();
     }
 
-    sockets.delete(nodeId)
-  }
+    sockets.delete(nodeId);
+  };
 
   self.send = (nodeId, type, data) => {
     return Promise.resolve()
       .then(() => {
-        const socket = sockets.get(nodeId)
+        const socket = sockets.get(nodeId);
 
         if (socket && !socket.destroyed) {
-          return socket
+          return socket;
         }
-        return connect(nodeId)
+        return connect(nodeId);
       })
       .then(socket => {
         return new Promise((resolve, reject) => {
-          const header = Buffer.alloc(headerSize)
+          const header = Buffer.alloc(headerSize);
 
-          header.writeInt32BE(data.length + headerSize, 1)
-          header.writeInt8(messageTypeHelper.getIndexByType(type), 5)
+          header.writeInt32BE(data.length + headerSize, 1);
+          header.writeInt8(messageTypeHelper.getIndexByType(type), 5);
 
-          const crc = header[1] ^ header[2] ^ header[3] ^ header[4] ^ header[5]
-          header[0] = crc
+          const crc = header[1] ^ header[2] ^ header[3] ^ header[4] ^ header[5];
+          header[0] = crc;
 
-          const payload = Buffer.concat([header, data])
+          const payload = Buffer.concat([header, data]);
 
           try {
             socket.write(payload, () => {
-              resolve()
-            })
+              resolve();
+            });
           } catch (error) {
-            removeSocket(nodeId)
-            reject(error)
+            removeSocket(nodeId);
+            reject(error);
           }
-        })
-      })
-  }
+        });
+      });
+  };
 
   self.close = () => {
     sockets.forEach(socket => {
       if (!socket.destroyed) {
-        socket.destroy()
+        socket.destroy();
       }
-      socket.end()
-    })
-    sockets.clear()
-  }
+      socket.end();
+    });
+    sockets.clear();
+  };
 
-  return self
-}
+  return self;
+};

package/lib/transport/adapters/tcp/utils.js

@@ -1,27 +1,27 @@
-const os = require('os')
+const os = require('os');
 
 function getBroadcastAddress ({ address, netmask }) {
-  const addressBytes = address.split('.').map(Number)
-  const netmaskBytes = netmask.split('.').map(Number)
+  const addressBytes = address.split('.').map(Number);
+  const netmaskBytes = netmask.split('.').map(Number);
   const subnetBytes = netmaskBytes.map(
     (_, index) => addressBytes[index] & netmaskBytes[index]
-  )
+  );
   const broadcastBytes = netmaskBytes.map(
     (_, index) => subnetBytes[index] | (~netmaskBytes[index] + 256)
-  )
-  return broadcastBytes.map(String).join('.')
+  );
+  return broadcastBytes.map(String).join('.');
 }
 
 exports.getBroadcastAddresses = () => {
-  const list = []
-  const interfaces = os.networkInterfaces()
+  const list = [];
+  const interfaces = os.networkInterfaces();
   for (const iface in interfaces) {
     for (const i in interfaces[iface]) {
-      const f = interfaces[iface][i]
+      const f = interfaces[iface][i];
       if (f.family === 'IPv4') {
-        list.push(getBroadcastAddress(f))
+        list.push(getBroadcastAddress(f));
       }
     }
   }
-  return list
-}
+  return list;
+};

package/lib/transport/createMessage.js

@@ -1,11 +1,11 @@
-const MessageTypes = require('./messageTypes')
+const MessageTypes = require('./messageTypes');
 
 const createMessage = (type, targetNodeId, payload) => {
   return {
     type: type || MessageTypes.MESSAGE_UNKNOWN,
     targetNodeId,
     payload: payload || {}
-  }
-}
+  };
+};
 
-module.exports = { createMessage }
+module.exports = { createMessage };