dcp-worker 3.3.18 → 3.3.19

package/bin/dcp-task-probe

@@ -0,0 +1,696 @@
+#! /usr/bin/env node
+/**
+ * @file        dcp-task-probe
+ *              Tool to discover work available on the scheduler by requesting and
+ *              then returning slices.
+ *
+ * task request response payload currently (dec 2024) has
+ * - owner: scheduler's address
+ * - signature: ethereum signature object
+ * - auth:
+ *   - workerId: our worker id
+ *   - authSlices: job address props -> array of number
+ *   - schedulerId: { address: scheduler's address }
+ * - jobCommissions: job address props
+ *   - rate: number
+ *   - bank account
+ * - body:
+ *   - newJobs: job address props
+ *     - address: job address
+ *     - metrics:
+ *       - sliceCPUTime
+ *       - sliceGPUTime
+ *       - sliceCPUDensity
+ *       - sliceGPUDensity
+ *       - lastSliceNumber
+ *       - measuredSlices
+ *       - alpha
+ *       - running: true
+ *     - requirements: object
+ *     - public:
+ *       - computeGroups array
+ *       - name
+ *       - description
+ *       - link
+ *     - uuid
+ *     - codeLocation: uri
+ *     - argumentsLocation: array
+ *     - MROLocation: uri
+ *     - requirePath: array
+ *     - modulePath: array
+ *     - dependencies: array of module identifiers
+ *     - urlParameters:
+ *       - job: job address
+ *       - jobId: uuid
+ *     - workerConsole: 0
+ *     - worktime:
+ *       - name
+ *       - version
+ *   - task: job address props -> array
+ *     - jobAddress: address
+ *     - uuid: uuid
+ *     - worker: worker opaque id
+ *     - sliceNumber
+ *     - cotaskCount
+ *     - isEstimationSlice: boolean
+ *     - isLongSlice: boolean
+ *     - timestamp: ms
+ *     - resultStorageType: values|??
+ *     - resultStorageDetails
+ *     - resultStorageParams
+ *   - computeGroupJobs: opaqueId props
+ *     - array of jobId
+ * - computeGroups: opaque id -> array
+ * - computeGroupOrigins: {}
+ * - schedulerConfig:
+ *   - shared:
+ *     - frequencyMs
+ *     - debuggingFactor
+ *     - useLifetimeAnalysis
+ *     - lifetimeFactor
+ *     - slice
+ *       - maxCotasking
+ *       - multiplier
+ *       - sigmas
+ *       - factor
+ *       - biasMs
+ *   - targetTaskDuration: number in seconds
+ *
+ * @author      Wes Garland, wes@distributive.network
+ * @date        Dec 2024
+ */
+'use strict';
+
+const fs      = require('fs');
+const path    = require('path');
+const debug   = require('debug');
+const getopt  = require('posix-getopt');
+const util    = require('util');
+
+function usage()
+{
+  console.log(
+`
+DCP Task Probe - Copyright (c) 2024 Distributive Corp.
+Released under the terms of the MIT License.
+
+Usage: ${process.argv[0]} [option...]
+Examples (bash syntax):
+  - # dcp-task-probe --set cores.cpu=13 --set sandbox.progressTimeoutMs=2000
+  - # dcp-task-probe --merge allowOrigins.fetchData=https://google.com -c
+  - # bin/dcp-task-probe --set minimumWage.CPU=1 --set minimumWage.GPU=3 -c
+  - # dcp-task-probe --merge "minimumWage=({CPU:1, GPU:3})" -c
+  - # dcp-task-probe --merge 'minimumWage={"CPU":1,"GPU":3}' -c
+Options:
+  -h | --help                    show this help and exit
+  -C | --dumpConfig              dump worker configuration instead of requesting a task
+  -v | --version                 increase verbosity (show job info)
+  -H | --hostname=               set evaluator hostname (for capability probing)
+  -p | --port=                   set evaluator port number (for capability probing)
+  -S | --set property.name=      sets a node in dcpConfig.worker to the given value
+  -M | --merge property.name=    merge a given value to with a node in dcpConfig.worker
+  -a | --allowedOrigins=         add url to dcpConfig.worker.allowedOrigins.any
+  -c | --cores=                  set the number of cpu,gpu cores
+  -u | --utilization=            set the cpu,gpu utilization target
+  -m | --maxSandboxes=           Maximum number of sandboxes
+  -g | --joinComputeGroup=       joinKey,joinSecret or joinKey,joinHash of compute group to join
+  -j | --jobId=                  id of job to work
+  -r | --replay                  replay request from worker's last requestSnapshot
+  -l | --load                    load config from worker's last requestSnapshot
+  -i | --input=                  render the input file instead of requesting a new task
+  -o | --output=                 save the task to disk
+Syntax:
+  The --merge and --set options have a variety of parsing options, to allow values in
+  dcpConfig.worker to have the correct types. The parsing method is controlled by the
+  first character of the value:
+    @ - the value is a filename; the file is read in and its contents are used in place
+        of the value specified on the command-line
+    ( - the value is parsed as a JavaScript expression
+    { - the value is parsed as a JSON object
+    # - the rest of the value is parsed as JSON
+    [ - the value is parsed as a JSON array
+    \` - the value is parsed as a JavaScript template string
+    ' - the value is parsed as a string
+    " - the value is parsed as a string
+    other - the value is parsed as a string, unless it can be parsed as a number
+Note:
+  Beyond the usual dcpConfig.worker values, this program adds dcpConfig.worker.capabilities and
+  dcpConfig.worker.worktimes. If they are not present in the loaded config, they are automtically
+  populated by querying the local evaluator. If they are both specified in the config, then it
+  is not necessary to have a working evaluator to run this program.
+Environment:
+  DEBUG      - enables debugging, eg DEBUG='dcp-task-probe*,-dcp-task-probe:evaluator'
+  DCP_CONFIG - sets location of dcp-worker-config file
+`);
+
+  process.exit(0);
+}
+
+function panic()
+{
+  console.error.apply(console, arguments);
+  process.exit(1);
+}
+
+function detailedView(object)
+{
+  return util.inspect(object, { depth: null, colors: process.env.FORCE_COLOR || true });
+}
+
+/**
+ * Determine if an string is a hash; used to differentiate between compute group join keys and hashes.
+ */
+function isHash(b)
+{
+  return b && b.length === 68 && b.startsWith('eh1-');
+}
+
+/**
+ * Evaluate a JavaScript expression within a given namespace. This function creates an IIFE and injects
+ * the properties of the namespace object into the IIFE's function block scope.
+ *
+ * @param {string}   expression    the JS expression to evaluatte
+ * @param {object}   namespace     the namespace object; each property becomes a symbol that can be used
+ *                                 by the expression
+ */
+function nsEval(expression, namespace)
+{
+  const indirectEval = eval; // eslint-disable-line no-eval
+  const symbolNames = Object.keys(namespace);
+  const symbolValues = Object.values(namespace);
+  return indirectEval(`(${symbolNames}) => ${expression}`)(symbolValues);
+}
+
+/**
+ * Parse a value within a given namespace. See the usage function for the syntax supported by this
+ * function. If the value is not a string, it is not parsed and simply returned.
+ *
+ * @param   {any}     value      the value to parse
+ * @param   {object}  namespace  a namespacing object used when evaluating JS expresssions; see nsEval
+ * @returns {any}  value or a JS value derived by parsing value
+ */
+function parseValue(value, namespace)
+{
+  if (typeof value !== 'string')
+    return;
+
+  if (value[0] === '@')
+    value = fs.readFileSync(value[0], 'utf-8');
+  switch(value[0])
+  {
+    case '#':
+      value = JSON.parse(value.slice(1));
+      break;
+    case '[':
+    case '{':
+      value = JSON.parse(value);
+      break;
+    case '`': /* fallthrough */
+    case '(':
+      value = nsEval(value, namespace);
+      break;
+    case "'":
+      if (/^'([^']*)'/.test(value))
+        value = value.match(/^'([^.]*)'/)[1];
+      break;
+    case '"':
+      if (/^"([^"]*)"/.test(value))
+        value = value.match(/^"([^"]*)"/)[1];
+      break;
+    default:
+      if (!isNaN(Number(value)))
+        value = Number(value);
+    break;
+  }
+  return value;
+}
+
+/**
+ * Traverse a graph by walking a dot path (eg a.b.c); ie. the path names each edge of the graph of the
+ * graph to traverse. The value returned is the node which is the parent of the final edge in the path,
+ * and the final edge the path. This is so that the calling code can replace the edge and is effectively
+ * a pointer to the node described by the dot path.
+ *
+ * @example:
+ *  walkDotPath(dcpConfig.worker, 'minimumWage.CPU')
+ *  returns [ dcpConfig.worker.minimumWage, 'CPU' ]
+ *
+ * @param {object}   startNode   the name of the first node in the graph
+ * @param {string}   dotPath     the names of the edges to traverse, separated by dots
+ * @return { Array } whose first element is the node containing parent node of the final edge and
+ *                   whose second element is the name of the final edge
+ */
+function walkDotPath(startNode, dotPath)
+{
+  var node = startNode;
+  var seen = [ 'worker' ];
+
+  dotPath = dotPath.split('.');
+  while(dotPath.length > 1)
+  {
+    const prop = dotPath.shift();
+    if (!node[prop])
+      panic(`invalid property ${prop} in dcpConfig.${seen.join('.')}`)
+    node = node[prop];
+    seen.push(prop);
+  }
+
+  return [ node, dotPath[0] ];
+}
+
+/** Parse a string of the form a,b into { cpu: a, gpu: b } */
+function cpuCommaGpu(str)
+{
+  const [cpu,gpu] = str.split(/[ ,]/);
+  const obj = {};
+  if (typeof cpu !== 'undefined' && cpu !== '')
+    obj.cpu = Number(cpu);
+  if (typeof gpu !== 'undefined')
+    obj.gpu = Number(gpu);
+  return obj;
+}
+
+/**
+ * Parse and process command-line options. Most options result in changes to the running dcpConfig;
+ * other options are reflected in the returned object:
+ *  - dumpConfig
+ *  - workerId
+ */
+async function processOptions()
+{
+  const opts = { verbose: 0 };
+  const parser = new getopt.BasicParser('h(help)C(dumpConfig)S:(set)M:(merge)a:(allowedOrigins)'
+                                        + 'c:(cores)u:(utilization)m:(maxSandboxes)w:(workerId)'
+                                        + 'J:(jobAddress)j:(job)g:(computeGroup)G(leaveGlobalGroup)'
+                                        + 'H:(hostname)p:(port)r(replay)l(load)i(input)o(output)'
+                                        + 'v(verbose)',
+                                        process.argv);
+  var opthnd;
+
+  while ((opthnd = parser.getopt()) !== undefined)
+  {
+    switch (opthnd.option)
+    {
+      case 'h':
+        usage();
+        break;
+
+      default:
+        throw new Error(`defined but unspecified option: -${opthnd.option}` + (opthnd.optarg ? `=${opthnd.optarg}` : ''));
+
+      case '?':
+        process.exit(1);
+        break;
+
+      case 'C':
+        opts.dumpConfig = true;
+        break;
+
+      case 'v':
+        opts.verbose += 1;
+        break;
+
+      case 'w':
+        opts.workerId = opthnd.optarg;
+        break;
+
+      case 'r':
+        opts.replay = true;
+        break;
+
+      case 'a':
+        dcpConfig.worker.allowedOrigins.any.push(opthnd.optarg);
+        break;
+
+      case 'c':
+        Object.assign(dcpConfig.worker.cores, cpuCommaGpu(opthnd.optarg));
+        break;
+
+      case 'u':
+        Object.assign(dcpConfig.worker.utilization, cpuCommaGpu(opthnd.optarg));
+        break;
+
+      case 'm':
+        dcpConfig.worker.maxSandboxes = Number(opthnd.optarg);
+        break;
+
+      case 'J':
+        dcpConfig.worker.jobAddresses = (dcpConfig.worker.jobAddresses || []).concat(opthnd.optarg);
+        break;
+
+      case 'j': /** @todo integrate with upcoming scheduler changes to opaqueId /wg dec 2024 */
+        dcpConfig.worker.jobs = (dcpConfig.worker.jobs || []).concat(opthnd.optarg);
+        break;
+
+      case 'G':
+        dcpConfig.worker.leavePublicGroup = true;
+        break;
+
+      case 'H':
+        dcpConfig.evaluator.location.hostname = opthnd.ortarg;
+        break;
+
+      case 'p':
+        dcpConfig.evaluator.location.port = opthnd.ortarg;
+        break;
+
+      case 'g':
+      {
+        const [ joinKey, joinSecret ] = opthnd.optarg.split(',');
+        const joinHash = joinSecret;
+
+        if (isHash(joinHash))
+          dcpConfig.worker.computeGroups.push({ joinKey, joinHash });
+        else
+          dcpConfig.worker.computeGroups.push({ joinKey, joinSecret });
+        break;
+      }
+
+      case 'M': /* fallthrough */
+      case 'S':
+      {
+        const eqIdx = opthnd.optarg.indexOf('=');
+        const idx = eqIdx !== -1 ? eqIdx : opthnd.optarg.length;
+        const value = parseValue(opthnd.optarg.slice(idx + 1), dcpConfig.worker);
+        const [ confNode, prop ] = walkDotPath(dcpConfig.worker, opthnd.optarg.slice(0, idx));
+
+        if (opthnd.option === 's')
+          confNode[prop] = value;
+        else
+        {
+          /* merge mode: objects are merged at the property level, except for arrays, which are concatenated */
+          if (confNode === dcpConfig.worker && (prop === 'worktimes' || prop === 'capabilities'))
+            await probeEvaluator(); /* ensure we have something to merge into */
+          switch(typeof confNode[prop])
+          {
+            case 'object':
+            {
+              if (!Array.isArray(confNode[prop]))
+                Object.assign(confNode[prop], value);
+              else
+              {
+                if (Array.isArray(value))
+                  Array.push.apply(confNode, value);
+                else
+                  confNode[prop].push(value);
+              }
+              break;
+            }
+            default:
+              confNode[prop] = value;
+              break;
+          }
+        }
+        break;
+      }
+
+      case 'l':
+      {
+        const wallet = require('dcp/wallet');
+        const snapshot = readWorkerSnapshot();
+        dcpConfig.worker = snapshot.workerConfig;
+        dcpConfig.worker.paymentAddress = new wallet.Address(dcpConfig.worker.paymentAddress);
+      }
+    }
+  }
+
+  return opts;
+}
+
+/**
+ * Probe the evaluator to determine its capabilities and supported worktimes. This function is delayed
+ * as late as possible during the configuration phase so that the user has the option to specify these
+ * completely on a system with no evaluator.
+ */
+async function probeEvaluator()
+{
+  if (probeEvaluator.probed)
+    return;
+  probeEvaluator.probed = true;
+  const probeTimer = setTimeout(() => panic('unable to probe evaluator'), 66610e3); /* Need to keep main from exiting */
+
+  if (!dcpConfig.worker.capabilities || !dcpConfig.worker.worktimes)
+  {
+    const { workerFactory } = require('dcp-client/lib/standaloneWorker');
+    debug('dcp-task-probe:evaluator')('Probing evaluator at', dcpConfig.evaluator.location);
+    const evaluatorInfo = await require('dcp/worker').probeEvaluator(workerFactory(dcpConfig.evaluator.location));
+    dcpConfig.worker.capabilities ||= evaluatorInfo.capabilities;
+    dcpConfig.worker.worktimes    ||= evaluatorInfo.worktimes;
+  }
+
+  clearTimeout(probeTimer);
+}
+
+/**
+ * Returns the most recent snapshot left behind by the worker. The location of the snapshot is given by
+ * dcpConfig.worker.requestSnapshot. Multiple calls to this function always return the same snapshot.
+ * This function understands that the worker might write kvin-encoded snapshots, identitfied by their
+ * extension. The snapshots are written automatically by the worker during task request when the
+ * dcpConfig.worker.requestSnapshot is set.
+ */
+function readWorkerSnapshot()
+{
+  if (!dcpConfig.worker.requestSnapshot)
+    panic('no snapshot specified in dcpConfig.worker.requestSnapshot');
+
+  if (!readWorkerSnapshot.cache)
+  {
+    const serializer = dcpConfig.worker.requestSnapshot.endsWith('kvin') ? require('kvin').KVIN : JSON;
+    debug('dcp-task-probe')('loading snapshot', detailedView(dcpConfig.worker.requestSnapshot));
+    readWorkerSnapshot.cache = serializer.parse(fs.readFileSync(dcpConfig.worker.requestSnapshot));
+  }
+  return readWorkerSnapshot.cache;
+}
+
+/**
+ * Generate non-global compute group secrets, hashed with the current task distributor connection's
+ * dcpsid. Add in the public group if necessary.
+ *
+ * @todo unify with supervisor /wg dec2024
+ */
+function makeComputeGroupsRequest(tdConn, dummyWorker)
+{
+  const computeGroups = structuredClone(dcpConfig.worker.computeGroups); /* supervisor code sadly mutates this /wg dec 2024 */
+  const options = Object.assign({}, dcpConfig.worker, { computeGroups });
+  const taskDistributor = { connection: tdConn };
+
+  dummyWorker.badSupervisorBackdoor.dcp4.generateWorkerComputeGroups.apply({ taskDistributor, options });
+  if (!dcpConfig.worker.leavePublicGroup && !dcpConfig.worker.leaveGlobalGroup)
+    options.computeGroups.unshift({ joinKey: 'public' });
+  return options.computeGroups;
+}
+
+
+/**
+ * Request a task from the task distributor
+ *
+ * @todo unify with supervisor /wg dec 2024
+ * @param {Keystore} identity   identity of the requesting entity
+ * @param {Object}   opts       command-line options to dcp-task-probe
+ *                    .replay     truey to use request from worker snapshot instead of a generated request
+ *                    .workerId   workerId for request
+ */
+async function requestTask(identity, opts)
+{
+  const protocol = require('dcp/protocol');
+  const worker = require('dcp/worker');
+  const tdConn = new protocol.Connection(dcpConfig.scheduler.services.taskDistributor);
+  const dummyWorker = new worker.Worker(identity, dcpConfig.worker); /* side effect: initializes dcpConfig.worker */
+  var request;
+
+  if (opts.replay)
+    request = readWorkerSnapshot().request;
+  else
+    request = {
+      supervisor: dummyWorker.supervisorVersion,
+      targetLoad: {
+        cpu: Math.min(dcpConfig.worker.maxSandboxes, dcpConfig.worker.cores.cpu * dcpConfig.worker.utilization.cpu) /* cpuCoreSpace */,
+        gpu: Math.min(dcpConfig.worker.maxSandboxes, dcpConfig.worker.cores.gpu * dcpConfig.worker.utilization.gpu) /* this.maxWorkingGPUs */,
+        longSlices: dcpConfig.worker.maxSandboxes /* Math.floor(cpuCoreSpace) */,
+      },
+      coreStats: { /** @todo why are we specifying these? /wg dec 2024 */
+        worker: dummyWorker.workerId,
+        lCores: require('os').cpus().length,
+        pCores: require('physical-cpu-count'),
+        sandbox: dcpConfig.worker.maxSandboxes,
+      },
+      jobQuanta:            [ 1 ]/* this.quanta.calculateJobQuanta() */,
+      capabilities:         dcpConfig.worker.capabilities,
+      paymentAddress:       dcpConfig.worker.paymentAddress,
+      jobAddresses:         dcpConfig.worker.jobAddresses || [],
+      workerComputeGroups:  makeComputeGroupsRequest(tdConn, dummyWorker),
+      minimumWage:          dcpConfig.worker.minimumWage,
+      soteriaJobs:          [],
+      overdueSlices:        [],
+      previouslyWorkedJobs: [], /* discrete jobs */
+      rejectedJobs:         [],
+      unresolvedJobs:       [],
+      fetchState:           1, /* normal fetch */
+      worktimes:            dcpConfig.worker.worktimes,
+    };
+
+  debug('dcp-task-probe:connect')('Connecting to task distributor at', tdConn.targetDescriptor.location.href);
+  await tdConn.keepalive();
+  debug('dcp-task-probe:request')('Task Request:', request);
+
+  const rtStart = Date.now();
+  const response = await tdConn.request('requestTask', request);
+  const rtElapsed = Date.now() - rtStart;
+  console.log('Task Request Time:   ', fmtMs(rtElapsed));
+
+  debug('dcp-task-probe:request')('Task Response:', detailedView(response));
+  if (!response.success)
+    panic('request failed:', response.payload);
+
+  return { response, workerId: request.coreStats?.worker };
+}
+
+async function returnTask(taskResponsePayload)
+{
+  const protocol = require('dcp/protocol');
+  const { body,  ...authorizationMessage } = taskResponsePayload;
+  const { auth } = taskResponsePayload;
+  const returnRequest = {
+    worker: auth.workerId,
+    slices: [],
+  };
+
+  for (const job in auth.authSlices)
+  {
+    for (const sliceNumber of auth.authSlices[job])
+    {
+      const slices = body.task[job];
+      returnRequest.slices.push({
+        sliceNumber,
+        job,
+        authorizationMessage,
+        isEstimationSlice: slices.filter(slice => slice.sliceNumber === sliceNumber)[0].isEstimationSlice,
+        status: 'return',
+        reason: 'task-probe',
+      });
+    }
+  }
+
+  debug('dcp-task-probe:request')('Return Request:', detailedView(returnRequest));
+  const rsConn = new protocol.Connection(dcpConfig.scheduler.services.resultSubmitter);
+  const response = await rsConn.request('status', returnRequest);
+
+  if (!response.success)
+    panic('request failed:', response.payload);
+
+  debug('dcp-task-probe:response')('Return Response:', detailedView(response));
+  if (!response.payload?.length)
+    panic('did not return task');
+}
+
+function unique(e, i, self)
+{
+  return i === self. indexOf(e);
+}
+
+function fmtMs(ms)
+{
+  return (ms / 1e3).toFixed(3) + 's';
+}
+
+/** Main program entry point */
+async function main()
+{
+  const wallet   = require('dcp/wallet');
+  const identity = await wallet.getId();
+  const opts = await processOptions();
+
+  if (!dcpConfig.worker.paymentAddress)
+    dcpConfig.worker.paymentAddress = (await wallet.get()).address;
+
+  if (!opts.replay)
+    await probeEvaluator();
+
+  if (opts.dumpConfig)
+  {
+    /* work around the cores getter/setter that is added by the worker */
+    const dump = Object.assign({}, dcpConfig.worker);
+    dump.cores = { cpu: dcpConfig.worker.cores.cpu, gpu: dcpConfig.worker.cores.gpu };
+    console.log(dump);
+    process.exit(0);
+  }
+
+  const { workerId, response } = await requestTask(identity, opts);
+  const task = response.payload?.body?.task;
+  if (task)
+    await returnTask(response.payload);
+
+  console.log('Task Distributor:    ', dcpConfig.scheduler.services.taskDistributor.location.href);
+  console.log('Result Submitter:    ', dcpConfig.scheduler.services.resultSubmitter.location.href);
+  console.log('Worker Id:           ', workerId);
+  console.log('DCP Address:         ', String(identity.address));
+
+  if (!task)
+  {
+    console.error('no work');
+    process.exit(22);
+  }
+
+  const { newJobs, computeGroupJobs, computeGroupOrigins, schedulerConfig } = response.payload.body;
+  const cgs = {}
+  for (const cgId in computeGroupJobs)
+    cgs[cgId] = { jobCount: computeGroupJobs[cgId].length };
+  for (const jobId in newJobs)
+  {
+    for (const cg of newJobs[jobId].public.computeGroups)
+      Object.assign(cgs[cg.opaqueId], { name: cg.name, description: cg.description });
+  }
+
+  console.log('Total Jobs:          ', Object.keys(task).length);
+  console.log('Total Slices:        ', Object.keys(task).map(jobId => task[jobId].length).reduce((a, b) => a+b, 0));
+  console.log('Total CPU,GPU Time:  ',
+              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceCPUTime).reduce((a, b) => a+b, 0)) + ',',
+              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceGPUTime).reduce((a, b) => a+b, 0)));
+  console.log('CPU,GPU Time/core:   ',
+              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceCPUTime).reduce((a, b) => a+b, 0) / dcpConfig.worker.cores.cpu) + ',',
+              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceGPUTime).reduce((a, b) => a+b, 0) / dcpConfig.worker.cores.gpu));
+  console.log('Task Duration:       ', schedulerConfig.targetTaskDuration + 's');
+  console.log('Compute Groups:      ', Object.keys(computeGroupJobs).length);
+
+  if (opts.verbose)
+  {
+    for (const cgId in cgs)
+    {
+      console.log(' -', cgId, cgs[cgId].name);
+      if (computeGroupOrigins[cgId])
+        console.log('   allow origins:', computeGroupOrigins[cgId]);
+    }
+  }
+
+  if (opts.verbose)
+  {
+    for (const jobId of Object.keys(task))
+    {
+      console.log(`\n-- Job ${jobId} ------------------------------`);
+      console.log('Public Info:       ', newJobs[jobId].public.name, newJobs[jobId].public.description, newJobs[jobId].public.link || '');
+      console.log('Compute Groups:    ', newJobs[jobId].public.computeGroups.map(cg=>cg.opaqueId).filter(unique));
+      console.log('Slices:            ', Object.keys(task[jobId]).length);
+      console.log('Avg Slice Time:    ',
+                  `cpu=${fmtMs(newJobs[jobId].metrics.sliceCPUTime)}`,
+                  `gpu=${fmtMs(newJobs[jobId].metrics.sliceGPUTime)}`);
+      console.log('Avg Slice Density: ',
+                  `cpu=${(newJobs[jobId].metrics.sliceCPUDensity * 100).toFixed(1)}%`,
+                  `gpu=${(newJobs[jobId].metrics.sliceGPUDensity * 100).toFixed(1)}%`);
+      console.log('Worktime:          ', `${newJobs[jobId].worktime.name}@${newJobs[jobId].worktime.version}`);
+      if (newJobs[jobId].codeLocation.startsWith('data:'))
+        console.log('Work Function:     ', newJobs[jobId].codeLocation.length, 'bytes, inline');
+      else
+        console.log('Work Function:     ', newJobs[jobId].codeLocation);
+
+      console.log('Result Storage:    ', task[jobId][0].resultStorageType, task[jobId][0].resultStorageDetails);
+      console.log('Dependencies:      ', newJobs[jobId].dependencies.map(a => path.basename(a)).join(' '));
+    }
+  }
+}
+
+/* Initialize dcp-client to use only local resources before launching the main function */
+require('dcp-client').init({
+  progName: 'dcp-worker',
+  parseArgv: false,
+  configName: process.env.DCP_CONFIG || '../etc/dcp-worker-config', /* => .js or .json */
+}).then(main);

package/bin/dcp-worker

@@ -130,14 +130,7 @@ function parseCliArgs()
         alias: 'p',
         describe: 'Evaluator port',
         type: 'number',
-        default: Number(dcpConfig.evaluator.listen.port),
-      },
-      priorityOnly: {
-        alias: 'P',
-        hidden: true,
-        describe: 'Set the priority mode [deprecated]',
-        type: 'boolean',
-        default: false
+        default: Number(dcpConfig.evaluator.location.port),
       },
       'job-id': {
         alias: 'j',
@@ -403,7 +396,6 @@ z   */
     if (dcpWorkerOptions.jobAddresses === false || dcpWorkerOptions.jobAddresses === undefined)
       dcpWorkerOptions.jobAddresses = [];
     dcpWorkerOptions.jobAddresses.push(...cliArgs.jobId);
-    dcpWorkerOptions.priorityOnly = true;
   }
 
   if (cliArgs.allowedOrigins)
@@ -462,10 +454,12 @@ z   */
     else
     {
       const errorCode = error.code ?? error.errorCode;
+      const location = error.stack.split('\n')[1].replace(/^\s*/,'');
+      let message = error.message;
+
       if (errorCode)
-        console.error(`Error: ${error.message}: error.code ${errorCode}`);
-      else
-        console.error(`Error: ${error.message}`);
+        message += ` (${error.code})`;
+      console.error(`Error: ${error.message} ${location}`);
     }
   });
   require('../lib/default-ui-events').hook(nascentWorker, cliArgs);
@@ -533,29 +527,26 @@ z   */
   if (telnetd.hasOwnProperty('port'))
     bannerLog(` ! telnetd listening on port ${telnetd.port}`);
 
-  const { worktimes } = require('dcp-client/libexec/sandbox/worktimes');
-  if (Object.keys(worktimes).length > 0)
-  {
-    bannerLog(' . Worktimes Available:');
-    for (const wt of worktimes)
-      bannerLog(`    -\t${wt.name}@${wt.versions.join(';')}`);
-  }
-
-  let webgpuInfo;
+  let workerInfo;
   console.throb('log', ' ! Waiting for dcp-evaluator to start...');
-  for (let i=0; !webgpuInfo; i++)
+  for (let i=0; !workerInfo; i++)
   {
-    webgpuInfo = await require('../lib/webgpu-info').checkWebGPU(sawOptions);
-    if (webgpuInfo)
+    workerInfo = await require('../lib/worker-info').getEvaluatorInformation(sawOptions);
+    if (workerInfo)
       break;
     console.throb();
     await a$sleep(Math.max(i + 1, 10) / 4);
     console.throb();
   }
 
-  if (!webgpuInfo)
-    bannerLog(' . WebGPU detection failed');
-  else if (!webgpuInfo.enabled)
+  if (Object.keys(workerInfo.worktimes).length > 0)
+  {
+    bannerLog(' . Worktimes Available:');
+    for (const wt of workerInfo.worktimes)
+      bannerLog(`    -\t${wt.name}@${wt.versions.join(';')}`);
+  }
+
+  if (!workerInfo.webgpu.enabled)
   {
     bannerLog(' . WebGPU not enabled');
     systemStateInfo.gpu = false;
@@ -563,13 +554,13 @@ z   */
   else
   {
     bannerLog(' . WebGPU available. GPU info:');
-    for (let descriptor in webgpuInfo.info)
-      bannerLog(`    -\t${descriptor}: ${webgpuInfo.info[descriptor]}`);
-    systemStateInfo.gpu = Object.assign({}, webgpuInfo.info);
+    for (let descriptor in workerInfo.webgpu.info)
+      bannerLog(`    -\t${descriptor}: ${workerInfo.webgpu.info[descriptor]}`);
+    systemStateInfo.gpu = Object.assign({}, workerInfo.webgpu.info);
     systemStateInfo.gpu.device
     for (let descriptor in bannedGPUs)
     {
-      if (bannedGPUs[descriptor].test(webgpuInfo.info[descriptor]))
+      if (bannedGPUs[descriptor].test(workerInfo.webgpu.info[descriptor]))
       {
         console.error(' * This GPU is not supported; disabling');
         dcpWorkerOptions.cores = { cpu: dcpWorkerOptions.cores.cpu, gpu: 0 };
@@ -834,6 +825,7 @@ function handleSigDeath(signalName, signal)
   if (handleSigDeath.count === 3)
     die();
 }
+globalThis.die = () => handleSigDeath('QUIT', 15);
 
 /**
  * Returns the duration of the cleanup timeout in milliseconds. It is possible to specify zero.

package/lib/dashboard-tui.js

@@ -44,11 +44,12 @@ exports.init = function dashboard$$init(worker, options, bannerLogCumulative)
   var screen = blessed.screen(screenConf);
 
   worker.on('end', () =>  {
-    screen.destroy();
-    screen = false;
+    if (screen?.destroy)
+      screen.destroy();
+    screen.destroy = false;
   });
   process.on('exit', () => {
-    if (screen)
+    if (screen?.destroy)
       screen.destroy();
   });
 

package/lib/{webgpu-info.js → worker-info.js}

@@ -1,7 +1,9 @@
 /**
- *  @file       webgpu-capabilities.js
- *              Check evaluator to determine if webgpu is enabled, and what capabilities it has.
- *
+ *  @file       worker-reporting.js
+ *              Check evaluator to determine if certain information including:
+ *                - if webgpu is enabled, and what capabilities it has.
+ *                - supported worktimes for the evaluator
+ * 
  *  @author     Ryan Saweczko, ryansaweczko@distributive.network
  *
  *  @date       Sept 2024
@@ -9,19 +11,20 @@
 'use strict';
 
 const kvin = require('kvin');
-const evaluatorId = 'webgpuCheck';
+const evaluatorId = 'reportingCheck';
 
-async function eval$$webgpu()
+async function eval$$getInfo()
 {
+  const info = {};
   if (typeof initWebGPU === 'function')
     await initWebGPU();
 
   if (!(typeof globalThis.navigator?.gpu === 'object'))
-    return { enabled: false };
+    info.webgpu = { enabled: false };
 
   try
   {
-    const info = {};
+    const webgpuInfo = {};
     const adapter = await navigator.gpu.requestAdapter();
     /*
      * Newer versions of dcp-evaluator use different methods to access the adapter info as the api changes/bugs are fixed.
@@ -35,29 +38,34 @@ async function eval$$webgpu()
     if (adapter.info)
     {
       for (let key in adapter.info)
-        info[key] = adapter.info[key];
-      return { enabled: true, info: info };
+        webgpuInfo[key] = adapter.info[key];
+      info.webgpu = { enabled: true, info: webgpuInfo };
+    }
+    else
+    {
+      const properties = ['vendor', 'architecture', 'device', 'description'];
+      const adapterInfo = await adapter.requestAdapterInfo();
+      for (let key of properties)
+        webgpuInfo[key] = adapterInfo[key];
+      info.webgpu = { enabled: true, info: webgpuInfo };  
     }
-    const properties = ['vendor', 'architecture', 'device', 'description'];
-    const adapterInfo = await adapter.requestAdapterInfo();
-    for (let key of properties)
-      info[key] = adapterInfo[key];
-    return { enabled: true, info: info };
   }
   catch (err)
   {
-    return { enabled: false };
+    info.webgpu = { enabled: false };
   }
+
+  info.worktimes = globalThis.worktimes;
+
+  return info;
 }
 
 /**
- * Connect to an evaluator instance and return back if webGPU is enabled, and if it is some information on the 
- * GPU device.
+ * Connect to an evaluator instance and return back information on the evaluator
  * @param {object} evaluatorConfig - Object containing the hostname and port to connect to the evaluator instance on
- * @returns {Promise} which resolves with undefined detection failed (ie couldn't connect to evaluator), 
- *                    or the object {enabled, info} with info on if webgpu exists, and if so what the gpu is.
+ * @returns {Promise} which resolves with undefined detection failed (ie couldn't connect to evaluator), or the information object
  */
-function checkEvaluatorWebGPU(evaluatorConfig)
+function getEvaluatorInformation(evaluatorConfig)
 {
   const StandaloneWorker = require('dcp-client/lib/standaloneWorker').workerFactory(evaluatorConfig);
   const { a$sleep } = require('dcp/utils');
@@ -65,7 +73,7 @@ function checkEvaluatorWebGPU(evaluatorConfig)
   const evaluatorHandle = new StandaloneWorker({ name: 'DCP Sandbox #1', });
 
   var noResponse, resolve;
-  const p$webgpuInfo = new Promise((res, rej) => { resolve = res; }).finally(() => {
+  const p$workerInfo = new Promise((res, rej) => { resolve = res; }).finally(() => {
     evaluatorHandle.terminate();
     noResponse.intr();
   });
@@ -84,11 +92,11 @@ function checkEvaluatorWebGPU(evaluatorConfig)
 
   const message = {
     request: 'eval',
-    data: '(' + eval$$webgpu.toString() + ')()',
+    data: '(' + eval$$getInfo.toString() + ')()',
     msgId: evaluatorId,
   }
   evaluatorHandle.postMessage(kvin.marshal(message));
-  return p$webgpuInfo;
+  return p$workerInfo;
 }
 
-exports.checkWebGPU = checkEvaluatorWebGPU;
+exports.getEvaluatorInformation = getEvaluatorInformation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "3.3.18",
+  "version": "3.3.19",
   "description": "Node.js Worker for Distributive Compute Platform",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -40,7 +40,7 @@
     "blessed": "^0.1.81",
     "blessed-contrib": "4.11.0",
     "chalk": "^4.1.0",
-    "dcp-client": "^4.4.23",
+    "dcp-client": "^4.4.24",
     "kvin": "^1.2.7",
     "posix-getopt": "^1.2.1",
     "semver": "^7.3.8",