dcp-worker 3.2.30-1 → 3.2.30-3

package/lib/worker-loggers/dashboard.js

@@ -6,183 +6,42 @@
  *  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 util = require('util');
-
-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',
-      },
-    });
+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();
 
-    console.log = console.error = console.warn = console.info = console.debug = function logWrapper() {
-      arguments = Array.from(arguments);
-      for (let i in arguments)
+        const logAt = consoleLogger.at || consoleLogger.raw;
+        logAt(logLevel, ...arguments);
+        return;
+      }
+      
+      const argv = Array.from(arguments);
+      for (let i in argv)
       {
-        if (arguments[i] instanceof Error)
-          arguments[i] = util.inspect(arguments[i]);
+        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]);
       }
-      log.log.apply(log, arguments);
-    }
-    require('../remote-console').reintercept();
-
-    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;
+      dashboardTui.logPane.log(...argv);
     }
+  }
 
-    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);
+  for (let level of ['log', 'warn', 'debug', 'info', 'error'])
+    exports[level] = logWrapperFactory(level);
+}

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

@@ -3,65 +3,42 @@
  *  @author     Eddie Roosenmaallen <eddie@kingsds.network>
  *  @date       August 2022
  *
- *  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
+ *  This logger module redirects logs to the Windows event-log, writing all
+ *  console logs to it. 
  */
+'use strict';
 
-require('./common-types');
-const consoleLogger = require('./console');
+const os = require('os');
+if (os.platform() !== 'win32')
+  throw new Error(`Windows Event Log module is not supported on ${os.platform()}`);
 
 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;
+}
 
-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 + ']');
-        }
-      }
-    });
-    
+/**
+ * @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)
+{
+  {    
     // Use the string log-level to look up the severity number:
     let severity = {
       error: 'error',
@@ -71,18 +48,9 @@ const eventlogLogger = {
       debug: 'info',
     }[level];
 
-    // _console.debug(`074: about to actually log a line:`, strBuilder, severity);
-    return this._eventLog.log(strBuilder.join(' '), severity).catch(error => {
+    return exports._eventLog.log(items.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);

package/lib/worker-loggers/logfile.js

@@ -4,122 +4,96 @@
  *  @date       August 2022
  *
  *  This logger module maintains a log file, writing all console logs to it.
- *  Most worker events are passed through to the console logger.
  */
-
-require('./common-types');
-const consoleLogger = require('./console');
+'use strict';
 
 // Copy the original global console object's properties onto a backup
 const _console = Object.assign({}, console);
 
-const logfileLogger = {
-  /**
-   *  Initialize the logfile worker logger
-   *
-   *  @param  {Worker}  worker           DCP Worker object to log
-   *  @param  {object}  options          Options for logger behaviour
-   *  @param  {string}  options.filepath Path to worker file; default: ./dcp-worker.log
-   *  @param  {boolean} options.truncate If true, logfile will be cleared at worker startup
-   */
-  init(worker, options) {
-    consoleLogger.init(worker, options);
-    
-    this._filepath = options.filepath || './dcp-worker.log';
-    this.options = options;
-    
-    options.verbose >= 3 && console.debug('050: constructing LogfileConsole', this._filepath, options);
-    
-    this._getLogFile();
-    
-    // on SIGHUP, close the output stream and open a new one
-    process.on('SIGHUP', () => {
-      this._getLogFile(true);
-    });
-
-    ['debug','error','info','log','warn'].forEach(level => {
-      console[level] = (...args) => this._log(level, ...args);
-    });
-  },
+/**
+ *  Initialize the logfile worker logger
+ *
+ *  @param  {object}  options          Options for logger behaviour
+ *  @param  {string}  options.filepath Path to worker file; default: ./dcp-worker.log
+ *  @param  {boolean} options.truncate If true, logfile will be cleared at worker startup
+ */
+exports.init = function init(options)
+{
+  delete exports.init; // singleton   
+  options.verbose >= 3 && _console.debug('050: constructing LogfileConsole', options.logfile, options);
+  getLogFile(options);
+  require('../startWorkerLogger').inspectOptions.colors = Boolean(process.env.FORCE_COLOR);
+  
+  // on SIGHUP, close the output stream and open a new one
+  process.on('SIGHUP', () => {
+    getLogFile(options);
+  });
+  
+  exports.at = log;
+}
 
-  /**
-   *  Return a handle to the WritableStream for this logger, creating one if
-   *  necessary.
-   *
-   *  @param  {boolean} forceNew If truthy, close any existing stream and open
-   *                             a new one
-   *  @return {fs.WriteStream}
-   */
-  _getLogFile(forceNew = false) {
+/**
+ *  Return a handle to the WritableStream for this logger, creating one if
+ *  necessary.
+ *
+ *  @return {fs.WriteStream}
+ */
+function getLogFile(options)
+{
+  {
     const fs = require('fs');
     
-    if (this._file)
+    if (getLogFile._file)
     {
-      if (!forceNew)
-        return this._file;
-
       try
       {
-        this._file.end();
+        getLogFile._file.end();
       }
       catch (err)
       {
         console.error('061: failed to close old log file:', err);
       }
-      this._file = false;
+      getLogFile._file = false;
     }
     
-    const options = {
-      flags: this.options.truncate ? 'w' : 'a',  // NYI: cli --truncate 
+    const fileOptions = {
+      flags: options.truncate ? 'w' : 'a',  // NYI: cli --truncate 
     }
     
-    const file = this._file = fs.createWriteStream(this._filepath, options);
+    const file = getLogFile._file = fs.createWriteStream(options.logfile, fileOptions);
     
     // On error, close & recreate the log file
     file.on('error', err => {
       _console.error('082: console-patch::LogFileConsole write error:', err);
       
-      this._getLogFile(true);
+      getLogFile(options);
     });
     
     return file;
-  },
-  
-  /** Write a log line to the output file. Items will be converted to strings as
-   *  possible and concatenated after the log-level and timestamp, then written to the
-   *  current outputStream.
-   *  @param {string} level Log level.
-   *  @param {any} ...items Items to log.
-   */
-  _log(level = 'none', ...items) {
-    const strBuilder = [
+  }
+}
+
+/** Write a log line to the output file. 
+ *  
+ *  current outputStream.
+ *  @param {string} level Log level.
+ *  @param {any} ...items Items to log.
+ */
+function log(level, ...items)
+{
+  {
+    const logPrefix = [
       (new Date()).toISOString(),
       level,
     ];
-    
-    items.forEach(i => {
-      try {
-        switch (typeof i) {
-          case 'object':
-            strBuilder.push(JSON.stringify(i));
-          default:
-            strBuilder.push(String(i));
-        }
-      }
-      catch (e) {
-        if (e instanceof TypeError) {
-          strBuilder.push('[encoding error: ' + e.message + ']');
-        }
-      }
-    });
-    
+
+    const logElements = logPrefix.concat(items);
+
     try {
-      this._file.write(strBuilder.join(' ') + '\n');
+      getLogFile._file.write(logElements.join(' ') + '\n');
     }
     catch (error) {
       _console.error('131: Unexpected error writing to log file:', error);
     }
-  },
-};
-
-Object.assign(exports, consoleLogger, logfileLogger);
+  }
+}

package/lib/worker-loggers/syslog.js

@@ -4,66 +4,45 @@
  *  @date       August 2022
  *
  *  This logger module emits log lines to a remote syslogd, 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
+ *  console logs to it.
  */
+'use strict';
 
-require('./common-types');
-const consoleLogger = require('./console');
-
-const syslog = require('syslog-client');
+const os      = require('os');
+const syslog  = require('syslog-client');
+const process = require('process');
 
 // Copy the original global console object's properties onto a backup
 const _console = Object.assign({}, console);
+var syslogClient;
+var processName;
 
-
-const eventlogLogger = {
-  /**
-   *  Initialize the syslog 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.options = Object.assign({}, options);
+/**
+ *  Initialize the syslog worker logger
+ *
+ *  @param  {object} cliArgs          Options for logger behaviour (passed
+ *                                    through to consoleLogger)
+ */
+exports.init = function syslog$$init(cliArgs)
+{
+  {
     const syslogOptions = {
-      transport: options.syslogTransport || 'udp', // tcp, udp, unix, tls
-      port: options.syslogPort || 514,
+      syslogHostname: os.hostname(),
+      transport: cliArgs.syslogTransport || 'udp', // tcp, udp, unix, tls
+      port:      cliArgs.syslogPort,
+      facility: syslog.Facility[cliArgs.syslogFacility[0].toUpperCase() + cliArgs.syslogFacility.slice(1)],
     }
 
-    this._syslog = syslog.createClient(options.syslogAddress || '127.0.0.1', options);
-    this._processName = require('path').basename(process.mainModule.filename || process.argv0);
-
-    ['debug','error','info','log','warn'].forEach(level => {
-      console[level] = (...args) => this._log(level, ...args);
-    });
-  },
+    syslogClient = syslog.createClient(cliArgs.syslogAddress || '127.0.0.1', syslogOptions);
+    processName = require('path').basename(process.mainModule.filename || process.argv0);
+    exports.close = () => syslogClient.close();
+  }
+}
 
-  _log(level, ...items) {
-    const strBuilder = [`${this._processName}[${process.pid}]:`];
-    
-    items.forEach(i => {
-      try {
-        switch (typeof i) {
-          case 'object':
-            strBuilder.push(JSON.stringify(i));
-          default:
-            strBuilder.push(String(i));
-        }
-      }
-      catch (e) {
-        if (e instanceof TypeError) {
-          strBuilder.push('[encoding error: ' + e.message + ']');
-        }
-      }
-    });
+function log(level, ...argv)
+{
+  {
+    const logPrefix = `${processName}[${process.pid}]: `;
     
     // Use the string log-level to look up the severity number:
     let severity = {
@@ -74,18 +53,17 @@ const eventlogLogger = {
       debug: syslog.Severity.Debug,
     }[level];
 
-    this._syslog.log(strBuilder.join(' '), {
-      severity,
-    }, error => {
-      if (error)
-        _console.error('168: Unexpected error writing to syslog:', error);
-    });
-  }
-};
+    const logMessages = argv.join(' ').split('\n');
 
-for (const [prop, value] of Object.entries(consoleLogger))
-{
-  if (typeof value === 'function')
-    exports[prop] = value.bind(consoleLogger);
+    for (let logMessage of logMessages)
+    {
+      logMessage = logPrefix + logMessage;
+      syslogClient.log(logMessage, { severity }, error => {
+        if (error)
+          _console.error('168: Unexpected error writing to syslog:');
+      });
+    }
+  }
 }
-Object.assign(exports, eventlogLogger);
+
+exports.at = log;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "3.2.30-1",
+  "version": "3.2.30-3",
   "description": "JavaScript portion of DCP Workers for Node.js",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -37,8 +37,9 @@
     "blessed": "^0.1.81",
     "blessed-contrib": "^4.11.0",
     "chalk": "^4.1.0",
-    "dcp-client": "4.2.32",
-    "semver": "^7.3.8"
+    "dcp-client": "gitlab:Distributed-Compute-Protocol/dcp-client#develop",
+    "semver": "^7.3.8",
+    "syslog-client": "1.1.1"
   },
   "optionalDependencies": {
     "telnet-console": "^1.0.4"

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

@@ -1,24 +0,0 @@
-/**
- * @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
- */