@weave-js/core 0.9.2 → 0.11.0

package/lib/transport/adapters/tcp/discovery/index.js

@@ -12,7 +12,7 @@ const createDiscoveryService = (adapter, options) => {
   const codec = Codec(options)
   const bus = new EventEmitter()
   const ips = getIpList(false)
-  const MESSAGE_TYPE_LENGHT = 1
+  const MESSAGE_TYPE_LENGTH = 1
 
   let servers = []
   let discoverTimer
@@ -20,32 +20,29 @@ const createDiscoveryService = (adapter, options) => {
   const startServer = (host, port, multicastAddress) => {
     return new Promise((resolve, reject) => {
       try {
-        const socket = dgram.createSocket({ type: options.discovery.type, reuseAddr: options.discovery.udpReuseAddress })
-
-        socket.on('message', (message, info) => {
-          const messageType = Buffer.prototype.readUInt8.call(message, 0)
-          const payload = message.slice(MESSAGE_TYPE_LENGHT)
-
-          switch (messageType) {
-          case messageTypes.HELLO:
-            onMessage(payload, info)
-            break
-          default:
-            onUnknown(payload, info)
-          }
+        const socket = dgram.createSocket({
+          type: options.discovery.type,
+          reuseAddr: options.discovery.udpReuseAddress
         })
 
-        socket.bind({ port, host, exclusive: true }, () => {
+        socket.on('message', onMessage)
+
+        socket.bind({ port, exclusive: true }, () => {
           try {
             if (multicastAddress) {
               socket.setMulticastInterface(host)
               socket.addMembership(multicastAddress, host)
               socket.setMulticastTTL(1)
-              socket.destinations = [multicastAddress]
+              // Add destination to socket object
+              Object.defineProperty(socket, 'destinations', {
+                value: [multicastAddress]
+              })
               adapter.log.info(`UDP Server is listening on ${host}:${port}. Membership: ${multicastAddress}`)
             } else {
               socket.setBroadcast(true)
-              socket.destinations = getBroadcastAddresses()
+              Object.defineProperty(socket, 'destinations', {
+                value: getBroadcastAddresses()
+              })
             }
           } catch (error) {
             adapter.log.info(`UDP Multicast membership error: ${error.message}`)
@@ -62,20 +59,25 @@ const createDiscoveryService = (adapter, options) => {
   }
 
   const onMessage = (buffer, info) => {
-    const message = codec.decode(buffer)
-    message.host = info.address
+    const messageType = Buffer.prototype.readUInt8.call(buffer, 0)
+    const payload = buffer.slice(MESSAGE_TYPE_LENGTH)
 
-    if (message.namespace === namespace) {
-      bus.emit('message', message)
-    }
-  }
+    switch (messageType) {
+    case messageTypes.HELLO:
+      const message = codec.decode(payload)
+      message.host = info.address
 
-  const onUnknown = (message, info) => {
-    adapter.log.debug(`Received an unknown data package from host "${info.address}"`)
+      if (message.namespace === namespace) {
+        bus.emit('message', message)
+      }
+      break
+    default:
+      adapter.log.debug(`Received an unknown data package from host "${info.address}"`)
+    }
   }
 
   function sendMessage (payload) {
-    const header = Buffer.alloc(MESSAGE_TYPE_LENGHT)
+    const header = Buffer.alloc(MESSAGE_TYPE_LENGTH)
     Buffer.prototype.writeUInt8.call(header, messageTypes.HELLO, 0)
 
     const message = Buffer.concat([header, codec.encode(payload)])
@@ -101,7 +103,6 @@ const createDiscoveryService = (adapter, options) => {
 
   function startDiscovering (port) {
     discoverTimer = setInterval(() => sendDiscoveryPackage(port), 2000)
-
     discoverTimer.unref()
   }
 
@@ -115,14 +116,27 @@ const createDiscoveryService = (adapter, options) => {
 
   return {
     bus,
-    init (port) {
+    async start (port) {
       if (!options.discovery.enabled) {
         return Promise.resolve()
       }
 
-      return Promise.all(ips.map(ip => startServer(ip, options.discovery.port, options.discovery.multicastAddress)))
-        .then(() => setTimeout(() => sendDiscoveryPackage(port), Math.floor(Math.random() * 500) + 1))
-        .then(() => startDiscovering(port))
+      // UDP Multicast
+      if (options.discovery.udpMulticast) {
+        if (options.discovery.multicastAddress) {
+          await Promise.all(ips.map(ip => startServer(ip, options.discovery.port, options.discovery.multicastAddress)))
+        }
+      }
+
+      // UDP Broadcast
+      if (options.discovery.udpBroadcast) {
+        await startServer(options.discovery.udpBindAddress, options.discovery.port, options.discovery.multicastAddress)
+      }
+
+      // send the first dis
+      const timeout = Math.floor(Math.random() * 500) + 500
+      setTimeout(() => sendDiscoveryPackage(port), timeout)
+      startDiscovering(port)
     },
     close () {
       stopDiscovery()

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

@@ -1,10 +1,12 @@
 
 const { defaultsDeep } = require('@weave-js/utils')
-const TransportBase = require('../adapter-base')
+const TransportBase = require('../adapteBase')
 const Swim = require('./discovery/index')
-const MessageTypes = require('../../message-types')
+const MessageTypes = require('../../messageTypes')
 const TCPReader = require('./tcpReader')
 const TCPWriter = require('./tcpWriter')
+const { createMessage } = require('../../createMessage')
+
 // const TCPMessageTypeHelper = require('./tcp-messagetypes')
 
 const defaultOptions = {
@@ -12,6 +14,7 @@ const defaultOptions = {
   discovery: {
     enabled: true,
     type: 'udp4',
+    udpMulticast: true,
     multicastAddress: '239.0.0.0',
     port: 54355,
     udpReuseAddress: true
@@ -59,7 +62,11 @@ module.exports = function SwimTransport (adapterOptions) {
       MessageTypes.MESSAGE_RESPONSE,
       MessageTypes.MESSAGE_GOSSIP_HELLO,
       MessageTypes.MESSAGE_GOSSIP_REQUEST,
-      MessageTypes.MESSAGE_GOSSIP_RESPONSE
+      MessageTypes.MESSAGE_GOSSIP_RESPONSE,
+      MessageTypes.MESSAGE_RESPONSE_STREAM_BACKPRESSURE,
+      MessageTypes.MESSAGE_RESPONSE_STREAM_RESUME,
+      MessageTypes.MESSAGE_REQUEST_STREAM_BACKPRESSURE,
+      MessageTypes.MESSAGE_REQUEST_STREAM_RESUME
     ].includes(message.type)) {
       if (message.type === MessageTypes.MESSAGE_DISCONNECT) {
         // send a disconnect message to all connected nodes
@@ -81,7 +88,7 @@ module.exports = function SwimTransport (adapterOptions) {
 
     const localNode = self.broker.registry.nodeCollection.localNode
 
-    const message = self.transport.createMessage(MessageTypes.MESSAGE_GOSSIP_HELLO, nodeId, {
+    const message = createMessage(MessageTypes.MESSAGE_GOSSIP_HELLO, nodeId, {
       host: localNode.IPList[0],
       port: localNode.port
     })
@@ -165,7 +172,7 @@ module.exports = function SwimTransport (adapterOptions) {
       }
     })
 
-    self.swim.init(port)
+    self.swim.start(port)
   }
 
   function startTCPServer () {
@@ -174,19 +181,19 @@ module.exports = function SwimTransport (adapterOptions) {
 
     tcpReader.on('message', onMessage)
 
-    tcpWriter.on('error', (error, nodeID) => {
+    tcpWriter.on('error', (error, nodeId) => {
       self.log.debug('TCP client error on ', error)
-      self.broker.registry.nodeDisconnected(nodeID, false)
+      self.broker.registry.nodeDisconnected(nodeId, false)
     })
 
-    tcpWriter.on('end', nodeID => {
+    tcpWriter.on('end', nodeId => {
       self.log.debug('TCP connection ended with')
-      self.broker.registry.nodeDisconnected(nodeID, false)
+      self.broker.registry.nodeDisconnected(nodeId, false)
     })
 
-    // tcpWriter.on('error', (_, nodeID) => {
+    // tcpWriter.on('error', (_, nodeId) => {
     //   self.log.debug('TCP server error on ')
-    //   // this.nodes.disconnected(nodeID, false)
+    //   // this.nodes.disconnected(nodeId, false)
     // })
 
     return tcpReader.listen()
@@ -250,7 +257,7 @@ module.exports = function SwimTransport (adapterOptions) {
 
     const destinationNode = nodes[Math.floor(Math.random() * nodes.length)]
     if (destinationNode) {
-      const message = self.transport.createMessage(MessageTypes.MESSAGE_GOSSIP_REQUEST, destinationNode.id, payload)
+      const message = createMessage(MessageTypes.MESSAGE_GOSSIP_REQUEST, destinationNode.id, payload)
 
       self.send(message).catch(() => {
         self.log.debug(`Unable to send gossip response to ${destinationNode.id}`)
@@ -357,7 +364,7 @@ module.exports = function SwimTransport (adapterOptions) {
 
       if (response.online || response.offline) {
         const destinationNode = self.broker.registry.nodeCollection.get(payload.sender)
-        const message = self.transport.createMessage(MessageTypes.MESSAGE_GOSSIP_RESPONSE, destinationNode.id, response)
+        const message = createMessage(MessageTypes.MESSAGE_GOSSIP_RESPONSE, destinationNode.id, response)
         self.send(message).catch(() => {})
       }
     } catch (error) {

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

@@ -29,6 +29,7 @@ module.exports = (adapter, options) => {
 
   self.close = () => {
     if (server && self.isConnected) {
+      server.close()
       sockets.forEach(socket => socket.destroy())
       sockets = []
     }

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

@@ -1,6 +1,6 @@
 
 const { Writable } = require('stream')
-const MessageTypes = require('../../message-types')
+const MessageTypes = require('../../messageTypes')
 const TCPMessageTypeHelper = require('./tcp-messagetypes')
 
 module.exports = class TCPWriteStream extends Writable {

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

@@ -1,9 +1,9 @@
 const net = require('net')
 const { EventEmitter } = require('events')
-const MessageTypes = require('../../message-types')
+const MessageTypes = require('../../messageTypes')
 const TCPMessageTypeHelper = require('./tcp-messagetypes')
 
-module.exports = (adapter, options) => {
+module.exports = (adapter) => {
   const self = Object.assign({}, EventEmitter.prototype)
   const sockets = new Map()
   const messageTypeHelper = TCPMessageTypeHelper(MessageTypes)

package/lib/transport/createMessage.js

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