@weave-js/core 0.10.0 → 0.11.0

package/lib/registry/service/service.js

@@ -9,7 +9,7 @@ const { WeaveError } = require('../../errors')
 const { parseAction } = require('./parseAction')
 const { parseEvent } = require('./parseEvent')
 const { reduceMixins } = require('./reduceMixins')
-const { createEventEndpoint } = require('../event-endpoint')
+const { createEventEndpoint } = require('../eventEndpoint')
 /**
  * Service factory
  * @param {Runtime} runtime Broker instance
@@ -133,7 +133,7 @@ exports.createServiceFromSchema = (runtime, schema) => {
           context = runtime.contextFactory.create(endpoint, data, options || {})
         }
 
-        return wrappedAction(context, { service, runtime, errors: {} })
+        return wrappedAction(context, { service, runtime, errors: {}})
       }
     })
   }

package/lib/runtime/{init-action-invoker.js → initActionInvoker.js}

@@ -36,7 +36,7 @@ exports.initActionInvoker = (runtime) => {
       log.debug({ action: context.action.name, nodeId, requestId: context.requestId }, 'Call action on remote node.')
     }
 
-    const p = action.handler(context, { service: endpoint.service, runtime, errors })
+    const p = action.handler(context, { service: context.action.service, runtime, errors })
     p.context = context
 
     return p

package/lib/runtime/{init-eventbus.js → initEventbus.js}

@@ -15,7 +15,11 @@ exports.initEventbus = (runtime) => {
       options = {}
     }
 
-    const promises = []
+    // Emit local events
+    if (/^\$/.test(eventName)) {
+      bus.emit(eventName, payload)
+    }
+
     // todo: create an event context object
     const context = contextFactory.create(null, payload, options)
 
@@ -23,18 +27,15 @@ exports.initEventbus = (runtime) => {
     context.eventName = eventName
     context.eventGroups = options.groups
 
-    // Emit system events
-    if (/^\$/.test(eventName)) {
-      bus.emit(eventName, payload)
-    }
-
     const endpoints = registry.eventCollection.getBalancedEndpoints(eventName, options.groups)
     const groupedEndpoints = {}
+    const promises = []
 
     endpoints.map(([endpoint, groupName]) => {
       if (endpoint) {
         if (endpoint.node.id === brokerOptions.nodeId) {
           // Local event. Call handler
+          context.setEndpoint(endpoint)
           promises.push(endpoint.action.handler(context))
         } else {
           const e = groupedEndpoints[endpoint.node.id]
@@ -50,7 +51,7 @@ exports.initEventbus = (runtime) => {
       }
     })
 
-    // send remote events
+    // Send remote events
     if (runtime.transport) {
       Object.values(groupedEndpoints)
         .forEach(groupedEndpoint => {

package/lib/runtime/{init-metrics.js → initMetrics.js}

@@ -1,4 +1,5 @@
 const { isPlainObject, isFunction } = require('@weave-js/utils')
+const { WeaveError } = require('../errors')
 const { registerCommonMetrics, updateCommonMetrics } = require('../metrics/common')
 const MetricTypes = require('../metrics/types')
 
@@ -32,7 +33,7 @@ exports.initMetrics = (runtime) => {
           // Load adapters
           if (metricOptions.adapters) {
             if (!Array.isArray(metricOptions.adapters)) {
-              runtime.handleError(new Error('Metic adapter needs to be an Array'))
+              runtime.handleError(new WeaveError('Metic adapter needs to be an Array.'))
             }
 
             this.adapters = metricOptions.adapters.map(adapter => {
@@ -50,21 +51,21 @@ exports.initMetrics = (runtime) => {
         },
         register (obj) {
           if (!isPlainObject(obj)) {
-            runtime.handleError(new Error('Param needs to be an object.'))
+            runtime.handleError(new WeaveError('Param needs to be an object.'))
           }
 
           if (!obj.type) {
-            runtime.handleError(new Error('Type is missing.'))
+            runtime.handleError(new WeaveError('Type is missing.'))
           }
 
           if (!obj.name) {
-            runtime.handleError(new Error('Name is missing.'))
+            runtime.handleError(new WeaveError('Name is missing.'))
           }
 
           const createMetricType = MetricTypes.resolve(obj.type)
 
           if (!createMetricType) {
-            runtime.handleError(new Error('Unknown metric type.'))
+            runtime.handleError(new WeaveError('Unknown metric type.'))
           }
 
           const type = createMetricType(this, obj)
@@ -81,7 +82,7 @@ exports.initMetrics = (runtime) => {
           const item = this.storage.get(name)
 
           if (!item) {
-            runtime.handleError(new Error('Item not found.'))
+            runtime.handleError(new WeaveError('Item not found.'))
           }
 
           item.increment(labels, value, timestamp)
@@ -94,7 +95,7 @@ exports.initMetrics = (runtime) => {
           const item = this.storage.get(name)
 
           if (!item) {
-            runtime.handleError(new Error('Item not found.'))
+            runtime.handleError(new WeaveError('Item not found.'))
           }
 
           item.decrement(labels, value, timestamp)
@@ -107,7 +108,7 @@ exports.initMetrics = (runtime) => {
           const item = this.storage.get(name)
 
           if (!isFunction(item.set)) {
-            runtime.handleError(new Error('Invalid metric type'))
+            runtime.handleError(new WeaveError('Invalid metric type'))
           }
 
           item.set(value, labels, timestamp)
@@ -137,12 +138,12 @@ exports.initMetrics = (runtime) => {
           const item = this.storage.get(name)
 
           if (!item) {
-            runtime.handleError(new Error('Item not found.'))
+            runtime.handleError(new WeaveError('Item not found.'))
           }
 
           return item
         },
-        list (options = {}) {
+        list (/* options = {} */) {
           const results = []
 
           this.storage.forEach(metric => {

package/lib/runtime/{init-tracing.js → initTracing.js}

@@ -9,6 +9,8 @@ exports.initTracer = (runtime) => {
 
   Object.defineProperty(runtime, 'tracer', {
     value: {
+      runtime,
+      options,
       log,
       async stop () {
         if (collectors.length > 0) {
@@ -55,7 +57,6 @@ exports.initTracer = (runtime) => {
       collectors = options.collectors
         .map(entry => {
           const initCollector = resolveCollector(runtime, entry, this)
-          // collector.init(this)
           initCollector.init(runtime)
           return initCollector
         })

package/lib/tracing/collectors/base.js

@@ -1,26 +1,25 @@
-const { isObject } = require('@weave-js/utils')
-const { WeaveError } = require('../../errors')
+const { isObject, pick } = require('@weave-js/utils')
 
-exports.createBaseTracingCollector = (options) => {
+exports.createBaseTracingCollector = (runtime) => {
   const baseTracingCollector = Object.create(null)
 
-  baseTracingCollector.options = options
+  baseTracingCollector.options = runtime.tracer.options
 
-  baseTracingCollector.init = (runtime, tracer) => {
+  baseTracingCollector.init = (runtime) => {
     baseTracingCollector.runtime = runtime
-    baseTracingCollector.tracer = tracer
+    baseTracingCollector.tracer = runtime.tracer
   }
 
   baseTracingCollector.startedSpan = () => {
-    throw new WeaveError('not implemented.')
+    // throw new WeaveError('not implemented.')
   }
 
   baseTracingCollector.finishedSpan = () => {
-    throw new WeaveError('not implemented.')
+    // throw new WeaveError('not implemented.')
   }
 
   baseTracingCollector.stop = () => {
-    throw new WeaveError('not implemented.')
+    // throw new WeaveError('not implemented.')
   }
 
   baseTracingCollector.flattenTags = (obj, convertToString = false, path = '') => {
@@ -42,18 +41,11 @@ exports.createBaseTracingCollector = (options) => {
     }, {})
   }
 
-  baseTracingCollector.getErrorFields = (error, ...fields) => {
-    if (!error) {
+  baseTracingCollector.getErrorFields = (err, fields) => {
+    if (!err) {
       return null
     }
-
-    const picked = {}
-
-    for (const field of fields) {
-      picked[field] = error[field]
-    }
-
-    return picked
+    return pick(err, fields)
   }
 
   return baseTracingCollector

package/lib/tracing/collectors/event.js

@@ -13,7 +13,7 @@ const mergeDefaultOptions = (options) => {
 module.exports = (options) => (runtime, tracer) => {
   options = mergeDefaultOptions(options)
 
-  const exporter = createBaseTracingCollector(options)
+  const exporter = createBaseTracingCollector(runtime)
 
   exporter.init(runtime, tracer)
 
@@ -28,7 +28,7 @@ module.exports = (options) => (runtime, tracer) => {
         const newSpan = Object.assign({}, span)
 
         if (newSpan.error) {
-          newSpan.error = exporter.getErrorFields(newSpan.error)
+          newSpan.error = exporter.getErrorFields(newSpan.error, exporter.options.errors.fields)
         }
 
         return newSpan

package/lib/tracing/collectors/index.js

@@ -11,14 +11,14 @@ const getByName = name => {
   return collectors[n]
 }
 
-exports.resolveCollector = (runtime, collector, tracer) => {
+exports.resolveCollector = (runtime, collector) => {
   let CollectorClass
   if (typeof collector === 'string') {
     CollectorClass = getByName(collector)
   }
 
   if (isFunction(collector)) {
-    return collector(runtime, tracer)
+    return collector(runtime)
   }
 
   if (typeof collector === 'object') {

package/lib/tracing/span.js

@@ -3,8 +3,8 @@ const hrTime = require('./time')
 exports.createSpan = (tracer, name, options) => {
   const span = Object.assign({}, {
     name,
-    id: options.id || tracer.broker.getUUID(),
-    traceId: options.traceId || tracer.broker.getUUID(),
+    id: options.id || tracer.runtime.generateUUID(),
+    traceId: options.traceId || tracer.runtime.generateUUID(),
     parentId: options.parentId,
     type: options.type,
     sampled: options.sampled || tracer.shouldSample(),
@@ -12,10 +12,12 @@ exports.createSpan = (tracer, name, options) => {
     tags: {}
   })
 
-  span.service = {
-    name: options.service.name,
-    version: options.service.version,
-    fullyQualifiedName: options.service.fullyQualifiedName
+  if (options.service) {
+    span.service = {
+      name: options.service.name,
+      version: options.service.version,
+      fullyQualifiedName: options.service.fullyQualifiedName
+    }
   }
 
   span.addTags = (tags) => {

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/{adapter-base.js → adapteBase.js}

@@ -6,6 +6,21 @@
 
 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'
 

package/lib/transport/adapters/adapters.js

@@ -4,6 +4,6 @@
  * Copyright 2019 Fachwerk
  */
 
-exports.BaseAdapter = require('./adapter-base')
+exports.BaseAdapter = require('./adapteBase')
 exports.Dummy = require('./dummy')
 exports.TCP = require('./tcp')

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

@@ -4,7 +4,7 @@
  * Copyright 2021 Fachwerk
  */
 
-const TransportBase = require('../adapter-base')
+const TransportBase = require('../adapteBase')
 const EventEmitter = require('eventemitter2').EventEmitter2
 
 // create a global eventbus to pass messages between weave service brokers.
@@ -18,7 +18,7 @@ const DummyTransportAdapter = (adapterOptions) => {
 
   return Object.assign(TransportBase(adapterOptions), {
     name: 'Dummy',
-    connect (isTryReconnect = false) {
+    connect () {
       this.bus.emit('$adapter.connected', false)
       this.log.info('Dummy transport client connected.')
       return Promise.resolve()

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) {