dcp-worker 3.2.30-3 → 3.2.30-4

package/bin/dcp-worker

@@ -4,7 +4,12 @@
  *              Standalone NodeJS DCP Worker
  *
  *  @author     Ryan Rossiter, ryan@kingsds.network
+ *              Paul, paul@distributive.network
+ *              Wes Garland, wes@distributive.network
+ *
  *  @date       April 2020
+ *              April-May 2023
+ *              May-June 2023
  */
 'use strict';
 
@@ -16,6 +21,7 @@ const path    = require('path');
 const crypto  = require('crypto');
 const chalk   = require('chalk');
 const telnetd = require('../lib/remote-console');
+const utils   = require('../lib/utils');
 
 const configName = process.env.DCP_CONFIG || '../etc/dcp-worker-config';
 const EXIT_UNHANDLED = 5;
@@ -35,7 +41,9 @@ const replHelpers = {
 };
 telnetd.init(replHelpers);
 
-/* Initialize dcp-client with local config defaults and run the main function. DCP_CONFIG_COOKIE becomes dcpConfig.cookie. */
+/* Initialize dcp-client with local config defaults and run the main function. DCP_CONFIG_COOKIE becomes dcpConfig.cookie.
+ * And dcpConfig is defined as a side effect of initializing dcp-client.
+ */
 process.env.DCP_CONFIG_COOKIE = (Math.random().toString(16)).slice(2) + '-' + process.pid + '-' + Date.now();
 require('dcp-client').init({ configName }).then(main).catch(handleUnhandled);
 
@@ -61,7 +69,6 @@ function parseCliArgs()
         alias: 'd',
         describe: 'default proportion of CPU,GPU to use when cores not specified',
         type: 'string',
-        default: JSON.stringify(dcpConfig.worker.defaultCoreDensity),
       },
       verbose: {
         alias: 'v',
@@ -400,23 +407,10 @@ async function main()
 
       function fetchEventHandler(ev)
       {
-        var slicesFetched;
-
         if (ev instanceof Error)
-        {
           console.error('Error fetching task:', 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;
-        }
-
-        dcpWorkerOptions.leavePublicGroup = Boolean(slicesFetched > 0);
+          dcpWorkerOptions.leavePublicGroup = Boolean(utils.slicesFetched(ev) > 0);
       }
     }
   }
@@ -499,12 +493,13 @@ function processCoresAndDensity (dcpWorkerOptions, cliArgs)
 
   const parseArg = (which) => {
     if (!cliArgs[which])
-      return false;
-
-    const [cpu, gpu] = cliArgs[which].split(',');
-    dcpWorkerOptions[which] = { cpu: Number(cpu || defaultTargets[which].cpu),
-                                gpu: Number(gpu || defaultTargets[which].gpu) };
-    return true;
+      dcpWorkerOptions[which] = defaultTargets[which];
+    else
+    {
+      const [cpu, gpu] = cliArgs[which].split(',');
+      dcpWorkerOptions[which] = { cpu: Number(cpu || defaultTargets[which].cpu),
+                                  gpu: Number(gpu || defaultTargets[which].gpu) };
+    }
   };
 
   parseArg('density');
@@ -512,8 +507,8 @@ function processCoresAndDensity (dcpWorkerOptions, cliArgs)
 
   if (dcpWorkerOptions.cores)
     debugging() && console.debug('dcp-worker: cores =', dcpWorkerOptions.cores);
-  else
-    debugging() && console.debug('dcp-worker: core density =', dcpWorkerOptions.defaultCoreDensity);
+  if (dcpWorkerOptions.density)
+    debugging() && console.debug('dcp-worker: core density =', dcpWorkerOptions.density);
 }
 
 /**
@@ -637,14 +632,14 @@ function sliceReport()
 
   report += ('Progress:') + '\n';
   worker.workingSandboxes.forEach(sb => {
-    const jobName = sb.job && sb.job.public && sb.job.public.name || `idek (${sb.jobAddress})`;
+    const jobName = sb.job?.public?.name || `idek (${sb.jobAddress})`;
     let el = Date.now() - sb.sliceStartTime;
     const t = el < 1000000
           ? toInterval(el)
           : 'new';
 
     el = sb.progressReports && sb.progressReports.last
-      ? Date.now() - (sb.sliceStartTime + sb.progressReports.last.timestamp)
+      ? Date.now() - (sb.sliceStartTime + (sb.progressReports.last?.timestamp ?? 0))
       : 0;
     const pct = (typeof sb.progress) === 'number'
           ? `${Number(sb.progress).toFixed(0).padStart(2)}%`

package/etc/dcp-worker-config.js

@@ -49,7 +49,7 @@
       // keystore('~/.dcp/scott'),
     ],
 
-    jobAddresses: [],               /* If specified, restrict the worker to only these jobs */
+    jobAddresses: false,               /* If specified, restrict the worker to only these jobs */
     paymentAddress: undefined,      /* Bank account where earned funds are transfered if not specified on command-line */
   },
 

package/etc/dcp-worker-config.js.md5

@@ -1,2 +1,2 @@
-8edf1c57bee521ed7f151a21b8f3f34d
+4d49057dd014344e4be5a266e9754824
 ### DO NOT MODIFY THIS FILE!!! ###

package/lib/blessed-components/sandboxes.js

@@ -67,11 +67,7 @@ class Sandboxes extends Box {
   update(data=this.data) {
     this.data = data;
     for (let i = 0; i < this.data.length; i++) {
-      if (i < this.progressBars.length) {
-        this.updateProgressBar(i, this.data[i]);
-      } else {
-        this.createProgressBar();
-      }
+      this.updateProgressBar(i, this.data[i]);
     }
 
     if (this.data.length < this.progressBars.length) {
@@ -80,7 +76,15 @@ class Sandboxes extends Box {
       }
     }
 
-    this.setLabel(`${this.options.label} (${this.data.length})`);
+    this.setLabel(`${this.options.label} (${this.progressBars.length})`);
+  }
+
+  // Deletes last progress bar
+  deleteProgressBar() {
+    let i = this.progressBars.length - 1;
+    this.progressBars[i].label.destroy()
+    this.progressBars[i].progressBar.destroy()
+    this.progressBars.pop(i)
   }
 }
 

package/lib/dashboard-tui.js

@@ -15,6 +15,7 @@ const chalk      = require('chalk');
 const blessed    = require('blessed');
 const contrib    = require('blessed-contrib');
 const components = require('./blessed-components');
+const utils      = require('../lib/utils');
 
 const { replaceWorkerEvent, replaceSandboxEvent }  = require('./default-ui-events');
 
@@ -52,7 +53,7 @@ exports.init = function dashboard$$init(worker, options)
 
   const sandboxPane = grid.set(0, 0, 2, 2, components.sandboxes, {
     label: 'Sandboxes',
-    defaultProgressBars: Math.floor(worker.workerOptions.cores.cpu) || 1,
+    defaultProgressBars: 0,
     scrollable: true,
     alwaysScroll: true,
     mouse: true,
@@ -99,23 +100,27 @@ exports.init = function dashboard$$init(worker, options)
 
   /* Override default event behaviour to work better with the Dashboard. */
 
-  replaceSandboxEvent('start', function dashboard$$sliceStart(sandbox, sandboxData, ev) {
+  /** XXXpfr @todo Is this correct?  Or should we init progressData inside 'slice' like we used to.  */
+  replaceSandboxEvent('ready', function dashboard$$job(sandbox, sandboxData, ev) {
     sandboxData.progressData = {
       indeterminate: true,
       progress: 0,
-      label: sandbox.public.name,
+      label: sandbox?.public ? sandbox.public.name: '<no-label>',
     };
-
+  });
+  
+  replaceSandboxEvent('slice', function dashboard$$slice(sandbox, sandboxData, ev) {
     sandboxPane.data.push(sandboxData.progressData);
     sandboxPane.update();
   });
 
-  replaceSandboxEvent('sliceProgress', function dashboard$$sliceProgress(sandbox, sandboxData, ev) {
-    if (ev.indeterminate)
+  replaceSandboxEvent('progress', function dashboard$$progress(sandbox, sandboxData, ev) {
+    if (!ev)
     {
       sandboxData.progressData.progress = 100;
       setTimeout(() => {
-        if (sandboxData.progressData.indeterminate) {
+        if (sandboxData.progressData.indeterminate)
+        {
           sandboxData.progressData.progress = 0;
           sandboxPane.update();
         }
@@ -123,53 +128,54 @@ exports.init = function dashboard$$init(worker, options)
     }
     else
     {
-      sandboxData.progressData.progress = ev.progress;
+      sandboxData.progressData.progress = ev;
       sandboxData.progressData.indeterminate = false;
     }
 
     sandboxPane.update();
   });
   
-  replaceSandboxEvent('sliceFinish', function dashboard$$sliceFinish(sandbox, sandboxData, ev) {
+  replaceSandboxEvent('sliceEnd', function dashboard$$sliceEnd(sandbox, sandboxData, ev) {
     sandboxPane.data = sandboxPane.data.filter(d => d != sandboxData.progressData);
+    sandboxData.progressData.progress = 0;
     sandboxPane.update();
   });
 
-  worker.on('payment', updateWorkerInfo);
+  replaceSandboxEvent('end', function dashboard$$end(sandbox, sandboxData, ev) {
+    sandboxPane.data = sandboxPane.data.filter(d => d != sandboxData.progressData);
+    sandboxPane.deleteProgressBar();
+    sandboxData.progressData.progress = 0;
+    sandboxPane.update();
+  });
 
-  replaceWorkerEvent('fetchStart', function dashboard$$fetchStart(ev) {
+  replaceWorkerEvent('beforeFetch', function dashboard$$beforeFetch(ev) {
     sliceFetchStatus = SLICE_FETCH_STATUS.FETCHING;
     updateWorkerInfo();
   });
   
   replaceWorkerEvent('fetch', function dashboard$$fetch(ev) {
-    var slicesFetched;
-
+    sliceFetchStatus = SLICE_FETCH_STATUS.NO_WORK;
     if (ev instanceof Error)
-    {
       console.error('Error fetching 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;
-    }
-
-    if (slicesFetched === 0 && sandboxPane.data.length === 0) {
-      sliceFetchStatus = SLICE_FETCH_STATUS.NO_WORK;
-    } else {
+    else if ( !(utils.slicesFetched(ev) === 0 && sandboxPane.data.length === 0))
       sliceFetchStatus = SLICE_FETCH_STATUS.WORKING;
-    }
-
     updateWorkerInfo();
   });
 
-  replaceWorkerEvent('fetchError', function dashabord$$fetchError() {
-    sliceFetchStatus = SLICE_FETCH_STATUS.NO_WORK;
+  worker.on('end', () =>  { screen.destroy(); });
+
+  worker.on('sandbox', function dashboard$$sandbox(ev) {
+    sandboxPane.createProgressBar();
+    sandboxPane.update();
+  });
+
+  worker.on('payment', function dashboard$$payment(ev) {
+    const payment = parseFloat(ev);
+    
+    if (!isNaN(payment))
+      totalDCCs += payment;
+
+    sandboxPane.update();
     updateWorkerInfo();
   });
 };

package/lib/default-ui-events.js

@@ -26,6 +26,8 @@
  */
 'use strict';
 
+const utils = require('../lib/utils');
+
 const sandboxEventHandlers = {};
 const workerEventHandlers = {};
 
@@ -50,35 +52,28 @@ exports.hook = function hookWorkerEvents$$hook(worker, options)
     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}:`;
+    const address = sandbox.jobAddress.slice(0, truncationLength);
+    const baseInfo = sandbox?.public ? `${address}: ${sandbox.public.name}` : address;
 
     if (!sliceNumber)
-      sliceNumber = sandbox.slice ? sandbox.slice.sliceNumber : 0;
-    return sliceNumber ? `slice ${sliceNumber}, ${baseInfo}` : baseInfo;
+      sliceNumber = sandbox.sliceNumber;
+    return sliceNumber > 0 ? `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() };
+  sandboxEventHandlers.slice = function sliceHandler(sandbox, sandboxData, ev) {
+    sliceMap[sandbox.id] = { slice: sandbox.sliceNumber, t0: Date.now() };
     console.log(` . Sandbox ${sandboxData.shortId}:  Slice Started:   ${makeSliceId(sandbox)}`);
   };
 
-  sandboxEventHandlers.sliceProgress = function sliceProgressHandler(sandbox, sandbodData, ev) {
-    // NOP
+  sandboxEventHandlers.progress = function progressHandler(sandbox, sandboxdData, ev) {
+    // Overridden in dashboard-tui.js
   };
 
-  sandboxEventHandlers.sliceFinish = function sliceFinishHandler(sandbox, sandboxData, ev) {
+  sandboxEventHandlers.sliceEnd = function sliceEndHandler(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`);
@@ -86,8 +81,14 @@ exports.hook = function hookWorkerEvents$$hook(worker, options)
       console.log(` * Sandbox ${sandboxData.shortId}:  Slice Completed: ${makeSliceId(sandbox)}`);
   };
 
+  sandboxEventHandlers.end = function endHandler(sandbox,sandboxData, ev) {
+    const sliceInfo = sliceMap[sandbox.id];
+    console.log(` * Sandbox ${sandboxData.shortId}:  Terminated:      ${makeSliceId(sandbox, sliceInfo?.slice)}`);
+    delete sliceMap[sandbox.id];
+  };
+
   workerEventHandlers.payment = function paymentHandler(ev) {
-    const payment = parseFloat(ev.payment);
+    const payment = parseFloat(ev);
 
     if (isNaN(payment))
       console.error(' ! Failed to parse payment:', payment);
@@ -95,39 +96,23 @@ exports.hook = function hookWorkerEvents$$hook(worker, options)
       console.log(` . Payment: ${payment.toFixed(3)} ⊇`);
   };
 
-  workerEventHandlers.fetchStart = function fetchStartHandler() {
+  workerEventHandlers.beforeFetch = function beforeFetchHandler() {
     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');
+      options.verbose && console.log(' . Fetched', utils.slicesFetched(ev), 'slices');
   };
 
-  workerEventHandlers.fetchError = function fetchErrorHandler(ev) {
-    console.log(' ! Failed to fetch slices:', ev);
-  };
 
-  workerEventHandlers.submitStart = function submitStartHandler() {
+  workerEventHandlers.beforeResult = function beforeResultHandler() {
     options.verbose >= 2 && console.log(' * Submitting results...');
   };
 
-  workerEventHandlers.submit = function submitHandler() {
+  workerEventHandlers.result = function resultHandler() {
     options.verbose >= 2 && console.log(' . Submitted');
   };
 
@@ -144,14 +129,14 @@ exports.hook = function hookWorkerEvents$$hook(worker, options)
    * 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(eventName, (...args) => workerEventHandlers[eventName](...args));
 
   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));
+      sandbox.on(eventName, (...args) => sandboxEventHandlers[eventName](sandbox, sandboxData, ...args));
   });
   
   exports.sandboxEventHandlers = sandboxEventHandlers;

package/lib/startWorkerLogger.js

@@ -36,7 +36,10 @@ function getLogger(options)
   catch (error)
   {
     if (error.code === 'MODULE_NOT_FOUND')
-      throw new Error(`Unknown outputMode "${options.outputMode}"`);
+    {
+      const errorMessageStart = error.message.replace(/\n.*/g, '');
+      error.message = `Unknown outputMode "${options.outputMode} (${errorMessageStart})`;
+    }
     throw error;
   }
 }
@@ -123,5 +126,5 @@ function format(...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,
+  colors: process.stdout.isTTY && process.stdout.hasColors() || process.env.FORCE_COLOR,
 };

package/lib/utils.js

@@ -0,0 +1,28 @@
+
+/**
+ * @file        utils.js
+ *              Shared library code.
+ *
+ * @author      Paul, paul@distributive.network
+ * @date        August 2023
+ */
+'use strict';
+
+/**
+ * Figure out #slices fetched from the different forms of the 'fetch' event.
+ * @param {*|string|number} task
+ * @returns {number}
+ */
+function slicesFetched (task)
+{
+  if (typeof task === 'number') /* <= June 2023 Worker events: remove ~ Sep 2023 /wg */
+    return task;
+  if (typeof task === 'string') /* <= June 2023 Worker events: remove ~ Sep 2023 /wg */
+    return parseInt(task) || 0;
+  let slicesFetched = 0;
+  for (const job in task.slices)
+    slicesFetched += task.slices[job];
+  return slicesFetched;
+}
+
+exports.slicesFetched = slicesFetched;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "3.2.30-3",
+  "version": "3.2.30-4",
   "description": "JavaScript portion of DCP Workers for Node.js",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -48,6 +48,14 @@
     "@kingsds/eslint-config": "^1.0.1",
     "eslint": "7.30.0"
   },
+  "peerDependencies": {
+    "node-eventlog": "https://gitpkg.now.sh/Distributive-Network/node-eventlog/package?dcp/0.0.1"
+  },
+  "peerDependenciesMeta": {
+    "node-eventlog": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=16",
     "npm": ">=7"