dcp-worker 3.2.30-7 → 3.2.30-9

package/lib/startWorkerLogger.js

@@ -1,127 +1,94 @@
 /**
  *  @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');
-const util = require('util');
+require('./worker-loggers/common-types');
 
 /**
  * Detects and returns the appropriate logger for the environment
- * @param {object} options - cliArgs from worker
  * @returns {WorkerLogger}
  */
-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';
+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';
+    }
   }
 
   try
   {
-    const om = require('path').basename(options.outputMode);
+    const om = require('path').basename(outputMode);
     return require('./worker-loggers/' + om);
   }
   catch (error)
   {
-    if (error.code === 'MODULE_NOT_FOUND')
-      throw new Error(`Unknown outputMode "${options.outputMode}"`);
-    throw error;
+    console.error(`032: Failed to load worker logger "${outputMode}":`, error);
+    throw new Error(`Unknown outputMode "${outputMode}"`);
   }
 }
 
-/**
- * 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);
+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',
+}
 
-  /* 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.
+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')
    */
+  startWorkerLogger(worker, options={}) {
+    const logger = getLogger(options);
+    logger.init(worker, options);
 
-  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
+    for (const [ev, handler] of Object.entries(workerEvents))
     {
-      require('./remote-console').reintercept();
-      throw new Error('logger module missing export for ' + level);
+      if (typeof logger[handler] === 'function')
+        worker.on(ev, logger[handler].bind(logger));
     }
-  }
-
-  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
+    for (const [ev, handler] of Object.entries(supervisorEvents))
     {
-      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]);
+      if (typeof logger[handler] === 'function')
+        worker.addSupervisorEventListener(ev, logger[handler].bind(logger));
     }
-    catch(e)
-    {
-      if (e instanceof TypeError)
-        argv[i] = '[encoding error: ' + e.message + ']';
-    }
-  }
 
-  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,
-};
+    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));
+      }
+    });
+  }
+});

package/lib/worker-loggers/common-types.js

@@ -0,0 +1,24 @@
+/**
+ * @typedef WorkerLogger
+ * @property {onSandboxReady} onSandboxReady
+ * @property {function} onPayment
+ * @property {function} onFetchingSlices
+ * @property {function} onFetchedSlices
+ * @property {function} onFetchSlicesFailed
+ * @property {SandboxCallback} sandbox$onSliceStart
+ * @property {SandboxCallback} sandbox$onSliceProgress
+ * @property {SandboxCallback} sandbox$onSliceFinish
+ * @property {SandboxCallback} sandbox$onWorkerStop
+ */
+
+/**
+ * @typedef {function} onSandboxReady
+ * @param {Sandbox} sandbox
+ * @returns {object} workerData
+ */
+
+/**
+ * @typedef {function} SandboxCallback
+ * @param {Sandbox} sandbox
+ * @param {object} workerData
+ */

package/lib/worker-loggers/console.js

@@ -1,30 +1,114 @@
 /**
- * @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
+ *  @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.
  */
-'use strict';
 
-const process = require('process');
+require('./common-types');
 
-exports.init = function console$$init(options)
-{
-  const myConsole = new (require('console').Console)(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'
+  },
 
-  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);
-    };
-  }
-  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(' '));
+  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);
+
+    const sandboxData = {
+      shortId,
     };
-  }
-}
+
+    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);

package/lib/worker-loggers/dashboard.js

@@ -6,42 +6,183 @@
  *  This worker logger uses the blessed library to create
  *  a monitoring dashboard for the worker.
  */
-'use strict';
 
+const dcpConfig = require('dcp/dcp-config');
+const blessed = require('blessed');
+const contrib = require('blessed-contrib');
 const chalk = require('chalk');
-const _console = new (require('console').Console)(process);
-
-exports.init = function dashboardLogger$$init(options)
-{
-  function logWrapperFactory(logLevel)
-  {
-    const inspect = Symbol.for('nodejs.util.inspect.custom');
-    const dashboardTui = require('../dashboard-tui');
-    
-    return function wrappedLogFun() {
-      if (!dashboardTui.logPane) /* no logPane => TUI not ready - fallback to console */
-      {
-        const consoleLogger = require('./console');
-        if (consoleLogger.init)
-          consoleLogger.init();
+const util = require('util');
 
-        const logAt = consoleLogger.at || consoleLogger.raw;
-        logAt(logLevel, ...arguments);
-        return;
-      }
-      
-      const argv = Array.from(arguments);
-      for (let i in argv)
+const components = require('../blessed-components');
+require('./common-types');
+
+const SLICE_FETCH_STATUS = {
+  IDLE: chalk.yellow('Idle'),
+  FETCHING: chalk.blue('Fetching Work...'),
+  WORKING: chalk.green('Working'),
+  NO_WORK: chalk.red('No Work Available'),
+}
+
+/** @type {WorkerLogger} */
+const dashboardLogger = {
+  init(worker, options) {
+    this.worker = worker;
+    this.options = options;
+    this.totalDCCs = 0;
+    this.sliceFetchStatus = SLICE_FETCH_STATUS.IDLE;
+    exports.screen = this.screen = blessed.screen();
+    const grid = new contrib.grid({rows: 3, cols: 5, screen: this.screen});
+
+    const log = grid.set(0, 2, 2, 3, components.log, {
+      label: 'Worker Log',
+      scrollable: true,
+      alwaysScroll: true,
+      mouse: true,
+      scrollbar: {
+        bg: 'blue',
+      },
+    });
+
+    console.log = console.error = console.warn = console.info = console.debug = function logWrapper() {
+      arguments = Array.from(arguments);
+      for (let i in arguments)
       {
-        if (argv[i] instanceof Error || (typeof argv[i] === 'object' && argv[i][inspect]))
-          argv[i] = util.inspect(argv[i]);
-        else if (logLevel === 'error' && typeof argv[i] === 'string')
-          argv[i] = chalk.red(argv[i]);
+        if (arguments[i] instanceof Error)
+          arguments[i] = util.inspect(arguments[i]);
       }
-      dashboardTui.logPane.log(...argv);
+      log.log.apply(log, arguments);
     }
-  }
+    require('../remote-console').reintercept();
 
-  for (let level of ['log', 'warn', 'debug', 'info', 'error'])
-    exports[level] = logWrapperFactory(level);
-}
+    this.sandboxes = grid.set(0, 0, 2, 2, components.sandboxes, {
+      label: 'Sandboxes',
+      defaultProgressBars: this.worker.cpuCores,
+      scrollable: true,
+      alwaysScroll: true,
+      mouse: true,
+      scrollbar: {
+        bg: 'blue',
+      },
+    });
+
+    this.workerInfo = grid.set(2, 0, 1, 5, blessed.text);
+    this.updateWorkerInfo();
+
+    setInterval(() => this.screen.render(), 50).unref(); /* 50ms = 20 fps */
+
+    function raise(sig)
+    {
+      process.kill(process.pid, sig);
+    }
+
+    /* Apply key bindings which mimic canonical input mode */
+    this.screen.key(['C-c'], () => raise('SIGINT'));
+    this.screen.key(['C-z'], () => raise('SIGTSTP'));
+    this.screen.key(['\u001c'], () => raise('SIGQUIT')); /* C-\ */
+
+    this.screen.key(['escape'], () => {
+      console.log('Stopping worker...');
+      worker.stop();
+    });
+  },
+
+  updateWorkerInfo() {
+    const workerOptions = dcpConfig.worker;
+    
+    this.workerInfo.setLabel(`Worker Status [${this.sliceFetchStatus}]`);
+    this.workerInfo.setContent([
+      chalk.green(` DCCs Earned: ${chalk.bold(this.totalDCCs.toFixed(7))}`),
+      '',
+      `   Scheduler: ${chalk.yellow(dcpConfig.scheduler.location.href)}`,
+      `        Bank: ${chalk.yellow(dcpConfig.bank.location.href)}`,
+      `Bank Account: ${chalk.yellow(this.worker.paymentAddress || 'Starting...')}`,
+      `    Identity: ${chalk.yellow(this.worker.identityKeystore? this.worker.identityKeystore.address : 'Starting...')}`,
+      `        Jobs: ${workerOptions.jobAddresses?.length ? workerOptions.jobAddresses.join(', ') : '<any>'}`,
+      ` Priv Groups: ${Object.keys(workerOptions.computeGroups).length}`,
+      `   Pub Group: ${workerOptions.leavePublicGroup ? 'no' : 'yes'}`,
+    ].join('\n'));
+  },
+
+  onSandboxReady(sandbox) {
+    
+  },
+
+  sandbox$onSliceStart(sandbox, sandboxData, slice) {
+    sandboxData.progressData = {
+      indeterminate: true,
+      progress: 0,
+      label: sandbox.public.name,
+    };
+
+    this.sandboxes.data.push(sandboxData.progressData);
+
+    this.sandboxes.update();
+  },
+
+  sandbox$onSliceProgress(sandbox, sandboxData, ev) {
+    if (ev.indeterminate) {
+      sandboxData.progressData.progress = 100;
+
+      setTimeout(() => {
+        if (sandboxData.progressData.indeterminate) {
+          sandboxData.progressData.progress = 0;
+          this.sandboxes.update();
+        }
+      }, 500).unref();
+    } else {
+      sandboxData.progressData.progress = ev.progress;
+      sandboxData.progressData.indeterminate = false;
+    }
+
+    this.sandboxes.update();
+  },
+  
+  sandbox$onSliceFinish(sandbox, sandboxData, ev) {
+    this.sandboxes.data =
+      this.sandboxes.data.filter(d => d != sandboxData.progressData);
+
+    this.sandboxes.update();
+  },
+    
+  sandbox$onWorkerStop(sandbox, sandboxData, ev) {
+    this.sandbox$onSliceFinish(sandbox, sandboxData, ev);
+  },
+
+  onPayment({ payment }) {
+    try {
+      payment = parseFloat(payment);
+    } catch (e) {
+      console.error("Failed to parse payment float:", payment);
+      return;
+    }
+
+    try {
+      this.totalDCCs += payment;
+      this.updateWorkerInfo();
+    } catch(e) {
+      console.error(e.message);
+    }
+  },
+
+  onFetchingSlices() {
+    this.sliceFetchStatus = SLICE_FETCH_STATUS.FETCHING;
+    this.updateWorkerInfo();
+  },
+
+  onFetchedSlices(fetchedSliceCount) {
+    if (fetchedSliceCount === 0 && this.sandboxes.data.length === 0) {
+      this.sliceFetchStatus = SLICE_FETCH_STATUS.NO_WORK;
+    } else {
+      this.sliceFetchStatus = SLICE_FETCH_STATUS.WORKING;
+    }
+
+    this.updateWorkerInfo();
+  },
+
+  onFetchSlicesFailed(ev) {
+    this.sliceFetchStatus = SLICE_FETCH_STATUS.NO_WORK;
+    this.updateWorkerInfo();
+  },
+};
+
+Object.assign(exports, dashboardLogger);

package/lib/worker-loggers/event-log.js

@@ -3,42 +3,65 @@
  *  @author     Eddie Roosenmaallen <eddie@kingsds.network>
  *  @date       August 2022
  *
- *  This logger module redirects logs to the Windows event-log, writing all
- *  console logs to it. 
+ *  This logger module emits events to the Windows event-log, writing all
+ *  console logs to it. Most worker events are passed through to be handled
+ *  by the console logger.
+ *
+ *  @TODO: This could likely be improved by handling worker events directly
+ *  and emitting events to the event log more deliberately than just
+ *  redirecting the base console output. ~ER20220831
  */
-'use strict';
 
-const os = require('os');
-if (os.platform() !== 'win32')
-  throw new Error(`Windows Event Log module is not supported on ${os.platform()}`);
+require('./common-types');
+const consoleLogger = require('./console');
 
 const { EventLog } = require('node-eventlog');
 
 // Copy the original global console object's properties onto a backup
 const _console = Object.assign({}, console);
 
-/**
- *  Initialize the eventlog worker logger
- *
- *  @param  {object} options          Options for logger behaviour (passed
- *    through to consoleLogger)
- */
-exports.init = function eventLog$$init(options)
-{
-  exports._processName = require('path').basename(process.mainModule.filename || process.argv0);
-  const source = options.source || exports._processName || 'dcp-worker';
-  exports._eventLog = new EventLog(source);
-  require('../startWorkerLogger').inspectOptions.colors = false;
-  exports.at = log;
-}
 
-/**
- * @param {string}    level    The node log level to log at
- * @param {[string]}  items    An array of strings to log as a single message
- */
-function log(level, ...items)
-{
-  {    
+const eventlogLogger = {
+  /**
+   *  Initialize the eventlog worker logger
+   *
+   *  @param  {Worker} worker           DCP Worker object to log
+   *  @param  {object} options          Options for logger behaviour (passed
+   *    through to consoleLogger)
+   */
+  init(worker, options) {
+    consoleLogger.init(worker, options);
+
+    this._processName = require('path').basename(process.mainModule.filename || process.argv0);
+    const source = options.source || this._processName || 'dcp-worker';
+    // _console.log(`036: creating new EventLog(${source}) client...`);
+    this._eventLog = new EventLog(source);
+
+    ['debug','error','info','log','warn'].forEach(level => {
+      console[level] = (...args) => this._log(level, ...args);
+    });
+  },
+
+  _log(level, ...items) {
+    const strBuilder = [`${this._processName}[${process.pid}]:`];
+    
+    items.forEach(i => {
+      try {
+        switch (typeof i) {
+          case 'object':
+            strBuilder.push(JSON.stringify(i));
+            break;
+          default:
+            strBuilder.push(String(i));
+        }
+      }
+      catch (e) {
+        if (e instanceof TypeError) {
+          strBuilder.push('[encoding error: ' + e.message + ']');
+        }
+      }
+    });
+    
     // Use the string log-level to look up the severity number:
     let severity = {
       error: 'error',
@@ -48,9 +71,18 @@ function log(level, ...items)
       debug: 'info',
     }[level];
 
-    return exports._eventLog.log(items.join(' '), severity).catch(error => {
+    // _console.debug(`074: about to actually log a line:`, strBuilder, severity);
+    return this._eventLog.log(strBuilder.join(' '), severity).catch(error => {
       if (error)
         _console.error('255: Unexpected error writing to event log:', error);
     });
   }
+};
+
+// necessary to keep `this` pointing at the correct thing when we call 
+for (const [prop, value] of Object.entries(consoleLogger))
+{
+  if (typeof value === 'function')
+    exports[prop] = value.bind(consoleLogger);
 }
+Object.assign(exports, eventlogLogger);