dcp-worker 3.2.30-1 → 3.2.30-3

package/bin/dcp-worker

@@ -8,21 +8,16 @@
  */
 'use strict';
 
+var worker;
+
 const process = require('process');
 const fs      = require('fs');
+const path    = require('path');
 const crypto  = require('crypto');
 const chalk   = require('chalk');
+const telnetd = require('../lib/remote-console');
 
 const configName = process.env.DCP_CONFIG || '../etc/dcp-worker-config';
-var worker, dcpConfig, debugging;
-
-const debug = (...args) => {
-  if (!debugging)
-    debugging = require('dcp/internal/debugging').scope('dcp-worker');
-  if (debugging())
-    console.debug('dcp-worker:', ...args);
-};
-
 const EXIT_UNHANDLED = 5;
 
 /* Setup the telnet REPL up early to ensure early-failure log messages are captured */
@@ -34,11 +29,11 @@ const replHelpers = {
   },
   commands: {
     report: printReport,
-    kill:   process.exit,
+    kill:   processExit,
     die:    () => worker && worker.stop()
   },
 };
-require('../lib/remote-console').init(replHelpers);
+telnetd.init(replHelpers);
 
 /* Initialize dcp-client with local config defaults and run the main function. DCP_CONFIG_COOKIE becomes dcpConfig.cookie. */
 process.env.DCP_CONFIG_COOKIE = (Math.random().toString(16)).slice(2) + '-' + process.pid + '-' + Date.now();
@@ -48,7 +43,6 @@ function parseCliArgs()
 {
   var defaultPidFileName;
   
-  dcpConfig = require('dcp/dcp-config');
   defaultPidFileName = require('../lib/pidfile').getDefaultPidFileName(dcpConfig.worker.pidfile);
   
   const cliArgs = require('dcp/cli')
@@ -98,18 +92,21 @@ function parseCliArgs()
       },
       priorityOnly: {
         alias: 'P',
+        hidden: true,
         describe: 'Set the priority mode [deprecated]',
         type: 'boolean',
         default: false
       },
       'job-id': {
         alias: 'j',
+        hidden: true,
         describe: 'Restrict worker to a specific job (use N times for N jobs)',
         type: 'array',
       },
 
       join: {
         alias: 'g',
+        hidden: true,
         describe: 'Join compute group; the format is "joinKey,joinSecret" or "joinKey,eh1-joinHash"',
         type: 'array'
       },
@@ -120,22 +117,27 @@ function parseCliArgs()
 
       leavePublicGroup: {
         type: 'boolean',
+        hidden: true,
         describe: 'Do not fetch slices from public compute group.',
         default: undefined,
       },
 
       publicGroupFallback: {
+        hidden: true,
         describe: 'If set, worker will prefer private groups but fall back on the public group if no preferred work is available',
         type: 'boolean',
-        default: undefined,
+        default: 'undefined',
+        defaultDescription: undefined,
       },
 
       identityKey: {
+        hidden: true,
         describe: 'Identity key, in hex format',
         type: 'string',
         group: 'Identity options',
       },
       identityKeystore: {
+        hidden: true,
         describe: 'Identity keystore, in json format',
         type: 'string',
         group: 'Identity options',
@@ -147,30 +149,40 @@ function parseCliArgs()
         group: 'Output options',
       },
       eventDebug: {
-        hide: true,
+        hidden: true,
         describe: 'If set, dump all sandbox and worker events',
       },
 
       logfile: {
-        describe: 'Path to log file (if --output=file)',
+        describe: 'Path to log file',
         type: 'string',
         group: 'Log File output options',
+        default: path.resolve('../log/dcp-worker.log'),
       },
       syslogAddress: {
-        describe: 'Address of rsyslog server (if --output=syslog)',
+        describe: 'Address of syslog server',
         type: 'string',
         group: 'Syslog output options',
+        default: 'loghost',
+      },
+      syslogFacility: {
+        describe: 'Name of syslog facility',
+        type: 'string',
+        group: 'Syslog output options',
+        default: 'local7',
       },
       syslogTransport: {
-        describe: 'Transport to connect to rsyslog daemon (if --output=syslog)',
+        describe: 'Transport to connect to use for syslog',
         type: 'string',
-        choices: ['udp','tcp'],
+        choices: ['udp','tcp','unix','tls'],
         group: 'Syslog output options',
+        default: 'udp',
       },
       syslogPort: {
-        describe: 'UDP/TCP port of rsyslog server',
+        describe: 'UDP/TCP port to use for syslog',
         type: 'number',
         group: 'Syslog output options',
+        default: 514,
       },
 
       allowedOrigins: {
@@ -202,8 +214,8 @@ function parseCliArgs()
 
   if (cliArgs.dumpConfig)
   {
-    console.debug(JSON.stringify(require('dcp/dcp-config'), null, 2));
-    process.exit(0);
+    console.log(JSON.stringify(require('dcp/dcp-config'), null, 2));
+    processExit(0);
   }
 
   return cliArgs;
@@ -228,6 +240,20 @@ function addConfig(target, ...objs)
   Object.assign(target, tmp);
 }
 
+/** 
+ * Replacement for process.exit() that tries to increase the probability
+ * that remote log messages will make it out over the network.
+*/
+function processExit()
+{
+  logClosing('debug', 'Exit Code:', process.exitCode || 0);
+  if (console.close)
+    console.close();
+  setImmediate(() => {
+    process.exit.apply(null, arguments);
+  });
+}
+
 /**
  * Main program entry point. Assumes DCP client is already initialized and console logging is ready.
  */
@@ -235,21 +261,22 @@ async function main()
 {
   const wallet = require('dcp/wallet');
   const DCPWorker = require('dcp/worker').Worker;
-  const { startWorkerLogger } = require('../lib/startWorkerLogger');
   const cliArgs = parseCliArgs();
   const sawOptions = {
     hostname: cliArgs.hostname,
     port:     cliArgs.port
   };
 
-  verifyDefaultConfigIntegrity(); /* Bail before TUI & as early as possible if config file is bad */
+  telnetd.setMainEval(function mainEval() { return eval(arguments[0]) }); // eslint-disable-line no-eval
+  require('../lib/startWorkerLogger').init(cliArgs); /* Start remote logger as early as possible */
+  verifyDefaultConfigIntegrity();                    /* Bail before TUI & as early as possible if bad conf */
 
   process.on('SIGINT', handleSigDeath);
   process.on('SIGTERM', handleSigDeath);
   process.on('SIGQUIT', handleSigDeath);
   process.on('unhandledRejection', handleUnhandled);
   process.on('uncaughtException', handleUnhandled);
-
+  
   let paymentAddress = false
       || cliArgs.paymentAddress
       || dcpConfig.worker.paymentAddress
@@ -285,6 +312,7 @@ async function main()
   const dcpWorkerOptions = dcpConfig.worker;
   const forceOptions = {
     paymentAddress,
+    maxWorkingSandboxes: cliArgs.cores,
   };
   const defaultOptions = {
     sandboxOptions: {
@@ -339,26 +367,26 @@ async function main()
     dcpWorkerOptions.watchdogInterval = cliArgs.watchdogInterval;
 
   worker = new DCPWorker(identityKeystore, dcpWorkerOptions);
-  worker.on('error', (...payload) => console.error(...payload));
-  worker.on('warning', (...payload) => console.warn(...payload));
+  worker.on('error',   (...payload) => console.error(...payload));
+  worker.on('warning', (...payload) => console.warn (...payload));
+  worker.on('stop', () => { console.log('Worker is stopping') });
+  worker.on('end',  () => { logClosing('log', 'Worker has stopped') });
+  require('../lib/default-ui-events').hook(worker, cliArgs);
 
+  if (cliArgs.outputMode === 'dashboard')
+    require('../lib/dashboard-tui').init(worker, cliArgs);
+  
   /* Let incorrect event-loop references keep us alive when linked with a debug library, but
    * exit quickly/accurately for production code even when the library isn't perfect.
    */
   if (require('dcp/build').config.build !== 'debug')
-    worker.on('end', process.exit);
+    worker.on('end', processExit);
   else
-    worker.on('end', () => setTimeout(process.exit, getCleanupTimeoutMs()).unref());
+    worker.on('end', () => setTimeout(processExit, getCleanupTimeoutMs()).unref());
 
   if (cliArgs.eventDebug)
     worker.enableDebugEvents = true;
 
-  worker.on('stop', () => { console.log('Worker is stopping') });
-  worker.on('end',  () => { logClosing('log', 'Worker has stopped') });
-  startWorkerLogger(worker, cliArgs);
-
-  require('../lib/remote-console').setMainEval(function mainEval() { return eval(arguments[0]) });
-
   if (dcpWorkerOptions.publicGroupFallback)
   {
     if (dcpWorkerOptions.leavePublicGroup)
@@ -380,12 +408,12 @@ async function main()
           return;
         }
 
-        if (typeof ev === 'string') /* <= June 2023 Worker events: remove ~ Sep 2023 /wg */
+        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;
+          slicesFetched = task.slices.length;
         }
 
         dcpWorkerOptions.leavePublicGroup = Boolean(slicesFetched > 0);
@@ -415,21 +443,23 @@ async function main()
 
   if (dcpWorkerOptions.jobAddresses?.length > 0)
     introBanner += ` * Processing only ${qty(dcpWorkerOptions.jobAddresses, 'job')} ` + dcpWorkerOptions.jobAddresses.join(', ') + '\n';
-  if (dcpWorkerOptions.computeGroups?.length > 0)
+  if (dcpWorkerOptions.computeGroups && Object.keys(dcpWorkerOptions.computeGroups).length > 0)
     introBanner += ` . Joining compute ${qty(dcpWorkerOptions.computeGroups, 'group')} ` + dcpWorkerOptions.computeGroups.map(el => el.joinKey).join(', ') + '\n';
   if (dcpWorkerOptions.publicGroupFallback)
     introBanner += ' . Falling back on public group when preferred groups have no work' + '\n';
   if (dcpWorkerOptions.leavePublicGroup)
     introBanner += ' . Leaving the public compute group' + '\n';
   if (dcpWorkerOptions.cores)
-    introBanner += ` . Target cores: ${JSON.stringify(dcpWorkerOptions.cores)}\n`;
+    introBanner += ` . Configured Cores: ${dcpWorkerOptions.cores.cpu},${dcpWorkerOptions.cores.gpu}\n`
   else
     introBanner += ` . Target core density: ${JSON.stringify(dcpWorkerOptions.defaultCoreDensity)}\n`;
   if (cliArgs.verbose)
     introBanner += ` + Verbosity level: ${cliArgs.verbose}` + '\n';
   if (cliArgs.eventDebug)
     introBanner += ' + Event debug on' + '\n';
-
+  if (telnetd.hasOwnProperty('port'))
+    introBanner += ` ! telnetd listening on port ${telnetd.port}\n`;
+  
   introBanner += ' . Supervisor version: ' + worker.supervisorVersion;
   introBanner += ' . Output mode: ' + cliArgs.outputMode + '\n';
   introBanner += ' * Ready' + '\n';
@@ -442,7 +472,7 @@ async function main()
     if (cliArgs.outputMode !== 'dashboard')
       setInterval(printReport, parseFloat(cliArgs.reportInterval) * 1000).unref();
     else
-      console.log('Ignoring --reportInterval in dashboard output mode');
+      console.warn('Ignoring --reportInterval in dashboard output mode');
   }
 
   /* Start the worker. Normal process exit happens by virtue of the worker<end> event */
@@ -481,9 +511,9 @@ function processCoresAndDensity (dcpWorkerOptions, cliArgs)
   parseArg('cores');
 
   if (dcpWorkerOptions.cores)
-    debug('cores = ', dcpWorkerOptions.cores);
+    debugging() && console.debug('dcp-worker: cores =', dcpWorkerOptions.cores);
   else
-    debug('core density = ', dcpWorkerOptions.defaultCoreDensity);
+    debugging() && console.debug('dcp-worker: core density =', dcpWorkerOptions.defaultCoreDensity);
 }
 
 /**
@@ -494,9 +524,7 @@ function logClosing(facility, ...message)
 {
   var screen = require('../lib/worker-loggers/dashboard').screen;
 
-  if (!screen)
-    console[facility](message);
-  else
+  if (screen)
   {
     /* Turn off fullscreen TUI and resume "normal" console logging.
      * FUTURE: dashboard API should know how to unregister its hook so that we don't have to clobber
@@ -505,10 +533,11 @@ function logClosing(facility, ...message)
     screen.log(...message);
     screen.destroy();
     screen = false;
-    console = new (require('console').Console)(process);
-    require('../lib/remote-console').reintercept();
-    console[facility].call(null, ...message);
+    console = new (require('console').Console)(process); // eslint-disable-line no-global-assign
+    telnetd.reintercept();
   }
+
+  console[facility](...message);
 }
 
 /** 
@@ -517,7 +546,7 @@ function logClosing(facility, ...message)
  * the worker must be restarted. This handler does its best to report the rejection and give the worker a few
  * seconds in which to attempt to return slices to the scheduler before it gives up completely.
  */
-async function handleUnhandled(error)
+function handleUnhandled(error)
 {
   var _worker = worker;
   worker = false;
@@ -526,21 +555,21 @@ async function handleUnhandled(error)
   
   try
   {
-    logClosing(error);
-  } catch(e) {};
+    logClosing('error', error);
+  } catch(e) {} // eslint-disable-line no-empty
 
   if (!_worker)
     console.error('trapped unhandled error:', error)
   else
   {
     console.error('trapped unhandled error -- stopping worker:', error);
-    _worker.on('end', process.exit);
+    _worker.on('end', processExit);
     _worker.stop();
   }
 
   setTimeout(() => {
     logClosing('error', 'handleFatalError timeout - exiting now');
-    process.exit();
+    processExit();
   }, getCleanupTimeoutMs()).unref();
 
   try {
@@ -550,7 +579,7 @@ async function handleUnhandled(error)
       fs.appendFileSync(process.env.DCP_WORKER_UNHANDLED_REJECTION_LOG,
                         `${Date.now()}: ${error.message}\n${error.stack}\n\n`);
     }
-  } catch(e) {};
+  } catch(e) {} // eslint-disable-line no-empty
 }
 
 /** print the slice report via console.log */
@@ -647,14 +676,14 @@ function handleSigDeath(signalName, signal)
   process.off(signalName, handleSigDeath);
 
   if (!worker)
-    console.error(`trapped ${signalName}, signal ${signal}`);
+    console.warn(`trapped ${signalName}, signal ${signal}`);
   else
   {
-    console.error(`trapped ${signalName}, signal ${signal} -- stopping worker`);
+    console.warn(`trapped ${signalName}, signal ${signal} -- stopping worker`);
     worker.stop(signalName === 'SIGQUIT');
   }
 
-  setTimeout(() => process.exit(signal - 128), getCleanupTimeoutMs()).unref();
+  setTimeout(() => processExit(signal - 128), getCleanupTimeoutMs()).unref();
 }
 
 /**
@@ -674,7 +703,7 @@ function getCleanupTimeoutMs()
     cleanupTimeout = defaultCT;
     if (!getCleanupTimeoutMs.warned)
     {
-      console.warn(`warning: dcpConfig.worker.cleanupTimeout is not a number (${dcpConfig.worker.cleanupTimeout})`);
+      console.error(`warning: dcpConfig.worker.cleanupTimeout is not a number (${dcpConfig.worker.cleanupTimeout})`);
       getCleanupTimeoutMs.warned = true;
     }
   }
@@ -696,7 +725,7 @@ function verifyDefaultConfigIntegrity()
 
   if (!fs.existsSync(md5sumPath))
   {
-    console.log(chalk.bold.red(` ! warning: ${md5sumPath} not found; cannot verify configuration integrity`));
+    console.error(chalk.bold.red(` ! warning: ${md5sumPath} not found; cannot verify configuration integrity`));
     require('dcp/utils').sleep(2);
   }
   else
@@ -718,7 +747,7 @@ function verifyDefaultConfigIntegrity()
       console.warn('    - the Windows Registry');
 
       if (require('dcp/build').config.build !== 'debug')
-        process.exit(1);
+        processExit(1);
 
       console.log(chalk.bold.red.inverse("If this wasn't a debug build, the worker would exit now."));
       require('dcp/utils').sleep(2);
@@ -728,10 +757,18 @@ function verifyDefaultConfigIntegrity()
   if (dcpConfig.cookie !== process.env.DCP_CONFIG_COOKIE || !dcpConfig.cookie)
   {
     console.error(' ! DCP Worker default configuration was not loaded; exiting.');
-    process.exit(1);
+    processExit(1);
   }
 }
 
+/* thunk - ensures global debugging() symbol always available even if called before dcp-client init */
+function debugging()
+{
+  require('dcp-client');
+  debugging = require('dcp/internal/debugging').scope('dcp-worker');
+  return debugging.apply(this, arguments);
+}
+
 /**
  * Cast b to boolean such that 'false' becomes false, falsey things become false, and everything else
  * becomes true.

package/docs/CODEOWNERS

@@ -18,9 +18,11 @@
 /package-lock.json @eroosenmaallen
 
 [Wes]
+/npm-hooks/ @wesgarland
 /README.md @wesgarland
 /docs/ @wesgarland
 /.eslintrc.json @wesgarland
+/.npmrc @wesgarland
 /.tidelift @wesgarland
 /lib/ @wesgarland
 /LICENSE.md @wesgarland

package/lib/blessed-components/index.js

@@ -1,3 +1,4 @@
+'use strict';
 
 Object.assign(exports, require('./log'));
 Object.assign(exports, require('./sandboxes'));

package/lib/blessed-components/log.js

@@ -7,6 +7,7 @@
  *  log component, but features text wrapping and behaves
  *  closer to the built-in console log methods.
  */
+'use strict';
 
 const { Box } = require('blessed');
 

package/lib/check-scheduler-version.js

@@ -6,6 +6,7 @@
  * @author      Sam Cantor
  * @date        Nov 2020
  */
+'use strict';
 
 exports.check = function checkSchedulerVersion$$check(quiet)
 {

package/lib/dashboard-tui.js

@@ -0,0 +1,184 @@
+/**
+ *  @file       worker-loggers/dashboard.js
+ *  @author     Ryan Rossiter, ryan@kingsds.network
+ *  @date       April 2020
+ *  @author     Wes Garland, wes@distributive.network
+ *  @date       June 2023
+ *
+ *  This module uses the blessed library to create a monitoring dashboard for the worker.
+ *  A corresponding worker-logger, dashboard.js, knows how to log to this dashboard.
+ */
+'use strict';
+
+const dcpConfig  = require('dcp/dcp-config');
+const chalk      = require('chalk');
+const blessed    = require('blessed');
+const contrib    = require('blessed-contrib');
+const components = require('./blessed-components');
+
+const { replaceWorkerEvent, replaceSandboxEvent }  = require('./default-ui-events');
+
+const SLICE_FETCH_STATUS = {
+  IDLE: chalk.yellow('Idle'),
+  FETCHING: chalk.blue('Fetching Work...'),
+  WORKING: chalk.green('Working'),
+  NO_WORK: chalk.red('No Work Available'),
+}
+
+const usingDebugger = require('module')._cache.niim instanceof require('module').Module;
+const screenConf = {
+  input:  usingDebugger ? new (require('events').EventEmitter) : undefined,
+  output: usingDebugger ? new (require('events').EventEmitter) : undefined,
+};
+/** 
+ */
+exports.init = function dashboard$$init(worker, options)
+{
+  var sliceFetchStatus = SLICE_FETCH_STATUS.IDLE;
+  var totalDCCs = 0;
+  const screen = blessed.screen(screenConf);
+  const grid = new contrib.grid({rows: 3, cols: 5, screen});
+  const workerInfoPane = grid.set(2, 0, 1, 5, blessed.text);
+  
+  const logPane = grid.set(0, 2, 2, 3, components.log, {
+    label: 'Worker Log',
+    scrollable: true,
+    alwaysScroll: true,
+    mouse: true,
+    scrollbar: {
+      bg: 'blue',
+    },
+  });
+
+  const sandboxPane = grid.set(0, 0, 2, 2, components.sandboxes, {
+    label: 'Sandboxes',
+    defaultProgressBars: Math.floor(worker.workerOptions.cores.cpu) || 1,
+    scrollable: true,
+    alwaysScroll: true,
+    mouse: true,
+    scrollbar: {
+      bg: 'blue',
+    },
+  });
+
+  delete exports.init; /* singleton */
+
+  if (!usingDebugger)
+    exports.logPane = logPane; /* now dashboard log can find the pane */
+  setInterval(() => screen.render(), 50).unref(); /* 50ms = 20 fps */
+  updateWorkerInfo();
+  screen.render();
+  
+  /* Apply key bindings which mimic canonical input mode */
+  screen.key(['C-c'], ()    => raise('SIGINT'));
+  screen.key(['C-z'], ()    => raise('SIGTSTP'));
+  screen.key(['\u001c'], () => raise('SIGQUIT')); /* C-\ */
+  
+  screen.key(['escape'], () => {
+    console.log('Stopping worker...');
+    worker.stop();
+  });
+
+  function updateWorkerInfo()
+  {
+    const workerOptions = worker.workerOptions;
+    
+    workerInfoPane.setLabel(`Worker Status [${sliceFetchStatus}]`);
+    workerInfoPane.setContent([
+      chalk.green(` DCCs Earned: ${chalk.bold(totalDCCs.toFixed(3))}`),
+      '',
+      `   Scheduler: ${chalk.yellow(dcpConfig.scheduler.location.href)}`,
+      `        Bank: ${chalk.yellow(dcpConfig.bank.location.href)}`,
+      `Bank Account: ${chalk.yellow(worker.paymentAddress || 'Starting...')}`,
+      `    Identity: ${chalk.yellow(worker.identityKeystore? 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'));
+  }
+
+  /* Override default event behaviour to work better with the Dashboard. */
+
+  replaceSandboxEvent('start', function dashboard$$sliceStart(sandbox, sandboxData, ev) {
+    sandboxData.progressData = {
+      indeterminate: true,
+      progress: 0,
+      label: sandbox.public.name,
+    };
+
+    sandboxPane.data.push(sandboxData.progressData);
+    sandboxPane.update();
+  });
+
+  replaceSandboxEvent('sliceProgress', function dashboard$$sliceProgress(sandbox, sandboxData, ev) {
+    if (ev.indeterminate)
+    {
+      sandboxData.progressData.progress = 100;
+      setTimeout(() => {
+        if (sandboxData.progressData.indeterminate) {
+          sandboxData.progressData.progress = 0;
+          sandboxPane.update();
+        }
+      }, 500).unref();
+    }
+    else
+    {
+      sandboxData.progressData.progress = ev.progress;
+      sandboxData.progressData.indeterminate = false;
+    }
+
+    sandboxPane.update();
+  });
+  
+  replaceSandboxEvent('sliceFinish', function dashboard$$sliceFinish(sandbox, sandboxData, ev) {
+    sandboxPane.data = sandboxPane.data.filter(d => d != sandboxData.progressData);
+    sandboxPane.update();
+  });
+
+  worker.on('payment', updateWorkerInfo);
+
+  replaceWorkerEvent('fetchStart', function dashboard$$fetchStart(ev) {
+    sliceFetchStatus = SLICE_FETCH_STATUS.FETCHING;
+    updateWorkerInfo();
+  });
+  
+  replaceWorkerEvent('fetch', function dashboard$$fetch(ev) {
+    var slicesFetched;
+
+    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 {
+      sliceFetchStatus = SLICE_FETCH_STATUS.WORKING;
+    }
+
+    updateWorkerInfo();
+  });
+
+  replaceWorkerEvent('fetchError', function dashabord$$fetchError() {
+    sliceFetchStatus = SLICE_FETCH_STATUS.NO_WORK;
+    updateWorkerInfo();
+  });
+};
+
+/**
+ * Send a signal to the caller
+ * @param {number|string} sig    the signal to raise
+ */
+function raise(sig)
+{
+  process.kill(process.pid, sig);
+}