@weave-js/core 0.10.0 → 0.12.0

package/lib/broker/index.js

@@ -6,10 +6,10 @@
 */
 
 // node packages
-const path = require('path')
-const glob = require('glob')
-const { isFunction } = require('@weave-js/utils')
-const Middlewares = require('../middlewares')
+const { isFunction } = require('@weave-js/utils');
+const path = require('path');
+const glob = require('glob');
+const Middlewares = require('../middlewares');
 
 /**
  * Creates a new Weave Broker instance
@@ -28,353 +28,375 @@ exports.createBrokerInstance = (runtime) => {
     validator,
     log,
     services,
-    transport,
-    metrics,
-    cache
-  } = runtime
+    transport
+  } = runtime;
 
   // Log Messages
-  log.info(`Initializing #weave node version ${version}`)
-  log.info(`Node Id: ${options.nodeId}`)
+  log.info(`Initializing #weave node version ${version}`);
+  log.info(`Node Id: ${options.nodeId}`);
 
+  // Output namespace
   if (options.namespace) {
-    log.info(`Namespace: ${options.namespace}`)
+    log.info(`Namespace: ${options.namespace}`);
   }
 
-  if (metrics) {
-    metrics.init()
+  // Init metrics
+  if (runtime.metrics) {
+    runtime.metrics.init();
   }
 
-  if (cache) {
-    cache.init()
+  // Init cache
+  if (runtime.cache) {
+    runtime.cache.init();
   }
 
   // broker object
   /** @type {Broker} */
-  const broker = {
-    nodeId: options.nodeId,
-    version,
-    options,
-    runtime,
-    bus,
-    validator,
-    contextFactory,
-    log,
-    createLogger: runtime.createLogger,
-    getUUID: () => runtime.generateUUID(),
-    registry,
-    getNextActionEndpoint (actionName, options = {}) {
-      return registry.getNextAvailableActionEndpoint(actionName, options)
-    },
-    emit: eventBus.emit.bind(this),
-    broadcast: eventBus.broadcast.bind(this),
-    broadcastLocal: eventBus.broadcastLocal.bind(this),
-    call: runtime.actionInvoker.call.bind(this),
-    multiCall: runtime.actionInvoker.multiCall.bind(this),
-    waitForServices: services.waitForServices.bind(this),
-    createService: services.createService.bind(this),
-    /**
-     * Load and register a service from file.
-     * @param {string} fileName Path to the service file.
-     * @returns {Service} Service
-    */
-    loadService (fileName) {
-      const filePath = path.resolve(fileName)
-      const schema = require(filePath)
-      const service = this.createService(schema)
-
-      // If the "watchSevrices" option is set - add service to service watcher.
-      if (options.watchServices) {
-        service.filename = fileName
-        services.watchService.call(this, service)
-      }
+  const broker = Object.create(null);
 
-      return service
-    },
-    /**
-     * Load services from a folder.
-     * @param {string} [folder='./services'] Path of the folder.
-     * @param {string} [fileMask='*.service.js'] Pattern of the service files
-     * @returns {number} Amount of services
-    */
-    loadServices (folder = './services', fileMask = '*.service.js') {
-      const serviceFiles = glob.sync(path.join(folder, fileMask))
-
-      log.info(`Searching services in folder '${folder}' with name pattern '${fileMask}'.`)
-      log.info(`${serviceFiles.length} services found.`)
-
-      serviceFiles.forEach(fileName => this.loadService(fileName))
-      return serviceFiles.length
-    },
-    /**
-     * Starts the broker.
-     * @returns {Promise} Promise
-    */
-    async start () {
-      const startTime = Date.now()
-      await middlewareHandler.callHandlersAsync('starting', [runtime], true)
-
-      if (transport) {
-        await transport.connect()
-      }
+  broker.runtime = runtime;
+  broker.registry = registry;
+  broker.bus = bus;
+  broker.nodeId = options.nodeId;
+  broker.version = version;
+  broker.options = options;
+  broker.validator = validator;
+  broker.contextFactory = contextFactory;
+  broker.log = log;
+  broker.createLogger = runtime.createLogger;
 
-      try {
-        await Promise.all(services.serviceList.map(service => service.start()))
-      } catch (error) {
-        log.error(error, 'Unable to start all services')
-        clearInterval(options.waitForServiceInterval)
-        throw error
-      }
+  broker.getUUID = function () {
+    return runtime.generateUUID();
+  };
 
-      runtime.state.isStarted = true
-      eventBus.broadcastLocal('$broker.started')
-      registry.generateLocalNodeInfo(true)
+  broker.getNextActionEndpoint = function (actionName, options = {}) {
+    return registry.getNextAvailableActionEndpoint(actionName, options);
+  };
 
-      if (transport) {
-        await transport.setReady()
-      }
+  broker.emit = eventBus.emit.bind(broker);
 
-      await middlewareHandler.callHandlersAsync('started', [runtime], true)
+  broker.broadcast = eventBus.broadcast.bind(broker);
 
-      if (runtime.state.isStarted && isFunction(options.started)) {
-        options.started.call(this)
-      }
+  broker.broadcastLocal = eventBus.broadcastLocal.bind(broker);
 
-      const duration = Date.now() - startTime
-      log.info(`Node "${options.nodeId}" with ${services.serviceList.length} services successfully started in ${duration}ms.`)
-    },
-    /**
-     * Stops the broker.
-     * @returns {Promise} Promise
-    */
-    async stop () {
-      runtime.state.isStarted = false
-      log.info('Shutting down the node...')
-
-      await middlewareHandler.callHandlersAsync('stopping', [runtime], true)
-
-      try {
-        await Promise.all(services.serviceList.map(service => service.stop()))
-      } catch (error) {
-        log.error(error, 'Unable to stop all services.')
-        throw error
-      }
+  broker.call = runtime.actionInvoker.call.bind(broker);
 
-      if (transport) {
-        await transport.disconnect()
-      }
+  broker.multiCall = runtime.actionInvoker.multiCall.bind(broker);
 
-      if (runtime.cache) {
-        log.debug('Stopping caching adapters.')
-        await runtime.cache.stop()
-      }
+  broker.waitForServices = services.waitForServices.bind(broker);
 
-      if (runtime.metrics) {
-        log.debug('Stopping metrics.')
-        await runtime.metrics.stop()
-      }
+  broker.createService = services.createService.bind(broker);
 
-      if (runtime.tracer) {
-        log.debug('Stopping tracing adapters.')
-        await runtime.tracer.stop()
-      }
+  /**
+   * Global error handler of the broker.
+   * @param {*} error Error
+   * @returns {void}
+  */
+  broker.handleError = runtime.handleError;
 
-      await middlewareHandler.callHandlersAsync('stopped', [runtime], true)
+  broker.fatalError = runtime.fatalError;
 
-      if (!runtime.state.isStarted && isFunction(options.stopped)) {
-        options.stopped.call(runtime)
-      }
+  /**
+  * Load and register a service from file.
+  * @param {string} filename Path to the service file.
+  * @returns {Service} Service
+  */
+  broker.loadService = function (filename) {
+    const filePath = path.resolve(filename);
+    const schema = require(filePath);
+    const service = broker.createService(schema);
+
+    if (service) {
+      service.filename = filename;
+    }
 
-      log.info('The node was successfully shut down. Bye bye! 👋')
-
-      eventBus.broadcastLocal('$broker.stopped')
-
-      process.removeListener('beforeExit', onClose)
-      process.removeListener('exit', onClose)
-      process.removeListener('SIGINT', onClose)
-      process.removeListener('SIGTERM', onClose)
-
-      // todo: handle errors
-    },
-    /**
-     * Send a ping to connected nodes.
-     * @param {*} nodeId Node id
-     * @param {number} [timeout=3000] Ping timeout
-     * @returns {Array} Ping result
-    */
-    ping (nodeId, timeout = 3000) {
-      if (transport && transport.isConnected) {
-        if (nodeId) {
-          return new Promise((resolve) => {
-            const timeoutTimer = setTimeout(() => {
-              bus.off('$node.pong', pongHandler)
-              return resolve(null)
-            }, timeout)
-
-            const pongHandler = pong => {
-              clearTimeout(timeoutTimer)
-              bus.off('$node.pong', pongHandler)
-              resolve(pong)
-            }
+    return service;
+  };
 
-            bus.on('$node.pong', pongHandler)
-            transport.sendPing(nodeId)
-          })
-        } else {
-          // handle arrays
-          const pongs = {}
-
-          const nodes = registry.getNodeList({})
-            .filter(node => !node.isLocal)
-            .map(node => node.id)
-
-          const onFlight = new Set(nodes)
-
-          nodes.forEach(nodeId => {
-            pongs[nodeId] = null
-          })
-
-          return new Promise((resolve) => {
-            // todo: handle timeout
-            const timeoutTimer = setTimeout(() => {
-              bus.off('$node.pong', pongHandler)
-              resolve(pongs)
-            }, timeout)
-
-            const pongHandler = pong => {
-              pongs[pong.nodeId] = pong
-              onFlight.delete(pong.nodeId)
-              if (onFlight.size === 0) {
-                clearTimeout(timeoutTimer)
-                bus.off('$node.pong', pongHandler)
-                resolve(pongs)
-              }
+  broker.loadServices = function (folder = './services', fileMask = '*.service.js') {
+    const serviceFiles = glob.sync(path.join(folder, fileMask));
+
+    log.info(`Searching services in folder '${folder}' with name pattern '${fileMask}'.`);
+    log.info(`${serviceFiles.length} services found.`);
+
+    serviceFiles.forEach(fileName => broker.loadService(fileName));
+    return serviceFiles.length;
+  };
+
+  /**
+  * Starts the broker.
+  * @returns {Promise} Promise
+  */
+  broker.start = async function () {
+    const startTime = Date.now();
+    await middlewareHandler.callHandlersAsync('starting', [runtime], true);
+
+    // If transport is used, we connect the transport adapter.
+    if (transport) {
+      await transport.connect();
+    }
+
+    try {
+      await Promise.all(services.serviceList.map(service => service.start()));
+    } catch (error) {
+      log.error(error, 'Unable to start all services');
+      clearInterval(options.waitForServiceInterval);
+      throw error;
+    }
+
+    runtime.state.isStarted = true;
+    eventBus.broadcastLocal('$broker.started');
+    // refresh local node information
+    registry.generateLocalNodeInfo(true);
+
+    // If transport is used, we set the transport ready to inform the other nodes
+    if (transport) {
+      await transport.setReady();
+    }
+
+    await middlewareHandler.callHandlersAsync('started', [runtime], true);
+
+    if (runtime.state.isStarted && isFunction(options.started)) {
+      options.started.call(broker);
+    }
+
+    const duration = Date.now() - startTime;
+    log.info(`Node "${options.nodeId}" with ${services.serviceList.length} services successfully started in ${duration}ms.`);
+  };
+
+  /**
+    * Stops the broker.
+    * @returns {Promise} Promise
+  */
+  broker.stop = async function () {
+    runtime.state.isStarted = false;
+    log.info('Shutting down the node...');
+
+    await middlewareHandler.callHandlersAsync('stopping', [runtime], true);
+
+    // Stop services
+    try {
+      await Promise.all(services.serviceList.map(service => service.stop()));
+    } catch (error) {
+      log.error(error, 'Unable to stop all services.');
+      throw error;
+    }
+
+    // Disconnect transports
+    if (transport) {
+      await transport.disconnect();
+    }
+
+    // Stop cache
+    if (runtime.cache) {
+      log.debug('Stopping caching adapters.');
+      await runtime.cache.stop();
+    }
+
+    // Stop metrics
+    if (runtime.metrics) {
+      log.debug('Stopping metrics.');
+      await runtime.metrics.stop();
+    }
+
+    // Stop tracers
+    if (runtime.tracer) {
+      log.debug('Stopping tracing adapters.');
+      await runtime.tracer.stop();
+    }
+
+    // Call "stopped" middleware method.
+    await middlewareHandler.callHandlersAsync('stopped', [runtime], true);
+
+    // Call "stopped" lifecycle hook
+    if (!runtime.state.isStarted && isFunction(options.stopped)) {
+      options.stopped.call(runtime);
+    }
+
+    log.info('The node was successfully shut down. Bye bye! 👋');
+
+    eventBus.broadcastLocal('$broker.stopped');
+
+    process.removeListener('beforeExit', onClose);
+    process.removeListener('exit', onClose);
+    process.removeListener('SIGINT', onClose);
+    process.removeListener('SIGTERM', onClose);
+
+    // todo: handle errors
+  };
+
+  /**
+   * Ping other nodes
+   * @param {string=} nodeId Node ID
+   * @param {number} timeout Timeout
+   * @returns {Object<string, number>} Result
+  */
+  broker.ping = function (nodeId, timeout = 3000) {
+    if (transport && transport.isConnected) {
+      if (nodeId) {
+        return new Promise((resolve) => {
+          const timeoutTimer = setTimeout(() => {
+            bus.off('$node.pong', pongHandler);
+            return resolve(null);
+          }, timeout);
+
+          const pongHandler = pong => {
+            clearTimeout(timeoutTimer);
+            bus.off('$node.pong', pongHandler);
+            resolve(pong);
+          };
+
+          bus.on('$node.pong', pongHandler);
+          transport.sendPing(nodeId);
+        });
+      } else {
+        // handle arrays
+        const pongs = {};
+
+        const nodes = registry.nodeCollection.list({})
+          .filter(node => !node.isLocal)
+          .map(node => node.id);
+
+        const onFlight = new Set(nodes);
+
+        nodes.forEach(nodeId => {
+          pongs[nodeId] = null;
+        });
+
+        return new Promise((resolve) => {
+          // todo: handle timeout
+          const timeoutTimer = setTimeout(() => {
+            bus.off('$node.pong', pongHandler);
+            resolve(pongs);
+          }, timeout);
+
+          const pongHandler = pong => {
+            pongs[pong.nodeId] = pong;
+            onFlight.delete(pong.nodeId);
+            if (onFlight.size === 0) {
+              clearTimeout(timeoutTimer);
+              bus.off('$node.pong', pongHandler);
+              resolve(pongs);
             }
+          };
 
-            bus.on('$node.pong', pongHandler)
-            nodes.map(nodeId => transport.sendPing(nodeId))
-          })
-        }
+          bus.on('$node.pong', pongHandler);
+          nodes.map(nodeId => transport.sendPing(nodeId));
+        });
       }
+    }
 
-      return Promise.resolve(nodeId ? null : {})
-    },
-    /**
-     * Global error handler of the broker.
-     * @param {*} error Error
-     * @returns {void}
-     */
-    handleError: runtime.handleError,
-    fatalError: runtime.fatalError
-  }
+    return Promise.resolve(nodeId ? null : {});
+  };
 
   // Register internal broker events
   broker.bus.on('$node.disconnected', ({ nodeId }) => {
-    runtime.transport.removePendingRequestsByNodeId(nodeId)
-    services.serviceChanged(false)
-  })
+    runtime.transport.removePendingRequestsByNodeId(nodeId);
+    services.serviceChanged(false);
+  });
 
   /**
    * Register middlewares
    * @param {Array<Object>} customMiddlewares Array of user defined middlewares
    * @returns {void}
    */
-  const registerMiddlewares = customMiddlewares => {
+  const registerMiddlewares = (customMiddlewares) => {
     // Register custom middlewares
     if (Array.isArray(customMiddlewares) && customMiddlewares.length > 0) {
-      customMiddlewares.forEach(middleware => middlewareHandler.add(middleware))
+      customMiddlewares.forEach(middleware => middlewareHandler.add(middleware));
     }
 
     // Add the built-in middlewares. (The order is important)
     if (options.loadInternalMiddlewares) {
-      middlewareHandler.add(Middlewares.ActionHooks)
+      middlewareHandler.add(Middlewares.ActionHooks);
 
       // Validator middleware
       if (options.validateActionParams && validator) {
-        middlewareHandler.add(Middlewares.Validator)
+        middlewareHandler.add(Middlewares.Validator);
       }
 
       // Bulkhead
       if (options.bulkhead.enabled) {
-        middlewareHandler.add(Middlewares.Bulkhead)
+        middlewareHandler.add(Middlewares.Bulkhead);
       }
 
       // Cache
       if (runtime.cache) {
-        middlewareHandler.add(runtime.cache.middleware)
+        middlewareHandler.add(Middlewares.Cache);
       }
 
       // Context tracking
       if (options.contextTracking.enabled) {
-        middlewareHandler.add(Middlewares.ContextTracker)
+        middlewareHandler.add(Middlewares.ContextTracker);
       }
 
       // Circuit breaker
       if (options.circuitBreaker.enabled) {
-        middlewareHandler.add(Middlewares.CircuitBreaker)
+        middlewareHandler.add(Middlewares.CircuitBreaker);
       }
 
       // timeout middleware
-      middlewareHandler.add(Middlewares.Timeout)
+      middlewareHandler.add(Middlewares.Timeout);
 
       // Retry policy
       if (options.retryPolicy.enabled) {
-        middlewareHandler.add(Middlewares.Retry)
+        middlewareHandler.add(Middlewares.Retry);
       }
 
       // Error handler
-      middlewareHandler.add(Middlewares.ErrorHandler)
+      middlewareHandler.add(Middlewares.ErrorHandler);
 
       // Tracing
       if (options.tracing.enabled) {
-        middlewareHandler.add(Middlewares.Tracing)
+        middlewareHandler.add(Middlewares.Tracing);
       }
 
       // Metrics
       if (options.metrics.enabled) {
-        middlewareHandler.add(Middlewares.Metrics)
+        middlewareHandler.add(Middlewares.Metrics);
       }
     }
 
     // Wrap runtime and broker methods for middlewares
-    runtime.actionInvoker.call = middlewareHandler.wrapMethod('call', runtime.actionInvoker.call)
-    runtime.actionInvoker.multiCall = middlewareHandler.wrapMethod('multiCall', broker.multiCall)
-    runtime.eventBus.emit = middlewareHandler.wrapMethod('emit', runtime.eventBus.emit)
-    runtime.eventBus.broadcast = middlewareHandler.wrapMethod('broadcast', runtime.eventBus.broadcast)
-    runtime.eventBus.broadcastLocal = middlewareHandler.wrapMethod('broadcastLocal', runtime.eventBus.broadcastLocal)
-
-    // Wrap Brober methods
-    broker.createService = middlewareHandler.wrapMethod('createService', broker.createService)
-    broker.loadService = middlewareHandler.wrapMethod('loadService', broker.loadService)
-    broker.loadServices = middlewareHandler.wrapMethod('loadServices', broker.loadServices)
-  }
+    runtime.actionInvoker.call = middlewareHandler.wrapMethod('call', runtime.actionInvoker.call);
+    runtime.actionInvoker.multiCall = middlewareHandler.wrapMethod('multiCall', broker.multiCall);
+    runtime.eventBus.emit = middlewareHandler.wrapMethod('emit', runtime.eventBus.emit);
+    runtime.eventBus.broadcast = middlewareHandler.wrapMethod('broadcast', runtime.eventBus.broadcast);
+    runtime.eventBus.broadcastLocal = middlewareHandler.wrapMethod('broadcastLocal', runtime.eventBus.broadcastLocal);
+
+    // Wrap broker methods
+    broker.createService = middlewareHandler.wrapMethod('createService', broker.createService);
+    broker.loadService = middlewareHandler.wrapMethod('loadService', broker.loadService);
+    broker.loadServices = middlewareHandler.wrapMethod('loadServices', broker.loadServices);
+    broker.ping = middlewareHandler.wrapMethod('ping', broker.ping);
+  };
 
   // Run "beforeRegisterMiddlewares" hook
   if (isFunction(options.beforeRegisterMiddlewares)) {
-    options.beforeRegisterMiddlewares.call(broker, { broker, runtime })
+    options.beforeRegisterMiddlewares.call(broker, { broker, runtime });
   }
 
   // Register middlewares
-  registerMiddlewares(options.middlewares)
+  registerMiddlewares(options.middlewares);
 
   // Stop the broker greaceful
   /* istanbul ignore next */
   const onClose = () => broker.stop()
     .catch(error => broker.log.error(error))
-    .then(() => process.exit(0))
+    .then(() => process.exit(0));
 
   // SIGTERM listener
-  process.setMaxListeners(0)
-  process.on('beforeExit', onClose)
-  process.on('exit', onClose)
-  process.on('SIGINT', onClose)
-  process.on('SIGTERM', onClose)
+  process.setMaxListeners(0);
+  process.on('beforeExit', onClose);
+  process.on('exit', onClose);
+  process.on('SIGINT', onClose);
+  process.on('SIGTERM', onClose);
 
   // Add broker reference to runtime
-  Object.assign(runtime, { broker })
+  Object.assign(runtime, { broker });
 
   // Call middleware hook for broker created.
-  middlewareHandler.callHandlersSync('created', [runtime])
+  middlewareHandler.callHandlersSync('created', [runtime]);
 
-  return broker
-}
+  return broker;
+};