dcp-worker 4.1.1 → 4.2.1

package/lib/worker-loggers/logfile.js

@@ -7,29 +7,53 @@
  */
 'use strict';
 
-// Copy the original global console object's properties onto a backup
-const _console = Object.assign({}, console);
+const fs = require('fs');
+var currentLogFileHnd;
 
 /**
  *  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
+ *  @param  {object}  options             Options for logger behaviour
+ *                    .filepath             Path to worker file; default: ./dcp-worker.log
+ *                    .overwriteLogfile     If true, logfile will be cleared at worker startup
  */
-exports.init = function init(options)
+exports.open = function logFile$$open(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);
-  
+  console.log(` . creating log file ${options.logfile}`);
+  createLogFile(options);
+
   // on SIGHUP, close the output stream and open a new one
   process.on('SIGHUP', () => {
-    getLogFile(options);
+    createLogFile(options, true);
   });
-  
-  exports.at = log;
+
+  exports.at = logToFile;
+  logToFile('info', 'begin');
+}
+
+/**
+ * Close the log file.
+ */
+exports.close = function logFile$$close()
+{
+  var p$resolve, p$reject;
+  if (!currentLogFileHnd)
+    return;
+  const p$finished = new Promise((resolve, reject) => { p$resolve = resolve; p$reject = reject });
+
+  try
+  {
+    currentLogFileHnd.on('error', error => p$reject(error));
+    currentLogFileHnd.on('finish', p$resolve);
+    currentLogFileHnd.write((new Date()).toISOString() + ` -------- end ${process.pid} --------\n`);
+    currentLogFileHnd.end();
+  }
+  catch (error)
+  {
+    exports.handleFatalError(error);
+  }
+  currentLogFileHnd = false;
+  return p$finished;
 }
 
 /**
@@ -38,62 +62,46 @@ exports.init = function init(options)
  *
  *  @return {fs.WriteStream}
  */
-function getLogFile(options)
+function createLogFile(options, overwrite)
 {
-  {
-    const fs = require('fs');
-    
-    if (getLogFile._file)
-    {
-      try
-      {
-        getLogFile._file.end();
-      }
-      catch (err)
-      {
-        console.error('061: failed to close old log file:', err);
-      }
-      getLogFile._file = false;
-    }
-    
-    const fileOptions = {
-      flags: options.truncate ? 'w' : 'a',  // NYI: cli --truncate 
-    }
-    
-    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);
-      
-      getLogFile(options);
-    });
-    
-    return file;
-  }
+  exports.close();
+
+  const logFileHnd = currentLogFileHnd = fs.createWriteStream(options.logfile, {
+    encoding:      'utf8',
+    flags:         (overwrite || options.overwriteLogfile) ? 'w' : 'a',
+    autoClose:     true,
+    emitClose:     true,
+    flush:         true,
+    highWaterMark: 1024 * 1024,
+  });
+  logFileHnd.on('error', exports.handleFatalError);
+  logFileHnd.write((new Date()).toISOString() + ` ------- begin ${process.pid} -------\n`);
+  return logFileHnd;
 }
 
-/** Write a log line to the output file. 
- *  
- *  current outputStream.
- *  @param {string} level Log level.
- *  @param {any} ...items Items to log.
+/**
+ * Write a log line to the output file.
+ *
+ * @param {string} level Log level.
+ * @param {any} ...items Items to log.
  */
-function log(level, ...items)
+function logToFile(level, ...items)
 {
-  {
-    const logPrefix = [
-      (new Date()).toISOString(),
-      level,
-    ];
-
-    const logElements = logPrefix.concat(items);
+  const logPrefix = `${(new Date()).toISOString()} ${level} `;
 
-    try {
-      getLogFile._file.write(logElements.join(' ') + '\n');
-    }
-    catch (error) {
-      _console.error('131: Unexpected error writing to log file:', error);
-    }
+  try
+  {
+    const message = items.join(' ');
+    if (!message)
+      return;
+    for (let line of message.split('\n'))
+      currentLogFileHnd.write(logPrefix + line + '\n');
+  }
+  catch (error)
+  {
+    exports.handleFatalError(error);
   }
 }
+
+exports.inspectOptions = { colors: Boolean(process.env.FORCE_COLOR) };
+exports.handleFatalError = undefined; /* supplied by ../loggers.js at runtime */

package/lib/worker-loggers/syslog.js

@@ -1,42 +1,123 @@
 /**
- *  @file       worker-loggers/syslog.js
- *  @author     Eddie Roosenmaallen <eddie@kingsds.network>
- *  @date       August 2022
+ * @file       worker-loggers/syslog.js
+ * @author     Eddie Roosenmaallen <eddie@kingsds.network>
+ * @date       August 2022
  *
- *  This logger module emits log lines to a remote syslogd, writing all
- *  console logs to it.
+ * This logger module emits log lines to a remote syslogd, writing all
+ * console logs to it.
+ *
+ * @todo   - Add options to support TLS syslog option tlsCA:
+ *           - this option becomes options.ca in require('tls').connect(options, ....)
+ *         - Add support to syslog-client-tls for options.secureProtocol; currently hard-coded to
+ *           TLSv1_2_method
+ *         - Investigate options besides handleFatalError when remote daemon yo-yoing
  */
 'use strict';
 
 const os      = require('os');
-const syslog  = require('syslog-client');
+const syslog  = require('syslog-client-tls');
 const process = require('process');
+const debug   = require('debug');
 
-// Copy the original global console object's properties onto a backup
-const _console = Object.assign({}, console);
 var syslogClient;
+var syslogOptions;
 var processName;
+var pending = 0; /* number of outstanding messages, not authoritative, good enough for cleanup timing */
 
+exports.at = syslogAt;
+exports.inspectOptions = { colors: false };
 /**
  *  Initialize the syslog worker logger
  *
- *  @param  {object} cliArgs          Options for logger behaviour (passed
+ *  @param  {object} options          Options for logger behaviour (passed
  *                                    through to consoleLogger)
  */
-exports.init = function syslog$$init(cliArgs)
+exports.open = function syslog$$open(options)
 {
+  const facilityName  = leadingCap(options.syslogUrl.pathname.slice(1) || 'local7');
+  const transportName = leadingCap(options.syslogUrl.protocol.slice(0, -1));
+  syslogOptions = {
+    syslogHostname: os.hostname(),
+    facility:       syslog.Facility[facilityName],
+    transport:      syslog.Transport[transportName],
+    port:           options.syslogUrl.port,
+    tcpTimeout:     (dcpConfig.worker.logging?.syslog?.tcpTimeout || '10') * 1e3,
+  };
+  const syslogTarget = options.syslogUrl.hostname;
+
+  if (!syslogOptions.transport)
+    throw new Error(`invalid syslog transport '${transportName}'`);
+  if (!syslogOptions.facility && syslogOptions.facility !== 0)
+    throw new Error(`invalid syslog facility '${facilityName}'`);
+
+  if (!syslogOptions.port)
   {
-    const syslogOptions = {
-      syslogHostname: os.hostname(),
-      transport: cliArgs.syslogTransport, // tcp, udp, unix, tls
-      port:      cliArgs.syslogPort,
-      facility: syslog.Facility[cliArgs.syslogFacility[0].toUpperCase() + cliArgs.syslogFacility.slice(1)],
-    };
-
-    syslogClient = syslog.createClient(cliArgs.syslogAddress, syslogOptions);
-    processName = require('path').basename(process.mainModule.filename || process.argv0);
-    exports.close = () => syslogClient.close();
+    switch(syslogOptions.transport)
+    {
+      case syslog.Transport.Tcp:
+      case syslog.Transport.Udp:
+        syslogOptions.port = 514;
+        break;
+      case syslog.Transport.Tls:
+        syslogOptions.port = 6514;
+        break;
+    }
   }
+
+  if (!syslogOptions.port)
+    throw new Error(`invalid syslog port '${syslogOptions.port}'`);
+  if (!syslogTarget)
+    throw new Error('missing syslog target');
+
+  debug('dcp-worker:logger')('connecting to syslogd at ' + options.syslogUrl);
+  syslogClient = syslog.createClient(options.syslogUrl.hostname, syslogOptions);
+  processName = require('path').basename(process.mainModule.filename) || 'dcp-worker';
+
+  syslogClient.on('error', (error) => {
+    pending = 0;
+    tryFinishClose();
+    if (!syslogClient)
+      return;
+
+    if (true /* lib does not have codes but messages are predictable */
+        && error.message !== 'connection timed out'
+        && error.message !== 'connection closed')
+      exports.handleFatalError(error);
+    else
+    {
+      if (pending !== 0)
+        console.warn(` ! syslog: ${error.message} (${pending} messages pending)`);
+    }
+  });
+
+  syslogClient.on('close', () => {
+    pending = 0;
+    tryFinishClose();
+    if (syslogClient)
+      exports.handleFatalError(new Error(`connection closed to syslog server at ${options.syslogUrl}`));
+  });
+}
+
+/**
+ * Close the connection to the syslog daemon; used by loggers::unhook(). Invoking this function makes
+ * it impossible to send any more messages to syslog, but we try to wait until all messages have been
+ * sent before resolving the close promise. This dramatically increases the probability that uncaught
+ * exceptions that crash the worker are actually logged some place other than the system console.
+ *
+ * The closePromise is resolved in tryFinishClose when the pending message counter reaches 0.
+ */
+exports.close = function a$syslog$$Close()
+{
+  const sc = syslogClient; /* symbol dance because sc.close() emits close event */
+  syslogClient = false;
+  const closePromise = new Promise(resolve => exports.close.resolve = resolve);
+  closePromise.then(() => {
+    clearTimeout(exports.close.timer);
+    sc && sc.close();
+  });
+  exports.close.timer = setTimeout(()=>1, syslogOptions.tcpTimeout + 867.5309); /* ref to keep process alive */
+  debug('dcp-worker:logger')('Closing syslog connection');
+  return sc ? closePromise : false;
 }
 
 /**
@@ -45,31 +126,52 @@ exports.init = function syslog$$init(cliArgs)
  *  @param  {string}    level Event level (info, debug, log, warning, error)
  *  @param  {...any[]}  argv  Items to log
  */
-function log(level, ...argv)
+function syslogAt(level, ...argv)
 {
+  const logPrefix = `${processName}[${process.pid}]: `;
+
+  // Use the string log-level to look up the severity number:
+  let severity = {
+    error: syslog.Severity.Error,
+    warn:  syslog.Severity.Warning,
+    log:   syslog.Severity.Notice,
+    info:  syslog.Severity.Informational,
+    debug: syslog.Severity.Debug,
+  }[level];
+
+  const logMessages = argv.join(' ').split('\n');
+  if (!syslogClient)
+    return;
+
+  for (let logMessage of logMessages)
   {
-    const logPrefix = `${processName}[${process.pid}]: `;
-    
-    // Use the string log-level to look up the severity number:
-    let severity = {
-      error: syslog.Severity.Error,
-      warn:  syslog.Severity.Warning,
-      log:   syslog.Severity.Notice,
-      info:  syslog.Severity.Informational,
-      debug: syslog.Severity.Debug,
-    }[level];
-
-    const logMessages = argv.join(' ').split('\n');
-
-    for (let logMessage of logMessages)
-    {
-      logMessage = logPrefix + logMessage;
-      syslogClient.log(logMessage, { severity }, error => {
-        if (error)
-          _console.error('168: Unexpected error writing to syslog:', error);
-      });
-    }
+    if (!logMessage)
+      continue;
+    pending++;
+    debug('dcp-worker:syslog-verbose')(`Sending message '${logMessage.slice(0,20)}'; pending=${pending}`);
+    syslogClient.log(logPrefix + logMessage, { severity }, function doneMessage(error) {
+      pending--;
+      tryFinishClose();
+      if (error)
+        exports.handleFatalError(error)
+    });
   }
 }
 
-exports.at = log;
+function tryFinishClose()
+{
+  debug('dcp-worker:syslog-verbose')(`tryFinishCLose, pending=${pending}, have resolve=${!!exports.close.resolve}`);
+  if (pending === 0 && exports.close.resolve)
+  {
+    clearTimeout(exports.close.timer);
+    exports.close.resolve();
+  }
+}
+
+function leadingCap(str)
+{
+  if (!str)
+    return str;
+  else
+    return str[0].toUpperCase() + str.toLowerCase().slice(1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "4.1.1",
+  "version": "4.2.1",
   "description": "Node.js Worker for Distributive Compute Platform",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -36,14 +36,16 @@
     "prepublishOnly": "npm-hooks/prepublish"
   },
   "dependencies": {
-    "blessed": "^0.1.81",
+    "blessed": "0.1.81",
     "blessed-contrib": "4.11.0",
     "chalk": "^4.1.0",
-    "dcp-client": "^5.0.1",
+    "dcp-client": "^5.1.2",
     "kvin": "^1.2.7",
     "posix-getopt": "^1.2.1",
     "semver": "^7.3.8",
-    "syslog-client": "1.1.1"
+    "syslog-client": "1.1.1",
+    "syslog-client-tls": "1.2.1",
+    "websocket": "1.0.34"
   },
   "optionalDependencies": {
     "dbus-next": "^0.10.2",

package/{bin/publish-docs.sh → publish-docs.sh}

@@ -9,7 +9,7 @@
 
 set -euo pipefail
 
-cd "$(dirname "$0")/.."
+cd "$(dirname "$0")"
 
 ROOT_DIR=$PWD
 

package/tests/worker-with-no-options.simple

@@ -2,19 +2,21 @@
 
 /**
  * @file        worker-with-no-options.simple
- * 
+ *
  * @author      Nazila Akhavan <nazila@distributive.network>
  * @date        Aug 2024
- * 
+ *
  * peter-timeout: 60
  */
 'use strict';
 
+const assert = require('node:assert');
+
 const { tmpdir } =require('node:os');
 const { spawnSync } = require('node:child_process');
 const { mkdtempSync, rmSync, existsSync, writeFileSync } = require('node:fs');
 const { join, parse, basename } = require('node:path');
-const { strictEqual, deepEqual } = require('node:assert');
+const { strictEqual, deepEqual } = assert;
 
 const filename = parse(basename(__filename)).name;
 const tempd = mkdtempSync(join(tmpdir(), `${filename}-`));
@@ -24,33 +26,53 @@ process.chdir(__dirname);
 
 async function main()
 {
+  const KVIN = require('dcp/internal/kvin')
   const { Keystore } = require('dcp/wallet');
   const ks = await new Keystore(null);
   const id = await new Keystore(null);
 
   writeFileSync(`${tempd}/default.keystore`, JSON.stringify(ks.toJSON()), { encoding: 'utf-8' });
   writeFileSync(`${tempd}/id.keystore`, JSON.stringify(id.toJSON()), { encoding: 'utf-8' });
-  const res = spawnSync(
-    '../bin/dcp-worker', ['--showConfig'],
+
+  const args = ['--show=worker-config', '--kvin'];
+  const env = { DCP_RESOURCE_DIR: tempd };
+  const envStr = Object.entries(env).map(kv => `${kv[0]}='${kv[1]}'`).join(' ');
+  const confOut = spawnSync(
+    '../bin/dcp-worker', ['--unmanaged', '--show=config', '--kvin', `--earnings-account=${tempd}/default.keystore`],
     {
       encoding: 'utf-8',
       env: {
         ...process.env,
-        DCP_RESOURCE_DIR: tempd
+        ...env,
       }
     }
-  );
-  
-  const confObj = JSON.parse(res.stdout);
-  strictEqual(confObj.paymentAddress, ks.address.valueOf(), `${confObj.paymentAddress} payment address is not correct`);
-  strictEqual(confObj.leavePublicGroup, undefined, `leaveComputeGroup is ${confObj.leavePublicGroup}`);
+  )
+
+  if (confOut.stderr)
+    console.error(confOut.stderr);
+  console.log(confOut.stdout);
+  const confObj = KVIN.parse(confOut.stdout);
+
+  strictEqual(confObj.paymentAddress.valueOf(), ks.address.valueOf(), `${confObj.paymentAddress} payment address is not correct`);
   deepEqual(confObj.allowOrigins.any, [], `allowOrigins should be empty. It includes ${confObj.allowOrigins.any}`);
   deepEqual(confObj.utilization, { cpu: 1, gpu: 0.75 }, `Mismatch in utilization! cpu: ${confObj.utilization.cpu}, gpu: ${confObj.utilization.gpu}`);
-  deepEqual(confObj.jobIds, undefined, `jobIds should be false but it is ${confObj.jobIds}`);
+  deepEqual(confObj.jobIds, false, `jobIds should be false but it is ${confObj.jobIds}`);
+
+  const computeGroups = KVIN.parse(spawnSync(
+    '../bin/dcp-worker', ['--unmanaged', '--show=compute-groups', '--kvin'],
+    {
+      encoding: 'utf-8',
+      env: {
+        ...process.env,
+        DCP_RESOURCE_DIR: tempd
+      }
+    }
+  ).stdout);
+  assert(Object.values(computeGroups).find(cg => cg.joinKey === 'public'));
 
   console.log('Done.');
 }
 
 require('dcp-client')
   .init()
-  .then(main);
+  .then(main);

package/tests/worker-with-options.simple

@@ -10,11 +10,13 @@
  */
 'use strict';
 
+const assert = require('node:assert');
+
 const { tmpdir } =require('node:os');
 const { spawnSync } = require('node:child_process');
 const { mkdtempSync, rmSync, existsSync, writeFileSync } = require('node:fs');
 const { join, parse, basename } = require('node:path');
-const { strictEqual, deepEqual } = require('node:assert');
+const { strictEqual, deepEqual } = assert;
 
 const filename = parse(basename(__filename)).name;
 const tempd = mkdtempSync(join(tmpdir(), `${filename}-`));
@@ -24,23 +26,28 @@ process.chdir(__dirname);
 
 async function main()
 {
+  const KVIN = require('dcp/internal/kvin')
   const { Keystore } = require('dcp/wallet');
   const ks = await new Keystore(null);
   const id = await new Keystore(null);
+  const testUrl = 'http://example.com';
 
   writeFileSync(`${tempd}/default.keystore`, JSON.stringify(ks.toJSON()), { encoding: 'utf-8' });
   writeFileSync(`${tempd}/id.keystore`, JSON.stringify(id.toJSON()), { encoding: 'utf-8' });
+  const args = [
+      '--unmanaged',
+      '--earnings-account=0x9fd0909Bd93f7bad915726C3AB499391384b8b4b',
+      '--no-global',
+      '--cores=3,1',
+      '--utilization=0.1,0.5',
+      '--max-sandboxes=5',
+      '--job=09fd0909Bd93f7bad915726C3AB4',
+      '--join=joinKey1,joinHash1', '-g', 'joinKey2,joinHash2',
+      '--show=config', '--kvin' ];
+
+  console.log('worker args:', args.join(' '));
   const res = spawnSync(
-    '../bin/dcp-worker', [
-      '--paymentAddress', '0x9fd0909Bd93f7bad915726C3AB499391384b8b4b',
-      '--leavePublicGroup',
-      '--allowedOrigins', 'test-url',
-      '--cores', '3,1',
-      '--utilization', '0.1,0.5',
-      '--maxSandboxes', '5',
-      '--job-id', '09fd0909Bd93f7bad915726C3AB4',
-      '--join', `joinKey1,joinHash1`, '-g', 'joinKey2,joinHash2',
-      '--showConfig' ],
+    '../bin/dcp-worker', args,
     {
       encoding: 'utf-8',
       env: {
@@ -49,20 +56,60 @@ async function main()
       }
     }
   );
-  
-  const confObj = JSON.parse(res.stdout);
-  strictEqual(confObj.paymentAddress, '0x9fd0909Bd93f7bad915726C3AB499391384b8b4b', `${confObj.paymentAddress} payment address is not corrrect`);
-  strictEqual(confObj.leavePublicGroup, true, `leaveComputeGroup is ${confObj.leavePublicGroup}`);
-  deepEqual(confObj.allowOrigins.any.includes('test-url'), true, `allowOrigins only includes ${confObj.allowOrigins.any}!`);
+
+  if (res.stderr)
+    res.stderr = res.stderr.replace(/^ *\*\*\* .*telnet daemon.*\n/,'').replace(/^ ! telnetd listening.*\n/,'');
+  if (res.stderr)
+    console.error('worker stderr:', res.stderr.replace(/\n$/,''));
+  console.log('worker stdout:', res.stdout.replace(/\n$/,''));
+  const confObj = KVIN.parse(res.stdout);
+  strictEqual(confObj.paymentAddress.valueOf(), '0x9fd0909Bd93f7bad915726C3AB499391384b8b4b', `${confObj.paymentAddress} payment address is not correct`);
+  strictEqual(confObj.leaveGlobalGroup, true, `leaveGlobalGroup is ${confObj.leaveGlobalGroup}`);
   deepEqual(confObj.cores, { cpu: 3, gpu: 1 }, `Mismatch in cores! cpu: ${confObj.cores.cpu}, gpu: ${confObj.cores.gpu}`);
   deepEqual(confObj.utilization, { cpu: 0.1, gpu: 0.5 }, `Mismatch in utilization! cpu: ${confObj.utilization.cpu}, gpu: ${confObj.utilization.gpu}`);
-  deepEqual(confObj.computeGroups, [{ joinKey: 'joinKey1', joinSecret: 'joinHash1' }, { joinKey: 'joinKey2', joinSecret: 'joinHash2' }], 'Mismatch in computeGroups')
+  deepEqual(confObj.computeGroups, { joinKey1: { joinKey: 'joinKey1', joinSecret: 'joinHash1' }, joinKey2: { joinKey: 'joinKey2', joinSecret: 'joinHash2' } }, 'Mismatch in computeGroups')
   deepEqual(confObj.maxSandboxes, 5, `Mismatch! maxSandboxes:${confObj.maxSandboxes}`);
   deepEqual(confObj.jobIds, ['09fd0909Bd93f7bad915726C3AB4'], `Mismatch  in job ids! jobIds:${confObj.jobIds}`);
 
+  const cgSpawn = spawnSync(
+    '../bin/dcp-worker', ['--unmanaged', '--show=compute-groups', '--kvin', '--no-global'],
+    {
+      encoding: 'utf-8',
+      env: {
+        ...process.env,
+        DCP_RESOURCE_DIR: tempd
+      }
+    }
+  );
+  if (cgSpawn.stderr)
+    cgSpawn.stderr = cgSpawn.stderr.replace(/^ *\*\*\* .*telnet daemon.*\n/,'').replace(/^ ! telnetd listening.*\n/,'');
+  if (cgSpawn.stderr)
+    console.error('worker stderr:', cgSpawn.stderr.replace(/\n$/,''));
+  console.log('worker stdout:', cgSpawn.stdout.replace(/\n$/,''));
+  const computeGroups = KVIN.parse(cgSpawn.stdout);
+  assert(!Object.values(computeGroups).find(cg => cg.joinKey === 'public'));
+
+  const allowedOriginsSpawn = spawnSync(
+    '../bin/dcp-worker', ['--unmanaged', '--show=allowed-origins', '--kvin', `--allow-origin=${testUrl}`],
+    {
+      encoding: 'utf-8',
+      env: {
+        ...process.env,
+        DCP_RESOURCE_DIR: tempd
+      }
+    }
+  );
+  if (allowedOriginsSpawn.stderr)
+    allowedOriginsSpawn.stderr = allowedOriginsSpawn.stderr.replace(/^ *\*\*\* .*telnet daemon.*\n/,'').replace(/^ ! telnetd listening.*\n/,'');
+  if (allowedOriginsSpawn.stderr)
+    console.error('worker stderr:', allowedOriginsSpawn.stderr.replace(/\n$/,''));
+  console.log('worker stdout:', allowedOriginsSpawn.stdout.replace(/\n$/,''));
+  const allowOrigins = KVIN.parse(allowedOriginsSpawn.stdout);
+  deepEqual(allowOrigins.every.any.includes(testUrl), true, `allowOrigins missing ${testUrl}; only includes [${allowOrigins.every.any}]!`);
+
   console.log('Done.');
 }
 
 require('dcp-client')
   .init()
-  .then(main);
+  .then(main);