dcp-worker 3.2.30-1 → 3.2.30-3

package/lib/default-ui-events.js

@@ -0,0 +1,187 @@
+/**
+ *  @file       default-event.js
+ *              Default worker/sandbox events, providing default logging behaviours (event handlers)
+ *              for the dcp-worker.
+ *
+ *              - All event handlers use the *current* global console object to emit messages;
+ *                enhanced logging subsystems should intercept this object to achieve their desired
+ *                behaviours.
+ *
+ *              - All event handlers invoke functions which are properties of the eventHandlers return
+ *                value from the hook function. This means that alternate user interfaces can either
+ *                hook or intercept the properties of that object to modify the event handlers'
+ *                behaviour without actually removing/replacing the event handler on the instance of
+ *                Worker.
+ *
+ *              NOTE: This is just a convenience module. There is no requirement to use this module to
+ *                    hook worker events, this module mainly exists to make it easy for the
+ *                    dashboard-tui to replace event handlers with better ones, but it also makes it
+ *                    easier to sandbox events since we only need to register one event handler here
+ *                    to handle every sandbox.
+ *
+ *  @author     Ryan Rossiter, ryan@kingsds.network
+ *  @date       April 2020
+ *  @author     Wes Garland, wes@distributive.network
+ *  @date       June 2023
+ */
+'use strict';
+
+const sandboxEventHandlers = {};
+const workerEventHandlers = {};
+
+/**
+ *   Sandbox   1:  Slice Started:   slice 1, 0x5b5214D48F0428669c4E: Simple Job
+ *   Sandbox   1:  Slice Completed: slice 1, 0x5b5214D48F0428669c4E: Simple Job: dt 114ms
+ */
+
+/**
+ * @param    worker    The instance of Worker to hook
+ * @param    options   cliArgs from worker
+ */
+exports.hook = function hookWorkerEvents$$hook(worker, options)
+{
+  const sliceMap = {};          // jobAddress --> ( sliceNumber, t0 )
+  const truncationLength = 22;  // Extra 2 for '0x'
+
+  delete exports.hook;
+
+  function makeSliceId (sandbox, sliceNumber)
+  {
+    if (!sandbox.jobAddress)
+      return '<no job>';
+    
+    const address = sandbox.jobAddress ? sandbox.jobAddress.slice(0, truncationLength) : 'null';
+    const baseInfo = sandbox.public?.name ? `${address}: ${sandbox.public.name}` : `${address}:`;
+
+    if (!sliceNumber)
+      sliceNumber = sandbox.slice ? sandbox.slice.sliceNumber : 0;
+    return sliceNumber ? `slice ${sliceNumber}, ${baseInfo}` : baseInfo;
+  }
+
+  sandboxEventHandlers.ready = function sandboxReadyHandler(sandbox, sandboxData, ev) {
+    console.log(` . Sandbox ${sandboxData.shortId}:  Initialized`);
+  };
+
+  sandboxEventHandlers.terminated = function sandboxTerminatedHandler(sandbox, sandboxData, ev) {
+    const sliceInfo = sliceMap[sandbox.id];
+    console.log(` * Sandbox ${sandboxData.shortId}:  Terminated:      ${makeSliceId(sandbox, sliceInfo?.slice)}`);
+    delete sliceMap[sandbox.id];
+  };
+
+  sandboxEventHandlers.start = function sliceStartHandler(sandbox, sandboxData, ev) {
+    const sliceNumber = sandbox.slice ? sandbox.slice.sliceNumber : 0;
+    sliceMap[sandbox.id] = { slice: sliceNumber, t0: Date.now() };
+    console.log(` . Sandbox ${sandboxData.shortId}:  Slice Started:   ${makeSliceId(sandbox)}`);
+  };
+
+  sandboxEventHandlers.sliceProgress = function sliceProgressHandler(sandbox, sandbodData, ev) {
+    // NOP
+  };
+
+  sandboxEventHandlers.sliceFinish = function sliceFinishHandler(sandbox, sandboxData, ev) {
+    const sliceInfo = sliceMap[sandbox.id];
+    if (sliceInfo)
+      console.log(` * Sandbox ${sandboxData.shortId}:  Slice Completed: ${makeSliceId(sandbox, sliceInfo.slice)}: dt ${Date.now() - sliceInfo.t0}ms`);
+    else
+      console.log(` * Sandbox ${sandboxData.shortId}:  Slice Completed: ${makeSliceId(sandbox)}`);
+  };
+
+  workerEventHandlers.payment = function paymentHandler(ev) {
+    const payment = parseFloat(ev.payment);
+
+    if (isNaN(payment))
+      console.error(' ! Failed to parse payment:', payment);
+    else
+      console.log(` . Payment: ${payment.toFixed(3)} ⊇`);
+  };
+
+  workerEventHandlers.fetchStart = function fetchStartHandler() {
+    options.verbose && console.log(' * Fetching slices...');
+  };
+
+  workerEventHandlers.fetch = function fetchHandler(ev) {
+    var slicesFetched;
+
+    if (ev instanceof Error)
+    {
+      console.error(' ! Failed to fetch slices:', ev);
+      return;
+    }
+
+    if (typeof ev === 'number' || typeof ev === 'string') /* <= June 2023 Worker events: remove ~ Sep 2023 /wg */
+      slicesFetched = ev;
+    else
+    {
+      const task = ev;
+      slicesFetched = task.slices.length;
+    }
+
+    options.verbose && console.log(' . Fetched', slicesFetched, 'slices');
+  };
+
+  workerEventHandlers.fetchError = function fetchErrorHandler(ev) {
+    console.log(' ! Failed to fetch slices:', ev);
+  };
+
+  workerEventHandlers.submitStart = function submitStartHandler() {
+    options.verbose >= 2 && console.log(' * Submitting results...');
+  };
+
+  workerEventHandlers.submit = function submitHandler() {
+    options.verbose >= 2 && console.log(' . Submitted');
+  };
+
+  workerEventHandlers.submitError = function submitErrorHandler(ev) {
+    console.log(' ! Failed to submit results:', ev);
+  };
+
+  /* Register the appropriate event handlers on the worker and on each sandbox. The handlers are
+   * registered in such a way that mutating the exports object to supply different handlers after
+   * registration will work.
+   *
+   * The handlers registered on each sandbox receive two extra arguments before the usual event
+   * arguments; these are the sandbox handle emitted by the Worker<sandbox> event and an object
+   * called `sandboxData` which is just arbitrary storage for the eventHandlers' use, eg for memos.
+   */
+  for (let eventName in workerEventHandlers)
+    worker.addEventListener(eventName, workerEventHandlers[eventName]);
+
+  worker.on('sandbox', function newSandboxHandler(sandbox) {
+    const sandboxData = {
+      shortId: sandbox.id.toString(10).padStart(3)
+    };
+    for (let eventName in sandboxEventHandlers)
+      sandbox.addEventListener(eventName, (...args) => sandboxEventHandlers[eventName](sandbox, sandboxData, ...args));
+  });
+  
+  exports.sandboxEventHandlers = sandboxEventHandlers;
+  exports. workerEventHandlers =  workerEventHandlers;
+};
+
+/**
+ * Function to replace a worker event handler.
+ *
+ * @param {string}   eventName          name of the event to replace
+ * @param {function} eventHandler       new event handler
+ */
+exports.replaceWorkerEvent = function hookWorkerEvents$$replace(eventName, eventHandler)
+{
+  if (!workerEventHandlers.hasOwnProperty(eventName))
+    throw new Error('unknown worker event: ' + eventName + `(${Object.keys(workerEventHandlers).join(', ')})`);
+
+  workerEventHandlers[eventName] = eventHandler;
+}
+
+/**
+ * Function to replace a sandbox event handler.
+ *
+ * @param {string}   eventName          name of the event to replace
+ * @param {function} eventHandler       new event handler
+ */
+exports.replaceSandboxEvent = function hookSandboxEvents$$replace(eventName, eventHandler)
+{
+  if (!sandboxEventHandlers.hasOwnProperty(eventName))
+    throw new Error('unknown sandbox event: ' + eventName + `(${Object.keys(sandboxEventHandlers).join(', ')})`);
+
+  sandboxEventHandlers[eventName] = eventHandler;
+}

package/lib/pidfile.js

@@ -21,7 +21,7 @@ const path = require('path');
  *
  * @param {string} filename           the location of the pid file
  */
-exports.write = async function pidfile$$write(filename)
+exports.write = function pidfile$$write(filename)
 {
   var fd;
   

package/lib/remote-console.js

@@ -47,7 +47,7 @@ function daemonEval()
 
 function callbackTelnet(port, client, registry) {
   client.unref();
-  debugging() && console.debug(' ! telnetd - listening on port', port);
+  debugging() && console.notice(' ! telnetd - listening on port', port);
 }
 
 /**
@@ -76,8 +76,16 @@ exports.init = function remoteConsole$$init(...commands)
 
     console.warn('*** Enabling telnet daemon on port', port, '(security risk) ***');
 
+    if (port !== 0)
+      exports.port = port;
+    else
+    {
+      /* telnet-console library does not properly support port 0 so we mostly work-around here */
+      exports.port = Math.floor(1023 + (Math.random() * (63 * 1024)));
+    }
+
     ci = require('telnet-console').start({
-      port,
+      port: exports.port,
       callbackTelnet,
       eval: daemonEval,
       histfile: edcFilename + '.history',

package/lib/startWorkerLogger.js

@@ -1,97 +1,127 @@
 /**
  *  @file       startWorkerLogger.js
+ *              Start the DCP Worker logging subsystem. Sets console.log (etc) redirection, determine
+ *              the correct log target (screen, TUI, syslog, windows event log, file) and redirect the
+ *              output there.
  *  @author     Ryan Rossiter, ryan@kingsds.network
  *  @date       April 2020
+ *  @author     Wes Garland, wes@distributive.network
  */
+'use strict';
 
 const process = require('process');
 const os = require('os');
-require('./worker-loggers/common-types');
+const util = require('util');
 
 /**
  * Detects and returns the appropriate logger for the environment
+ * @param {object} options - cliArgs from worker
  * @returns {WorkerLogger}
  */
-function getLogger({ outputMode='detect' }) {
-  if (outputMode === 'detect') {
-    if (process.stdout.isTTY && os.platform() !== 'win32' &&
-        process.env.LANG && process.env.LANG.match(/utf-?8/i)) {
-      outputMode = 'dashboard';
-    } else {
-      outputMode = 'console';
-    }
+function getLogger(options)
+{
+  if (options.outputMode === 'detect')
+  {
+    options.outputMode = 'console';
+    /* have TTY - use dashboard when charset supports line drawing */
+    if ((process.env.LANG && process.env.LANG.match(/utf-|latin-|iso-8859-/i)) || os.platform() === 'win32')
+      options.outputMode = 'dashboard';
   }
 
   try
   {
-    const om = require('path').basename(outputMode);
+    const om = require('path').basename(options.outputMode);
     return require('./worker-loggers/' + om);
   }
   catch (error)
   {
-    console.error(`032: Failed to load worker logger "${outputMode}":`, error);
-
     if (error.code === 'MODULE_NOT_FOUND')
-      throw new Error(`Unknown outputMode "${outputMode}"`);
+      throw new Error(`Unknown outputMode "${options.outputMode}"`);
     throw error;
   }
 }
 
-const workerEvents = {
-  fetchStart:     'onFetchingSlices',
-  fetchEnd:       'onFetchedSlices',
-  fetchError:     'onFetchSlicesFailed',
-  submit:         'onSubmit',
-  submitError:    'onSubmitError',
-  payment:        'onPayment',
-}
-const supervisorEvents = {
-  submittingResult: 'onSubmitStart',
-}
-const sandboxEvents = {
-  start:          'sandbox$onSliceStart',
-  sliceProgress:  'sandbox$onSliceProgress',
-  sliceFinish:    'sandbox$onSliceFinish',
-  terminated:     'sandbox$onWorkerStop',
-}
+/**
+ * Start intercepting console.* methods so that log output from the worker goes to the appropriate log
+ * target; eg syslog, file, windows event log, etc. Unlike the telnet console log interceptor which is
+ * merely a passthrough shim, this is a "dead end" interceptor - we do not pass the log message through
+  * to the original console method.  This implies, for example, that sending console messages to syslogd
+ * quiesces the tty output.
+ * 
+ * @param {object} options - cliArgs from worker
+ */
+exports.init = function startWorkerLogger$$init(options)
+{
+  const logger = getLogger(options);
+
+  logger.init(options);
 
-Object.assign(exports, {
-  /**
-   * This method will attach event listeners from the provided
-   * worker to a worker logger. The logger to use is
-   * determined by getLogger based on the environment.
-   * 
-   * @param {Worker} worker 
-   * @param {object} options
-   * @param {number} options.verbose
-   * @param {boolean} options.outputMode - which logger to use (default='detect')
+  /* The logger module's exports are its API. The following functions are supported, in this order
+   * of severity:
+   * . debug: debug-level message
+   * . info:  informational message
+   * . log:   normal, but significant, condition
+   * . warn:  warning conditions
+   * . error: error conditions
+   *
+   * Additionally, generic functions may be used when one of the above is not defined:
+   * . at:    write a log message at a specific log level; the level is the first argument
+   * . raw:   same as at, but arguments are not formatted
+   * . any:   write a log message without regard to log level
+   *
+   * All of these functions, with the exception of raw, receive only string arguments.
    */
-  startWorkerLogger(worker, options={}) {
-    const logger = getLogger(options);
-    logger.init(worker, options);
 
-    for (const [ev, handler] of Object.entries(workerEvents))
+  for (let level of ['debug', 'error', 'info', 'log', 'warn'])
+  {
+    if (logger[level])
+      console[level] = (...args) => logger[level](          ...format(...args));
+    else if (logger.at)
+      console[level] = (...args) => logger.at(level,        ...format(...args));
+    else if (logger.raw)
+      console[level] = (...args) => logger.raw(level,       ...args);
+    else if (logger.any)
+      console[level] = (...args) => logger.any(`${level}:`, format(...args));
+    else
+    {
+      require('./remote-console').reintercept();
+      throw new Error('logger module missing export for ' + level);
+    }
+  }
+
+  require('./remote-console').reintercept();
+}  
+
+/**
+ * Format console.log arguments for use by a non-native logger, eg syslog.  All non-string arguments are
+ * converted into the best human-readable strings we can muster.
+ */
+function format(...argv)
+{
+  for (let i in argv)
+  {
+    try
     {
-      if (typeof logger[handler] === 'function')
-        worker.on(ev, logger[handler].bind(logger));
+      if (typeof argv[i] === 'object' && argv[i] instanceof String)
+        argv[i] = String(argv[i]);
+      if (typeof argv[i] === 'object')
+        argv[i] = util.inspect(argv[i], exports.inspectOptions);
+      if (typeof argv[i] !== 'string')
+        argv[i] = String(argv[i]);
     }
-    for (const [ev, handler] of Object.entries(supervisorEvents))
+    catch(e)
     {
-      if (typeof logger[handler] === 'function')
-        worker.addSupervisorEventListener(ev, logger[handler].bind(logger));
+      if (e instanceof TypeError)
+        argv[i] = '[encoding error: ' + e.message + ']';
     }
-
-    worker.on('sandbox', (sandbox) => {
-      /**
-       * logger.onSandboxStart can return a data object that will be provided to
-       * the other sandbox event handlers
-       */
-      const data = logger.onSandboxReady(sandbox) || {};
-      for (const [ev, handler] of Object.entries(sandboxEvents))
-      {
-        if (typeof logger[handler] === 'function')
-          sandbox.on(ev, logger[handler].bind(logger, sandbox, data));
-      }
-    });
   }
-});
+
+  return argv;
+}
+
+/**
+ * Options for util.inspect. Loggers which cannot deal with colours should force this false.
+ */
+exports.inspectOptions = {
+  colors: process.stdout.hasColors() || process.env.FORCE_COLOR,
+};

package/lib/worker-loggers/console.js

@@ -1,114 +1,30 @@
 /**
- *  @file       worker-loggers/console.js
- *  @author     Ryan Rossiter, ryan@kingsds.network
- *  @date       April 2020
- * 
- *  This worker logger uses console.log to produce
- *  simple log output.
+ * @file        worker-loggers/console.js
+ *              Logger interface which just logs to the node console on stdout/stderr.
+ * @author      Wes Garland, wes@distributive.network
+ * @date        June 2023
  */
+'use strict';
 
-require('./common-types');
+const process = require('process');
 
-/**
- * When this.enhancedDisplay is true
- *   Sandbox   1:  Slice Started:   slice 1, 0x5b5214D48F0428669c4E: Simple Job
- *   Sandbox   1:  Slice Completed: slice 1, 0x5b5214D48F0428669c4E: Simple Job: dt 114ms
- * When this.enhancedDisplay is false
- *   Sandbox   1:  Slice Started:   0x5b5214D48F0428669c4E68779896D29D77c42903 Simple Job
- *   Sandbox   1:  Slice Completed: 0x5b5214D48F0428669c4E68779896D29D77c42903 Simple Job
- * @type {WorkerLogger}
- */
-const consoleLogger = {
-  init(worker, options) {
-    this.worker = worker;
-    this.options = Object.assign({}, options);
-    this.sliceMap = {};          // jobAddress --> ( sliceNumber, t0 )
-    this.enhancedDisplay = true; // When false, no timing, no sliceNumber, full jobAddress
-    this.truncationLength = 22;  // Extra 2 for '0x'
-  },
-
-  id (sandbox, sliceNumber) {
-    if (!this.enhancedDisplay)
-      return sandbox.public ? `${sandbox.jobAddress} ${sandbox.public.name}` : `${sandbox.jobAddress}`;
-
-    const address = sandbox.jobAddress ? sandbox.jobAddress.slice(0, this.truncationLength) : 'null';
-    const baseInfo = sandbox.public ? `${address}: ${sandbox.public.name}` : `${address}:`;
-
-    if (!sliceNumber)
-      sliceNumber = sandbox.slice ? sandbox.slice.sliceNumber : 0;
-    return sliceNumber ? `slice ${sliceNumber}, ${baseInfo}` : baseInfo;
-  },
-
-  onSandboxReady(sandbox) {
-    const shortId = sandbox.id.toString(10).padStart(3);
+exports.init = function console$$init(options)
+{
+  const myConsole = new (require('console').Console)(process);
 
-    const sandboxData = {
-      shortId,
+  delete exports.init; // singleton
+  if (process.env.RAW_CONSOLE)
+  {
+    /* raw mode is used to debug node-inspect problems by dumping raw types directly to console.log */
+    exports.raw = function console$$raw(level, ...args) {
+      myConsole[level](...args);
     };
-
-    console.log(` * Sandbox ${sandboxData.shortId}:  Initialized`);
-
-    return sandboxData;
-  },
-
-  sandbox$onSliceStart(sandbox, sandboxData, ev) {
-    const sliceNumber = sandbox.slice ? sandbox.slice.sliceNumber : 0;
-    this.sliceMap[sandbox.id] = { slice: sliceNumber, t0: Date.now() };
-    console.log(` * Sandbox ${sandboxData.shortId}:  Slice Started:   ${this.id(sandbox)}`);
-  },
-
-  sandbox$onSliceProgress(sandbox, sandboxData, ev) {
-    // something
-  },
-
-  sandbox$onSliceFinish(sandbox, sandboxData, ev) {
-    const sliceInfo = this.sliceMap[sandbox.id];
-    if (sliceInfo && this.enhancedDisplay)
-      console.log(` * Sandbox ${sandboxData.shortId}:  Slice Completed: ${this.id(sandbox, sliceInfo.slice)}: dt ${Date.now() - sliceInfo.t0}ms`);
-    else
-      console.log(` * Sandbox ${sandboxData.shortId}:  Slice Completed: ${this.id(sandbox)}`);
-  },
-
-  sandbox$onWorkerStop(sandbox, sandboxData, ev) {
-    const sliceInfo = this.sliceMap[sandbox.id];
-    delete this.sliceMap[sandbox.id];
-    console.log(` * Sandbox ${sandboxData.shortId}:  Terminated:      ${this.id(sandbox, sliceInfo?.slice)}`);
-  },
-
-  onPayment({ payment }) {
-    try {
-      payment = parseFloat(payment);
-    } catch (e) {
-      console.error(" ! Failed to parse payment:", payment);
-      return;
-    }
-
-    if (payment > 0) console.log(` * DCC Credit: ${payment.toFixed(3)}`);
-  },
-
-  onFetchingSlices() {
-    this.options.verbose && console.log(" * Fetching slices...");
-  },
-
-  onFetchedSlices(ev) {
-    this.options.verbose && console.log(" * Fetched", ev);
-  },
-
-  onFetchSlicesFailed(ev) {
-    console.log(" ! Failed to fetch slices:", ev);
-  },
-
-  onSubmitStart() {
-    this.options.verbose >= 2 && console.log(" * Submitting results...");
-  },
-
-  onSubmit() {
-    this.options.verbose >= 2 && console.log(" * Submitted");
-  },
-
-  onSubmitError(ev) {
-    console.log(" ! Failed to submit results:", ev);
-  },
-};
-
-Object.assign(exports, consoleLogger);
+  }
+  else
+  {
+    /* Log a single string to the console; conceptually very similar to other loggers */
+    exports.at = function console$$at(level, ...args) {
+      myConsole[level](args.join(' '));
+    };
+  }
+}