things-js

#! /usr/bin/env node

var fs = require('fs');
var path = require('path');
var program = require('commander');
var jsBeautify = require('js-beautify').js_beautify;

program
  .version('0.0.1')
  .description('Framework for building IoT systems')

program
  .command('dashboard')
  .option('-c, --config <conf_path>', 'Config File Path')
  .alias('dash')
  .description('Start a Dashboard application')
  .action(function(options){
    var config = options.config ? require(options.config) : {};
    var startApp = require('../util/dashboard/startApp.js');
    startApp(config);
  });

program
  .command('worker <conf_path>')
  .option('-d, --debug', 'Set environment variable DEBUG to "true" and see debug output')
  .option('--statusLED', 'Set CodeEngine to indicate busy status on LED connected to GPIO (works only if device has GPIO)')
  .alias('engine')
  .description('Start a ThingsJS Worker')
  .action(function(conf_path, options){
    process.env['DEBUG'] = options.debug ? "true": "false";
    var CodeEngine = require('../lib/core/CodeEngine.js');
    var config = CodeEngine.validateConfig(conf_path);
    var engine = new CodeEngine(config, {
      enable_status_led: options.statusLED
    });
    process.on('SIGINT', function(){
      engine.kill().then(function(){
          process.exit();
        })
    });

  });

program
  .command('scheduler <conf_path>')
  .option('-s, --save <log_path>', 'File path to optionally log resource usage')
  .alias('sched')
  .description('Start a ThingsJS Scheduler')
  .action(function(conf_path, options){
    var CodeEngine = require('../lib/core/CodeEngine.js');
    var Scheduler = require('../lib/core/Scheduler.js');
    var config = CodeEngine.validateConfig(conf_path);
    // var engine = new things.CodeEngine(config);
    // console.log(options);
    var scheduler = new Scheduler(config, {
      log_path: options.save
    });
    process.on('SIGINT', function(){
      scheduler.kill().then(function(){
          process.exit();
        })
    });

  });

program
  .command('instrument <file_path>')
  .option('-p, --pubsub <pubsub_url>', 'Pubsub URL')
  .option('-s, --save <save_path>', 'File path to optionally save instrumented code')
  .option('-d, --debug', 'Set environment variable DEBUG to "true" and see debug output')
  .alias('inst')
  .description('Instrument raw JavaScript code to make it migrate-able')
  .action(function(file_path, options){
    process.env['DEBUG'] = options.debug ? "true": "false";
    var Code = require('../lib/core/Code.js');
    var pubsub = { url: (options.pubsub_url || 'mqtt://localhost') }; // use a dummy pubsub, no need to connect
    var code = Code.fromFile(pubsub, file_path);
    if (options.save) code.save(options.save);
    else console.log(code.source);
  });

program
  .command('restore <file_path>')
  .option('-s, --save <save_path>', 'File path to optionally save instrumented code')
  .option('-d, --debug', 'Set environment variable DEBUG to "true" and see debug output')
  .description('Instrument raw JavaScript code to make it migrate-able')
  .action(function(file_path, options){
    process.env['DEBUG'] = options.debug ? "true": "false";
    var Code = require('../lib/core/Code.js');
    var code = Code.fromSnapshotFile(file_path, true);
    if (options.save) code.save(options.save);
    else console.log(code.source);
  });

program
  .command('run <file_path>')
  .option('-r, --restore', 'Restore from snapshot and run')
  .option('-p, --pubsub <pubsub_url>', 'Pubsub URL')
  .option('-s, --save <save_path>', 'File path to optionally save instrumented code')
  .option('-d, --debug', 'Set environment variable DEBUG to "true" and see debug output')
  .option('-nr, --noReport', 'Turn off resource reporting')
  .description('Instrument and run raw JavaScript code.')
  .action(function(file_path, options){
    process.env['DEBUG'] = options.debug ? "true": "false";
    var Pubsub = require("../lib/core/Pubsub.js");
    var Code = require('../lib/core/Code.js');
    if (options.restore){
      var code = Code.fromSnapshotFile(file_path);
    }
    else {
      var pubsub = new Pubsub(options.pubsub_url || 'mqtt://localhost');
      var code = Code.fromFile(pubsub, file_path);
    }

    if (options.save) code.save(options.save);
    code.run({
      enableStats: !(options.noReport)
    })
    .then(function(instance){
      instance.on('finished', function(){
        code.kill();
        process.exit();
      })
      if(process.stdin.isTTY){
        process.stdin.setRawMode( true );
      }
      process.stdin.setEncoding('utf8');
      process.stdin.on('data', function(key){
        switch(key.trim()){
            case 'p':
                instance.pause();
                break;

            case 'r':
                instance.resume();
                break;

            case 's':
              instance.snapshot(true).then(function(snap){
                console.log(JSON.stringify(snap));
                // console.log(jsBeautify(JSON.stringify(snap)));
                instance.saveLastSnapshot(file_path+'.snap.json');
              })
              break;

            case 'q':
                code.kill();
                process.exit();
                break;

            case '\u0003':
                code.kill();
                process.exit();

            default:
                console.log(key);
        }

      });
    })
    
  });

program
  .command('dispatch <pubsub_url> <ctrl> [args...]')
  .description('Use the dispatcher to perform operations over the network such as running or migrating processes')
  .action(function(pubsub_url, ctrl, args){
    var Dispatcher = require('../lib/core/Dispatcher.js');
    var helpers = require('../lib/helpers.js');
    // console.log(pubsub_url, ctrl, args);
    var prepare = helpers.defer();

    switch(ctrl){
      case 'run':
        var engine_id = args[0];
        var file_path = args[1];
        if (engine_id && file_path){
          fs.readFile(file_path, function(err, data){
            if (err) prepare.reject({ reason: 'Error reading file at '+file_path});
            else {
              var source = data.toString();
              prepare.resolve({
                type: ctrl,
                args: [engine_id, path.basename(file_path), source]
              })
            }
          })  
        }
        else {
          prepare.reject({ reason: 'Invalid arguments for "run" command. It should be "run <engine_id> <local_file_path>"'});
        }
        break;
      case 'pause':
        if (args[0]){
          prepare.resolve({ type: ctrl, args: args })  
        }
        else {
          prepare.reject({ reason: 'Invalid argument for "'+ctrl+'" command. It should be "'+ctrl+' <process_id>"'})
        }
        break;
      case 'resume':
        if (args[0]){
          prepare.resolve({ type: ctrl, args: args })  
        }
        else {
          prepare.reject({ reason: 'Invalid argument for "'+ctrl+'" command. It should be "'+ctrl+' <process_id>"'})
        }
        break;
      case 'kill':
        if (args[0]){
          prepare.resolve({ type: ctrl, args: args })  
        }
        else {
          prepare.reject({ reason: 'Invalid argument for "'+ctrl+'" command. It should be "'+ctrl+' <process_id>"'})
        }
        break;
      case 'migrate':
        var from_id = args[0];
        var to_id = args[1];
        var code_name = args[2];
        var proc_id = args[3];
        if (from_id && to_id && code_name && proc_id){
          prepare.resolve({ type: ctrl, args: args });
        }
        else {
          prepare.reject({ reason: 'Invalid arguments for "migrate" command. It should be "run <from_engine_id> <to_engine_id> <code_name> <process_id>"'});
        }
        break;
      default:
        console.log('Invalid <ctrl> argument. It should be one of: run, pause, resume, kill, migrate')
        break;
    }

    prepare.promise.then(function(action){
      var dispatcher = new Dispatcher({ pubsub_url: pubsub_url });
      var apply = helpers.defer();
      dispatcher.on('ready', function(){
        setTimeout(function(){
          dispatcher.applyActions([action])
            .then(function(results){
              apply.resolve({ dispatcher: dispatcher, result: results[0] });
            }).catch(function(error){
              apply.reject(error);
            })
        }, 500); // Giving 500 ms timeout to ensure the target engine is discovered by the Dispatcher
      });
      return apply.promise;
    }).catch(function(error){
      console.log(error.reason);
      process.exit(1);
    }).then(function(data){
      console.log(data.result);
      data.dispatcher.kill();
    })
  });

program
  .command('pubsub')
  .option('-p, --port <port>', 'Port to Listen to')
  .option('-d, --debug', 'Set environment variable DEBUG to "true" and see debug output')
  .description('Start a Pubsub Server')
  .action(function(options){
    process.env['DEBUG'] = options.debug ? "true": "false";
    var Pubsub = require('../lib/core/Pubsub.js');
    var server = new Pubsub.Server();
    process.on('SIGINT', function(){
      server.kill().then(function(){
          process.exit();
        })
    });

  });

program
  .command('debug <action> [args...]')
  .description('Use Debug Commands')
  .action(function(action, args){
    var Pubsub = require('../lib/core/Pubsub.js');
    var pubsub = new Pubsub('mqtt://localhost');
    pubsub.on('ready', function(){
      console.log(args);
      pubsub.publish(args[0], JSON.parse(args[1]))
        .then(function(){
          pubsub.kill()
            .then(function(){
              process.exit();
            })
        })
    })
  });

program.parse(process.argv);
if (process.argv.length === 2){
  var Shell = require('../lib/util/Shell.js');
  var shell = new Shell;
}