dcp-worker 3.2.30-8 → 3.2.30-9

package/lib/remote-console.js

@@ -47,7 +47,7 @@ function daemonEval()
 
 function callbackTelnet(port, client, registry) {
   client.unref();
-  debugging() && console.notice(' ! telnetd - listening on port', port);
+  debugging() && console.debug(' ! telnetd - listening on port', port);
 }
 
 /**
@@ -76,16 +76,8 @@ 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: exports.port,
+      port,
       callbackTelnet,
       eval: daemonEval,
       histfile: edcFilename + '.history',

package/lib/startWorkerLogger.js

@@ -1,130 +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')
-    {
-      const errorMessageStart = error.message.replace(/\n.*/g, '');
-      error.message = `Unknown outputMode "${options.outputMode} (${errorMessageStart})`;
-    }
-    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
-    {
-      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]);
-    }
-    catch(e)
+    for (const [ev, handler] of Object.entries(supervisorEvents))
     {
-      if (e instanceof TypeError)
-        argv[i] = '[encoding error: ' + e.message + ']';
+      if (typeof logger[handler] === 'function')
+        worker.addSupervisorEventListener(ev, logger[handler].bind(logger));
     }
-  }
-
-  return argv;
-}
 
-/**
- * Options for util.inspect. Loggers which cannot deal with colours should force this false.
- */
-exports.inspectOptions = {
-  colors: process.stdout.isTTY && 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,43 +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);