dcp-worker 4.1.0 → 4.2.0

package/lib/{remote-console.js → telnetd.js}

@@ -1,5 +1,5 @@
 /**
- * @file        remote-console.js
+ * @file        telnetd.js
  *              DCP Service Worker support for a remote console, accessible via telnet.
  *
  *              * SECURITY NOTICE *
@@ -23,9 +23,10 @@
  */
 'use strict';
 
-const path = require('path');
-const fs   = require('fs');
-const { debugging } = require('./utils');
+const path  = require('path');
+const fs    = require('fs');
+const debug = require('debug');
+
 var dcpConfig;
 var mainEval;
 var ci;
@@ -46,10 +47,29 @@ function daemonEval()
   return eval(arguments[0]);  /* eslint-disable-line no-eval */
 }
 
-function callbackTelnet(port, client, registry)
+function callbackTelnet()
 {
-  client.unref();
-  debugging() && console.notice(' ! telnetd - listening on port', port);
+  /* The telnet daemon is purposefully started as early and synchronously as possible, so that it is
+   * ready to capture errors in and/or help troubleshoot the most basic tasks, like setting up the
+   * console, log multiplexing, or command-line option parsing.
+   *
+   * In this callback, we purposefully push the telnetd startup status reporting so that it is more
+   * likely that the multiplexed loggers and/or the dashboard will be ready for the diagnostic
+   * messages.
+   */
+  if (arguments.length === 1)
+  {
+    const [ error ] = arguments;
+    setTimeout(() => console.error(` ! telnetd - startup error ${error.code || error.message}`), 250);
+    debug('dcp-worker:telnet')('telnet listen error:', error);
+  }
+  else
+  {
+    const [ port, server, _registry ] = arguments; // eslint-disable-line no-unused-vars
+    setTimeout(() => console.warn(' ! telnetd listening on port', port), 250);
+    debug('dcp-worker:telnet')('telnetd listening on', server.address().family, server.address().address, server.address().port);
+    server.unref();
+  }
 }
 
 /**
@@ -64,7 +84,7 @@ exports.setMainEval = function removeConsole$$setMainEval()
 /**
  *  Initialize the remote console
  *
- *  @param  {...object} commands Command definitions. See telnet-console documentation 
+ *  @param  {...object} commands Command definitions. See telnet-console documentation
  *                               for details
  */
 exports.init = function remoteConsole$$init(...commands)
@@ -84,16 +104,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',
@@ -105,12 +117,13 @@ exports.init = function remoteConsole$$init(...commands)
   }
   catch(e)
   {
-    console.warn(' ! Failed to enable telnet daemon:', e.message);
+    console.warn(` ! Failed to enable telnet daemon (${e.code || e.message})`);
+    debug('dcp-worker:telnet')('telnet daemon error:', e);
   }
 }
 
 /**
- *  Re-intercept log calls. To be used after a logger may have added its own override.
+ *  Re-intercept log calls. To be used after the globalThis.console has been replaced or mutated.
  */
 exports.reintercept = function remoteConsole$$reintercept()
 {

package/lib/utils.js

@@ -1,14 +1,21 @@
-
 /**
  * @file        utils.js
  *              Shared library code.
  *
  * @author      Paul, paul@distributive.network
  * @date        August 2023
+ * @author      Wes Garland, wes@distributive.network
+ * @date        June 2025
  */
 'use strict';
 
-const process = require('process');
+exports.slicesFetched      = slicesFetched;
+exports.debugging          = debugging;
+exports.isHash             = isHash;
+exports.shortLoc           = shortLoc;
+exports.qty                = qty;
+exports.uniq               = uniq;
+exports.makeSyslogUrl      = makeSyslogUrl;
 
 /**
  * Figure out #slices fetched from the different forms of the 'fetch' event.
@@ -33,14 +40,110 @@ function debugging()
 }
 
 /**
- * Flag to display detailed debug info in diagnostics.
- * @return {boolean}
+ * Output hostname:port for an arbitrary URL object
+ * @param {URL|DcpURL}    url
+ */
+function shortLoc(url)
+{
+  var port = url.port;
+
+  if (!port)
+  {
+    switch(url.protocol)
+    {
+      case 'http:':
+      case 'ws:':
+        port = 80;
+        break;
+      case 'https:':
+      case 'wss:':
+        port = 443;
+        break;
+      case 'ftp:':
+        port = 21;
+        break;
+    }
+  }
+
+  return `${url.hostname}:${port}`;
+}
+
+/**
+ * Imperfect, but handles CG { joinKey, joinHash }.
+ * @param {string} b      string which might be a join hash
+ * @returns {boolean} returns true when b is a join hash; false otherwise
  */
-function displayMaxDiagInfo ()
+function isHash(b)
 {
-  return Boolean(process.env.DCP_SUPERVISOR_DEBUG_DISPLAY_MAX_INFO) || debugging() || false;
+  return b && b.length === 68 && b.startsWith('eh1-');
 }
 
-exports.slicesFetched = slicesFetched;
-exports.debugging = debugging;
-exports.displayMaxDiagInfo = displayMaxDiagInfo;
+/**
+ * Display a quantity of things with units
+ * @param {number} amount    the number of things
+ * @param {string} singular  singular form of unit
+ * @param {string} plural    plural form of unit
+ * @returns {string}
+ * @example
+ *   qty(1, 'apple', 'apples') => '1 apple'
+ *   qty(2, 'apple', 'apples') => '2 apples'
+ * @todo i18n
+ */
+function qty(amount, singular, plural)
+{
+  if (Array.isArray(amount))
+    amount = amount.length;
+  if (!plural)
+    plural = singular + 's';
+  if (!amount)
+    return plural;
+  if (Number(amount) === 1)
+    return singular;
+  return plural;
+}
+
+/**
+ * Return a new array composed only of unique elements of arr
+ * @param {Array} arr
+ * @returns {Array}
+ */
+function uniq(array)
+{
+  return array.filter((val, idx, arr) => arr.indexOf(val) === idx);
+}
+
+/**
+ * Syslog URLs are bit special - the pathname of the URL encodes the syslog facility. Additionally, a
+ * plain string treated as just a pathname and no other components
+ *
+ * existingUrl                       newArg                             result
+ * -------------------------------   --------------------------------   ----------------------------------
+ * udp://localhost:513/local0        tls://provider.com:123/local1      tls://provider.com:123/local1
+ * udp://localhost:513/local0        local1                             udp://localhost:513/local1
+ * udp://localhost:513/local0        tls://provider.com:123/            tls://provider.com:123/local0
+ *
+ * @param {URL}          existingUrl
+ * @param {string|URL}   newArg
+ * @returns {URL}
+ */
+function makeSyslogUrl(existingUrl, newArg)
+{
+  var newUrl;
+
+  if (/^[A-Za-z]+[0-9]?$/.test(newArg))
+  {
+    newUrl = new URL(existingUrl.href);
+    newUrl.pathname = newArg;
+  }
+  else
+  {
+    newUrl = new URL(newArg)
+    if (!newUrl.pathname)
+      newUrl.pathname = existingUrl.pathname;
+  }
+
+  if (!newUrl.pathname)
+    newUrl.pathname = 'local7';
+
+  return newUrl;
+}

package/lib/web-console.js

@@ -0,0 +1,178 @@
+/**
+ * https://stackoverflow.com/questions/52843900/blessed-server-node-js-over-websocket-to-xterm-js-client-in-browser
+ */
+const blessed = require('blessed');
+const contrib = require('blessed-contrib');
+const path    = require('path');
+const fs      = require('fs');
+const http    = require('http');
+
+const progDir = path.dirname(require.main.filename);
+const wwwDir  = path.resolve(progDir, '../www');
+const nmDir   = path.resolve(progDir, '../node_modules');
+
+const magic = {
+  html: 'text/html',
+  txt:  'text/plain',
+  js:   'application/javascript',
+  css:  'text/css',
+  gif:  'image/gif',
+  jpeg: 'image/jpeg',
+  jpg:  'image/jpeg',
+  png:  'image/png',
+  svg:  'image/svg+xml',
+  kvin: 'application/x-kvin',
+}
+
+const clients = [ ];
+var worker; /* instance of DistributiveWorker, null (stopped), or undefined (not started) */
+
+/**
+ * Return a copy of the local dcp config, with the current worker's config at dcpConfig.worker, but with
+ * with sensitive information (eg compute group credentials) stripped.
+ */
+function makeSafeConfig()
+{
+  const conf = Object.assign({}, dcpConfig);
+  conf.worker = Object.assign({}, worker.config || dcpConfig.worker?.config);
+
+  /* Sanitize worker.computeGroups credentials */
+  if (conf.worker?.computeGroups)
+  {
+    conf.worker.computeGroups = Object.assign({}, conf.worker.computeGroups);
+    for (let key in conf.worker.computeGroups)
+    {
+      const group = conf.worker.computeGroups[key];
+      if (group.joinKey)
+        group = { joinKey: group.joinKey };
+      else
+        group = {};
+      conf.worker.computeGroups[key] = group;
+    }
+  }
+
+  return conf;
+}
+
+/**
+ * HTTP server
+ */
+function handleHttpRequest(request, response)
+{
+  if (request.url === '/etc/dcp-config.js')
+  {
+    response.setHeader('Content-Type', magic.js);
+    response.end(makeSkeletonConfig());
+    return;
+  }
+
+  if (request.url === '/etc/dcp-config.kvin')
+  {
+    response.setHeader('Content-Type', magic.kvin);
+    response.end('(' + JSON.stringify(dcpConfig) + ')');
+    return;
+  }
+
+  var filename = (request.url.slice(1) || 'index.html');
+  const contentType = magic[path.extname(filename).slice(1)] || 'text/plain';
+  var errorStatus, contentDir;
+
+  if (!filename.startsWith('node_modules/'))
+    contentDir = wwwDir;
+  else
+  {
+    contentDir = nmDir;
+    filename = filename.slice(13);
+  }
+
+  filename = path.resolve(contentDir, filename);
+  console.log({contentDir,filename,requestUrl:request.url});
+  if (!filename.startsWith(contentDir) || filename[0] !== '/')
+    errorStatus = 401;
+  else if (!fs.existsSync(filename))
+    errorStatus = 404;
+
+  if (errorStatus)
+  {
+    response.setHeader('Content-Type', 'text/plain');
+    response.statusCode = errorStatus;
+    response.end(`${errorStatus} accessing ${filename}`);
+    return;
+  }
+
+  response.setHeader('Content-Type', contentType);
+  response.end(fs.readFileSync(filename));
+}
+
+exports.getConfig = function webConsole$$getConfig()
+{
+  var config = { host: 'localhost', port: 9080 };
+
+  if (dcpConfig.worker?.webConsole?.listen)
+  {
+    config.host = dcpConfig.worker.webConsole.listen.host;
+    config.port = dcpConfig.worker.webConsole.listen.port || 80;
+  }
+
+  return config;
+}
+
+exports.a$init = function webConsole$$init()
+{
+  var server = http.createServer(handleHttpRequest).unref();
+  var resolve, reject;
+  var a$Promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+
+  server.on('error', error => {
+    console.error(` ! Web console not started; ${error.message}`);
+    reject(error);
+  });
+  server.listen(exports.getConfig(), function webConsole$$ready() {
+    resolve();
+    console.log(` * httpd listening on ${server._connectionKey}`);
+  });
+
+  /**
+   * WebSocket server
+   */
+  const WebSocketServer = require('websocket').server;
+  const wsServer = new WebSocketServer({
+    httpServer: server,
+    autoAcceptConnections: false
+  });
+
+  wsServer.on('request', handleWssRequest);
+  function handleWssRequest(request)
+  {
+    const connection = request.accept(null, request.origin);
+    connection.socket.unref();
+    clients.push(connection);
+
+    const write = connection.send;
+    const read = connection.socket.read;
+
+    connection.send(JSON.stringify({ type: 'log', facility: 'debug', message: 'hello, world' }));
+    connection.on('message', messageHandler);
+    connection.on('close', closeHandler);
+
+    function messageHandler(message)
+    {
+      console.log('message:', message)
+      console.log('this:', this);
+    }
+
+    function closeHandler()
+    {
+    }
+  }
+
+  return a$Promise;
+}
+
+exports.setWorker = function webConsole$$setWorker(dw)
+{
+  worker = dw;
+}

package/lib/web-iface.js

@@ -0,0 +1,128 @@
+/**
+ * https://stackoverflow.com/questions/52843900/blessed-server-node-js-over-websocket-to-xterm-js-client-in-browser
+ */
+const blessed = require('blessed');
+const contrib = require('blessed-contrib');
+const path    = require('path');
+const fs      = require('fs');
+const http    = require('http');
+
+const progDir = path.dirname(require.main.filename);
+const wwwDir  = path.resolve(progDir, '../www');
+const nmDir   = path.resolve(progDir, '../node_modules');
+const listenHost = listenUrl.hostname === 'localhost' ? '::' : listenUrl.hostname;
+
+const magic = {
+  html: 'text/html',
+  txt:  'text/plain',
+  js:   'application/javascript',
+  css:  'text/css',
+  gif:  'image/gif',
+  jpeg: 'image/jpeg',
+  jpg:  'image/jpeg',
+  png:  'image/png',
+  svg:  'image/svg+xml',
+  kvin: 'application/x-kvin',
+}
+
+const clients = [ ];
+
+function makeSkeletonConfig()
+{
+  return `window.dcpConfig = {
+  scheduler: {
+    location: new URL('${dcpConfig.scheduler.location.href}'),
+  },
+const listenUrl = dcpConfig.webConsole.listen;
+  worker: (${JSON.stringify(dcpConfig.worker)})
+}`;
+}
+
+/**
+ * HTTP server
+ */
+var server = http.createServer(handleHttpRequest).unref();
+function handleHttpRequest(request, response)
+{
+  if (request.url === '/etc/dcp-config.js')
+  {
+    response.setHeader('Content-Type', magic.js);
+    response.end(makeSkeletonConfig());
+    return;
+  }
+
+  if (request.url === '/etc/dcp-config.kvin')
+  {
+    response.setHeader('Content-Type', magic.kvin);
+    response.end('(' + JSON.stringify(dcpConfig) + ')');
+    return;
+  }
+
+  var filename = (request.url.slice(1) || 'index.html');
+  const contentType = magic[path.extname(filename).slice(1)] || 'text/plain';
+  var errorStatus, contentDir;
+
+  if (!filename.startsWith('node_modules/'))
+    contentDir = wwwDir;
+  else
+  {
+    contentDir = nmDir;
+    filename = filename.slice(13);
+  }
+
+  filename = path.resolve(contentDir, filename);
+  console.log({contentDir,filename,requestUrl:request.url});  
+  if (!filename.startsWith(contentDir) || filename[0] !== '/')
+    errorStatus = 401;
+  else if (!fs.existsSync(filename))
+    errorStatus = 404;
+
+  if (errorStatus)
+  {
+    response.setHeader('Content-Type', 'text/plain');
+    response.statusCode = errorStatus;
+    response.end(`${errorStatus} accessing ${filename}`);
+    return;
+  }
+
+  response.setHeader('Content-Type', contentType);
+  response.end(fs.readFileSync(filename));
+}
+
+server.listen({ host: listenHost, port: listenUrl.port }, function(server) {
+  console.log(`listening on port ${listenUrl.href}`);
+});
+
+/**
+ * WebSocket server
+ */
+const WebSocketServer = require('websocket').server;
+const wsServer = new WebSocketServer({
+  httpServer: server,
+  autoAcceptConnections: false
+});
+
+wsServer.on('request', handleWssRequest);
+function handleWssRequest(request)
+{
+  const connection = request.accept(null, request.origin);
+  connection.socket.unref();
+  clients.push(connection);
+  
+  const write = connection.send;
+  const read = connection.socket.read;
+
+  connection.send(JSON.stringify({ type: 'log', facility: 'debug', message: 'hello, world' }));
+  connection.on('message', messageHandler);
+  connection.on('close', closeHandler);
+
+  function messageHandler(message)
+  {
+    console.log('message:', message)
+    console.log('this:', this);
+  }
+
+  function closeHandler()
+  {
+  }
+}