@weave-js/core 0.10.0 → 0.12.0

package/lib/tracing/time.js

@@ -1,16 +1,16 @@
-const loadTime = getNanoSeconds()
-const nodeLoadTime = loadTime - process.uptime() * 1e9
+const loadTime = getNanoSeconds();
+const nodeLoadTime = loadTime - process.uptime() * 1e9;
 
 function getNanoSeconds () {
-  const time = process.hrtime()
-  return time[0] * 1e9 + time[1]
+  const time = process.hrtime();
+  return time[0] * 1e9 + time[1];
 }
 
 function now () {
-  return (getNanoSeconds() - nodeLoadTime) / 1e6
+  return (getNanoSeconds() - nodeLoadTime) / 1e6;
 }
 
-const loadNs = now()
-const loadMs = Date.now()
+const loadNs = now();
+const loadMs = Date.now();
 
-module.exports = () => loadMs + now() - loadNs
+module.exports = () => loadMs + now() - loadNs;

package/lib/transport/InboundTransformStream.js

@@ -0,0 +1,75 @@
+const { Transform } = require('stream');
+
+const pushWithBackpressure = (stream, chunks, encoding, callback = null, $index = 0) => {
+  if (!(stream instanceof Transform)) {
+    throw new TypeError('Argument "stream" must be an instance of Duplex');
+  }
+
+  chunks = [].concat(chunks).filter(x => x !== undefined);
+
+  if (typeof encoding === 'function') {
+    callback = encoding;
+    encoding = undefined;
+  }
+
+  if ($index >= chunks.length) {
+    if (typeof callback === 'function') {
+      callback();
+    }
+    return stream;
+  } else if (!stream.push(chunks[$index], ...([encoding].filter(Boolean)))) {
+    stream.emit('backpressure', {
+      sender: stream.sender,
+      requestId: stream.requestId
+    });
+
+    const pipedStreams = [].concat(
+      (stream._readableState || {}).pipes || stream
+    ).filter(Boolean);
+
+    let listenerCalled = false;
+
+    const drainListener = () => {
+      stream.emit('resume_backpressure', {
+        sender: stream.sender,
+        requestId: stream.requestId
+      });
+
+      if (listenerCalled) {
+        return;
+      }
+
+      listenerCalled = true;
+
+      for (const stream of pipedStreams) {
+        stream.removeListener('drain', drainListener);
+      }
+
+      pushWithBackpressure(stream, chunks, encoding, callback, $index + 1);
+    };
+
+    for (const stream of pipedStreams) {
+      stream.once('drain', drainListener);
+    }
+
+    return stream;
+  }
+  return pushWithBackpressure(stream, chunks, encoding, callback, $index + 1);
+};
+class InboundTransformStream extends Transform {
+  constructor (sender, requestId, options) {
+    super(options);
+    this.sender = sender;
+    this.requestId = requestId;
+  }
+
+  _transform (chunk, encoding, callback) {
+    pushWithBackpressure(this, chunk, encoding, callback);
+  }
+
+  _flush (callback) {
+    return callback();
+  }
+}
+
+module.exports = { InboundTransformStream };

package/lib/transport/adapters/adapteBase.js

@@ -0,0 +1,107 @@
+/*
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
+ * -----
+ * Copyright 2021 Fachwerk
+ */
+
+const EventEmitter = require('events').EventEmitter;
+
+/**
+ * @typedef {Object} AdapterBase
+ * @property {string} name Name
+ * @property {EventEmitter} bus Event bus.
+ * @property {function():Promise<any>} afterInit After init callback.
+ * @property {boolean} isConnected Is connected state.
+ * @property {number} interruptCounter Interruption counter.
+ * @property {number} repeatAttemptCounter Repeat attempt counter
+ * @property {function(Object, Object, Object):Promise<any>} init Repeat attempt counter
+*/
+
+/**
+ * Create a adapter base object.
+ * @returns {AdapterBase} Adapter base object
+*/
+const createTransportBase = () => {
+  let prefix = 'weave';
+
+  return {
+    name: null,
+    bus: new EventEmitter(),
+    afterInit: null,
+    isConnected: false,
+    interruptCounter: 0,
+    repeatAttemptCounter: 0,
+    init (broker, transport, messageHandler) {
+      this.broker = broker;
+      this.transport = transport;
+      this.log = transport.log;
+      this.messageHandler = messageHandler;
+
+      if (broker.options.namespace) {
+        prefix = `${prefix}-${broker.options.namespace}`;
+      }
+
+      if (this.afterInit) {
+        this.afterInit();
+      }
+
+      return Promise.resolve();
+    },
+    subscribe () {
+      return Promise.resolve();
+    },
+    /**
+     *
+     * Connection handler
+     * @instance
+     * @param {*} connectionEventParams Connection event
+     * @param {boolean} [startHeartbeatTimers=true] Start timers for this adapter
+     * @returns {void}
+    */
+    connected (connectionEventParams = {}) {
+      this.bus.emit('$adapter.connected', connectionEventParams);
+    },
+    disconnected () {
+      this.bus.emit('$adapter.disconnected');
+    },
+    getTopic (cmd, nodeId) {
+      const topic = prefix + '.' + cmd + (nodeId ? '.' + nodeId : '');
+      return topic;
+    },
+    preSend (packet) {
+      return this.send(packet);
+    },
+    send (/* message*/) {
+      this.broker.handleError(new Error('Method "send" not implemented.'));
+    },
+    incomingMessage (messageType, message) {
+      const data = this.deserialize(message);
+      this.updateStatisticReceived(message.length);
+      this.bus.emit('$adapter.message', messageType, data);
+    },
+    serialize (packet) {
+      try {
+        // Add the sender to each outgoing message
+        packet.payload.sender = this.broker.nodeId;
+        return Buffer.from(JSON.stringify(packet));
+      } catch (error) {
+        this.broker.handleError(error);
+      }
+    },
+    deserialize (packet) {
+      try {
+        return JSON.parse(packet);
+      } catch (error) {
+        this.broker.handleError(error);
+      }
+    },
+    updateStatisticReceived (length) {
+      this.transport.statistics.received.packages += length;
+    },
+    updateStatisticSent (length) {
+      this.transport.statistics.sent.packages += length;
+    }
+  };
+};
+
+module.exports = createTransportBase;

package/lib/transport/adapters/adapters.js

@@ -1,9 +1,9 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2019 Fachwerk
  */
 
-exports.BaseAdapter = require('./adapter-base')
-exports.Dummy = require('./dummy')
-exports.TCP = require('./tcp')
+exports.BaseAdapter = require('./adapteBase');
+exports.Dummy = require('./dummy');
+exports.TCP = require('./tcp');

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

@@ -1,42 +1,42 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const TransportBase = require('../adapter-base')
-const EventEmitter = require('eventemitter2').EventEmitter2
+const TransportBase = require('../adapteBase');
+const EventEmitter = require('eventemitter2').EventEmitter2;
 
 // create a global eventbus to pass messages between weave service brokers.
 global.bus = new EventEmitter({
   wildcard: true,
   maxListeners: 100
-})
+});
 
 const DummyTransportAdapter = (adapterOptions) => {
-  const messageBus = global.bus
+  const messageBus = global.bus;
 
   return Object.assign(TransportBase(adapterOptions), {
     name: 'Dummy',
-    connect (isTryReconnect = false) {
-      this.bus.emit('$adapter.connected', false)
-      this.log.info('Dummy transport client connected.')
-      return Promise.resolve()
+    connect () {
+      this.bus.emit('$adapter.connected', false);
+      this.log.info('Dummy transport client connected.');
+      return Promise.resolve();
     },
     close () {
-      return Promise.resolve()
+      return Promise.resolve();
     },
     send (message) {
-      const data = this.serialize(message)
-      const topic = this.getTopic(message.type, message.targetNodeId)
-      messageBus.emit(topic, data)
-      return Promise.resolve()
+      const data = this.serialize(message);
+      const topic = this.getTopic(message.type, message.targetNodeId);
+      messageBus.emit(topic, data);
+      return Promise.resolve();
     },
     subscribe (type, nodeId) {
-      const topic = this.getTopic(type, nodeId)
-      messageBus.on(topic, message => this.incomingMessage(type, message))
+      const topic = this.getTopic(type, nodeId);
+      messageBus.on(topic, message => this.incomingMessage(type, message));
     }
-  })
-}
+  });
+};
 
-module.exports = DummyTransportAdapter
+module.exports = DummyTransportAdapter;

package/lib/transport/adapters/fromURI.js

@@ -1,35 +1,35 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2019 Fachwerk
  */
-const { parse } = require('url')
-const getAdapterByName = require('./getAdapterByName')
+const { parse } = require('url');
+const getAdapterByName = require('./getAdapterByName');
 
 function fromURI (uri) {
   if (typeof uri !== 'string') {
-    throw new Error('URI needs to be a string.')
+    throw new Error('URI needs to be a string.');
   }
 
-  const urlObject = parse(uri)
+  const urlObject = parse(uri);
 
   if (!urlObject.protocol) {
-    throw new Error('Protocol is missing.')
+    throw new Error('Protocol is missing.');
   }
 
-  const name = urlObject.protocol.slice(0, -1).toLowerCase()
+  const name = urlObject.protocol.slice(0, -1).toLowerCase();
 
-  const AdapterFactory = getAdapterByName(name)
+  const AdapterFactory = getAdapterByName(name);
 
   if (!AdapterFactory) {
-    throw new Error('No adapter found.')
+    throw new Error('No adapter found.');
   }
 
-  let config = null
+  let config = null;
   if (AdapterFactory.uriToConfig) {
-    config = AdapterFactory.uriToConfig(urlObject)
+    config = AdapterFactory.uriToConfig(urlObject);
   }
-  return AdapterFactory(config)
+  return AdapterFactory(config);
 }
 
-module.exports = fromURI
+module.exports = fromURI;

package/lib/transport/adapters/getAdapterByName.js

@@ -1,11 +1,11 @@
-const adapters = require('./adapters')
+const adapters = require('./adapters');
 
 module.exports = name => {
   if (!name) {
-    return
+    return;
   }
-  const foundAdapterName = Object.keys(adapters).find(adapter => adapter.toLowerCase() === name.toLowerCase())
+  const foundAdapterName = Object.keys(adapters).find(adapter => adapter.toLowerCase() === name.toLowerCase());
   if (foundAdapterName) {
-    return adapters[foundAdapterName]
+    return adapters[foundAdapterName];
   }
-}
+};

package/lib/transport/adapters/index.js

@@ -1,29 +1,29 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { WeaveBrokerOptionsError } = require('../../errors')
-const fromURI = require('./fromURI')
-const getAdapterByName = require('./getAdapterByName')
-const adapters = require('./adapters')
+const { WeaveBrokerOptionsError } = require('../../errors');
+const fromURI = require('./fromURI');
+const getAdapterByName = require('./getAdapterByName');
+const adapters = require('./adapters');
 
 const resolve = (broker, options) => {
   if (typeof options === 'object') {
     if (typeof options.adapter === 'string') {
-      const Adapter = getAdapterByName(options.adapter)
+      const Adapter = getAdapterByName(options.adapter);
 
       if (Adapter) {
-        return Adapter(options.options)
+        return Adapter(options.options);
       } else {
-        broker.handleError(new WeaveBrokerOptionsError(`Invalid transport settings: ${options.adapter}`))
+        broker.handleError(new WeaveBrokerOptionsError(`Invalid transport settings: ${options.adapter}`));
       }
     }
-    return options.adapter
+    return options.adapter;
   }
 
-  return null
-}
+  return null;
+};
 
-module.exports = Object.assign({ resolve, fromURI }, adapters)
+module.exports = Object.assign({ resolve, fromURI }, adapters);

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

@@ -1,10 +1,10 @@
 module.exports = function createCodec (options) {
   return {
     encode (object) {
-      return Buffer.from(JSON.stringify(object))
+      return Buffer.from(JSON.stringify(object));
     },
     decode (buffer) {
-      return JSON.parse(buffer.toString())
+      return JSON.parse(buffer.toString());
     }
-  }
-}
+  };
+};

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

@@ -1,94 +1,96 @@
-const dgram = require('dgram')
-const { getIpList } = require('@weave-js/utils')
-const EventEmitter = require('events').EventEmitter
-const Codec = require('./codec')
-const { getBroadcastAddresses } = require('../utils')
+const dgram = require('dgram');
+const { getIpList } = require('@weave-js/utils');
+const EventEmitter = require('events').EventEmitter;
+const Codec = require('./codec');
+const { getBroadcastAddresses } = require('../utils');
 const messageTypes = {
   HELLO: 4
-}
+};
 
 const createDiscoveryService = (adapter, options) => {
-  const namespace = adapter.broker.options.namespace
-  const codec = Codec(options)
-  const bus = new EventEmitter()
-  const ips = getIpList(false)
-  const MESSAGE_TYPE_LENGHT = 1
+  const namespace = adapter.broker.options.namespace;
+  const codec = Codec(options);
+  const bus = new EventEmitter();
+  const ips = getIpList(false);
+  const MESSAGE_TYPE_LENGTH = 1;
 
-  let servers = []
-  let discoverTimer
+  let servers = [];
+  let discoverTimer;
 
   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.on('message', onMessage);
 
-        socket.bind({ port, host, exclusive: true }, () => {
+        socket.bind({ port, exclusive: true }, () => {
           try {
             if (multicastAddress) {
-              socket.setMulticastInterface(host)
-              socket.addMembership(multicastAddress, host)
-              socket.setMulticastTTL(1)
-              socket.destinations = [multicastAddress]
-              adapter.log.info(`UDP Server is listening on ${host}:${port}. Membership: ${multicastAddress}`)
+              socket.setMulticastInterface(host);
+              socket.addMembership(multicastAddress, host);
+              socket.setMulticastTTL(1);
+              // 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()
+              socket.setBroadcast(true);
+              Object.defineProperty(socket, 'destinations', {
+                value: getBroadcastAddresses()
+              });
             }
           } catch (error) {
-            adapter.log.info(`UDP Multicast membership error: ${error.message}`)
+            adapter.log.info(`UDP Multicast membership error: ${error.message}`);
           }
-        })
+        });
 
-        servers.push(socket)
+        servers.push(socket);
 
-        resolve(socket)
+        resolve(socket);
       } catch (error) {
-        reject(error)
+        reject(error);
       }
-    })
-  }
+    });
+  };
 
   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)
-    Buffer.prototype.writeUInt8.call(header, messageTypes.HELLO, 0)
+    const header = Buffer.alloc(MESSAGE_TYPE_LENGTH);
+    Buffer.prototype.writeUInt8.call(header, messageTypes.HELLO, 0);
 
-    const message = Buffer.concat([header, codec.encode(payload)])
+    const message = Buffer.concat([header, codec.encode(payload)]);
 
     servers.forEach(server => {
       server.destinations.forEach(host => {
         server.send(message, options.discovery.port, host, (error) => {
           if (!error) {
-            adapter.log.verbose(`Message sent to ${host}:${options.discovery.port}`)
+            adapter.log.verbose(`Message sent to ${host}:${options.discovery.port}`);
           }
-        })
-      })
-    })
+        });
+      });
+    });
   }
 
   function sendDiscoveryPackage (port) {
@@ -96,40 +98,52 @@ const createDiscoveryService = (adapter, options) => {
       namespace: adapter.broker.options.namespace,
       nodeId: adapter.broker.nodeId,
       port: port
-    })
+    });
   }
 
   function startDiscovering (port) {
-    discoverTimer = setInterval(() => sendDiscoveryPackage(port), 2000)
-
-    discoverTimer.unref()
+    discoverTimer = setInterval(() => sendDiscoveryPackage(port), 2000);
+    discoverTimer.unref();
   }
 
   function stopDiscovery () {
     if (discoverTimer) {
-      clearInterval(discoverTimer)
-      discoverTimer = null
-      adapter.log.info('UDP discovery service stopped')
+      clearInterval(discoverTimer);
+      discoverTimer = null;
+      adapter.log.info('UDP discovery service stopped');
     }
   }
 
   return {
     bus,
-    init (port) {
+    async start (port) {
       if (!options.discovery.enabled) {
-        return Promise.resolve()
+        return Promise.resolve();
+      }
+
+      // UDP Multicast
+      if (options.discovery.udpMulticast) {
+        if (options.discovery.multicastAddress) {
+          await Promise.all(ips.map(ip => startServer(ip, options.discovery.port, options.discovery.multicastAddress)));
+        }
       }
 
-      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 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()
-      servers.forEach(server => server.close())
-      servers = []
+      stopDiscovery();
+      servers.forEach(server => server.close());
+      servers = [];
     }
-  }
-}
+  };
+};
 
-module.exports = createDiscoveryService
+module.exports = createDiscoveryService;