hello-lights 0.3.6 → 0.3.8

package/README.md

@@ -34,9 +34,11 @@ $ hello-lights exec-file ./cmds.clj     # execute commands from a file
 $ hello-lights repl                     # start an interactive REPL
 $ hello-lights serve                    # start the HTTP server on port 9000
 $ hello-lights serve --port 3000        # start the HTTP server on a custom port
+$ hello-lights --selector http exec bounce 300   # execute via a remote server
+$ hello-lights --selector http --host http://myserver:3000 repl  # REPL via a remote server
 ```
 
-Use `--help` for the full list of options, including `--serial-num` to target a specific device and `--selector multi` to control multiple traffic lights at once.
+Use `--help` for the full list of options, including `--serial-num` to target a specific device, `--selector multi` to control multiple traffic lights at once, and `--selector http` to send commands to a remote hello-lights server.
 
 ### Library
 
@@ -95,9 +97,11 @@ $ npm run cli -- exec-file ./cmds.clj  # execute commands from a file
 $ npm run cli -- repl                  # start an interactive REPL
 $ npm run cli -- serve                 # start the HTTP server on port 9000
 $ npm run cli -- serve --port 3000     # start the HTTP server on a custom port
+$ npm run cli -- --selector http exec bounce 300   # execute via a remote server
+$ npm run cli -- --selector http --host http://myserver:3000 repl  # REPL via a remote server
 ```
 
-Use `--help` for the full list of options, including `--serial-num` to target a specific device and `--selector multi` to control multiple traffic lights at once.
+Use `--help` for the full list of options, including `--serial-num` to target a specific device, `--selector multi` to control multiple traffic lights at once, and `--selector http` to send commands to a remote hello-lights server.
 
 ## HTTP Server REST API
 

package/lib/cli/commander-options.js

@@ -1,6 +1,6 @@
 const chalk = require('chalk');
 const path = require('path');
-const {Commander} = require('..');
+const {Commander, RestCommander} = require('..');
 const {MetaFormatter, CodeFormatter} = require('..').commands;
 
 /////////////////////////////////////////////////////////////////
@@ -87,6 +87,9 @@ function resolveDeviceManager(options) {
 /////////////////////////////////////////////////////////////////
 
 function resolveCommander(options) {
+  if (options.selector === 'http') {
+    return new RestCommander({host: options.host, logger});
+  }
   return Commander[options.selector]({
     logger,
     formatter: new ChalkMetaFormatter(),
@@ -116,8 +119,13 @@ function define(yargs) {
     .option('selector', {
       alias: 's',
       describe: 'selector type to use',
-      choices: ['single', 'multi'],
-      default: 'single' });
+      choices: ['single', 'multi', 'http'],
+      default: 'single' })
+    .option('host', {
+      alias: 'H',
+      describe: 'server URL for --selector http',
+      default: 'http://localhost:9000',
+      type: 'string' });
 }
 
 /////////////////////////////////////////////////////////////////

package/lib/cli/repl-command.js

@@ -13,8 +13,8 @@ class CommanderRepl {
     this.manager = this.commander.manager;
   }
 
-  formatCommandNames() {
-    let names = this.commander.commandNames;
+  async formatCommandNames() {
+    let names = await this.commander.fetchCommandNames();
     let parts = ['  '];
     names.forEach((name, i) => {
       parts.push(`  ${name}`);
@@ -23,7 +23,7 @@ class CommanderRepl {
     return parts.join('');
   }
 
-  help(commandName) {
+  async help(commandName) {
     if (commandName === undefined) {
       this.logger.log([
         `Commands for the traffic light`,
@@ -34,30 +34,30 @@ class CommanderRepl {
         `> [command]`,
         `> { [... multi line command] }`,
         `  available commands:`,
-        this.formatCommandNames()
+        await this.formatCommandNames()
       ].join('\n'));
     } else {
-      this.commander.help(commandName);
+      await this.commander.help(commandName);
     }
   }
 
-  execute(text, context, filename, callback) {
+  async execute(text, context, filename, callback) {
     text = text.trim();
     let match;
     if (!text) {
     } else if (text === 'cancel') {
-      this.commander.cancel();
+      await this.commander.cancel();
     } else if (text === 'help') {
-      this.help();
+      await this.help();
     } else if (match = text.match(/^help\s+(.+)/)) { // eslint-disable-line no-cond-assign
-      this.help(match[1]);
+      await this.help(match[1]);
     } else if (text === 'exit' || text === 'quit') {
-      this.commander.cancel();
+      await this.commander.cancel();
       this.commander.close();
       this.logger.log('Bye');
       process.exit(0);
     } else if (text === 'check device') {
-      this.commander.logInfo();
+      await this.commander.logInfo();
     } else if (this.supportsNewDevice() && text === 'new device') {
       this.newDevice();
     } else if (text.startsWith('{')) {
@@ -84,7 +84,7 @@ class CommanderRepl {
   }
 
   supportsNewDevice() {
-    return !!this.manager.newDevice;
+    return !!this.manager && !!this.manager.newDevice;
   }
   newDevice() {
     this.manager.newDevice();

package/lib/cli/serve/index.js

@@ -18,8 +18,8 @@ function createApp(commander) {
     res.sendStatus(202);
   });
 
-  app.post('/cancel', (req, res) => {
-    commander.cancel();
+  app.post('/cancel', async (req, res) => {
+    await commander.cancel();
     res.sendStatus(200);
   });
 
@@ -28,8 +28,8 @@ function createApp(commander) {
     res.sendStatus(202);
   });
 
-  app.get('/commands', (req, res) => {
-    res.json(commander.commandNames);
+  app.get('/commands', async (req, res) => {
+    res.json(await commander.fetchCommandNames());
   });
 
   app.get('/commands/:name', (req, res) => {

package/lib/commander.js

@@ -89,7 +89,7 @@ class Commander {
   /**
    * Cancels any currently executing command.
    */
-  cancel() {
+  async cancel() {
     this.interpreter.cancel();
   }
 
@@ -248,11 +248,19 @@ class Commander {
     return this.interpreter.commands;
   }
 
+  /**
+   * Fetches all supported command names.
+   * @returns {Promise<string[]>} A promise that resolves with the command names.
+   */
+  async fetchCommandNames() {
+    return this.interpreter.commandNames;
+  }
+
   /**
    * Logs the help info for the given command name.
    * @param {string} commandName - Name of the command to log help info.
    */
-  help(commandName) {
+  async help(commandName) {
     let command = this.interpreter.lookup(commandName);
     if (!command) {
       this.logger.error(`Command not found: "${commandName}"`);
@@ -264,7 +272,7 @@ class Commander {
   /**
    * Logs information about known traffic lights.
    */
-  logInfo() {
+  async logInfo() {
     this.selector.logInfo(this.logger);
   }
 

package/lib/index.js

@@ -1,4 +1,5 @@
 const {Commander} = require('./commander');
+const {RestCommander} = require('./rest-commander');
 
 module.exports = {
   commands: require('./commands'),
@@ -6,5 +7,6 @@ module.exports = {
   physical: require('./physical'),
   devices: require('./devices'),
   selectors: require('./selectors'),
-  Commander
+  Commander,
+  RestCommander
 };

package/lib/rest-commander.js

@@ -0,0 +1,126 @@
+////////////////////////////////////////////////
+
+const http = require('http');
+const https = require('https');
+
+////////////////////////////////////////////////
+
+function request(baseUrl, method, path, body) {
+  return new Promise((resolve, reject) => {
+    let url = new URL(path, baseUrl);
+    let client = url.protocol === 'https:' ? https : http;
+    let options = {
+      method,
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname + url.search,
+      headers: {}
+    };
+    if (body != null) {
+      options.headers['Content-Type'] = 'text/plain';
+    }
+    let req = client.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => resolve({statusCode: res.statusCode, body: data}));
+    });
+    req.on('error', reject);
+    if (body != null) req.write(body);
+    req.end();
+  });
+}
+
+////////////////////////////////////////////////
+
+/**
+ * A Commander client that controls a traffic light via a remote REST API.
+ * Communicates with a server started by the `serve` command.
+ */
+class RestCommander {
+
+  /**
+   * Creates a new RestCommander instance.
+   * @param {object} [options] - Options.
+   * @param {string} [options.host='http://localhost:9000'] - The base URL of
+   *   the remote server (e.g. `http://localhost:9000`).
+   * @param {object} [options.logger=console] - A Console-like object for logging.
+   */
+  constructor({host = 'http://localhost:9000', logger = console} = {}) {
+    this.host = host.replace(/\/+$/, ''); // strip trailing slashes
+    this.logger = logger;
+  }
+
+  /**
+   * Executes a command on the remote server (fire-and-forget).
+   * @param {string} command - Command to execute.
+   * @param {boolean} [reset=false] - Whether to reset the traffic light first.
+   */
+  async run(command, reset = false) {
+    let path = reset ? '/run?reset=true' : '/run';
+    await request(this.host, 'POST', path, command);
+  }
+
+  /**
+   * Cancels any currently executing command on the remote server.
+   */
+  async cancel() {
+    await request(this.host, 'POST', '/cancel');
+  }
+
+  /**
+   * Executes definition-only commands on the remote server.
+   * @param {string} command - Command with definitions to execute.
+   */
+  async runDefinitions(command) {
+    await request(this.host, 'POST', '/definitions', command);
+  }
+
+  /**
+   * Fetches all available command names from the remote server.
+   * @returns {Promise<string[]>} Array of command names.
+   */
+  async fetchCommandNames() {
+    let res = await request(this.host, 'GET', '/commands');
+    return JSON.parse(res.body);
+  }
+
+  /**
+   * Logs the help info for the given command name from the remote server.
+   * @param {string} commandName - Name of the command.
+   */
+  async help(commandName) {
+    let res = await request(this.host, 'GET', `/commands/${encodeURIComponent(commandName)}`);
+    if (res.statusCode === 404) {
+      this.logger.error(res.body);
+    } else {
+      this.logger.log(res.body);
+    }
+  }
+
+  /**
+   * Logs information about known traffic lights from the remote server.
+   */
+  async logInfo() {
+    let res = await request(this.host, 'GET', '/info');
+    let devicesInfo = JSON.parse(res.body);
+    if (devicesInfo.length === 0) {
+      this.logger.log('No devices found');
+    } else {
+      this.logger.log('Known devices:');
+      devicesInfo.forEach(info =>
+        this.logger.log(`device ${info.serialNum}: ${info.status}`));
+    }
+  }
+
+  /**
+   * Closes this instance. No-op for REST client.
+   */
+  close() {}
+
+}
+
+////////////////////////////////////////////////
+
+module.exports = {RestCommander};
+
+////////////////////////////////////////////////

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hello-lights",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Commands to control a traffic light",
   "main": "index.js",
   "bin": {