@zappinginc/zm2 6.0.14

package/lib/API/Configuration.js

@@ -0,0 +1,212 @@
+
+var Common               = require('../Common.js');
+var cst                  = require('../../constants.js');
+var UX                   = require('./UX');
+var chalk                = require('ansis');
+var Configuration        = require('../Configuration.js');
+
+module.exports = function(CLI) {
+
+  CLI.prototype.get = function(key, cb) {
+    var that = this;
+
+    if (!key || key == 'all') {
+      displayConf(function(err, data) {
+        if (err)
+          return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
+        return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT);
+      });
+      return false;
+    }
+    Configuration.get(key, function(err, data) {
+      if (err) {
+        return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
+      }
+      // pm2 conf module-name
+      if (key.indexOf(':') === -1 && key.indexOf('.') === -1) {
+        displayConf(key, function() {
+          console.log('Modules configuration. Copy/Paste line to edit values.')
+          return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT)
+        });
+        return false;
+      }
+      // pm2 conf module-name:key
+      var module_name, key_name;
+
+      if (key.indexOf(':') > -1) {
+        module_name = key.split(':')[0];
+        key_name    = key.split(':')[1];
+      } else if (key.indexOf('.') > -1) {
+        module_name = key.split('.')[0];
+        key_name    = key.split('.')[1];
+      }
+
+      Common.printOut('Value for module ' + chalk.blue(module_name), 'key ' + chalk.blue(key_name) + ': ' + chalk.bold.green(data));
+
+
+      return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT);
+    });
+  };
+
+  CLI.prototype.set = function(key, value, cb) {
+    var that = this;
+
+    if (!key) {
+      interactiveConfigEdit(function(err) {
+        if (err)
+          return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
+        return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT);
+      });
+      return false;
+    }
+
+    /**
+     * Set value
+     */
+    Configuration.set(key, value, function(err) {
+      if (err)
+        return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
+
+      var values = [];
+
+      if (key.indexOf('.') > -1)
+        values = key.split('.');
+
+      if (key.indexOf(':') > -1)
+        values = key.split(':');
+
+      if (values && values.length > 1) {
+        // The first element is the app name (module_conf.json)
+        var app_name = values[0];
+
+        process.env.PM2_PROGRAMMATIC = 'true';
+        that.restart(app_name, {
+          updateEnv : true
+        }, function(err, data) {
+          process.env.PM2_PROGRAMMATIC = 'false';
+          if (!err)
+            Common.printOut(cst.PREFIX_MSG + 'Module %s restarted', app_name);
+          Common.log('Setting changed')
+          displayConf(app_name, function() {
+            return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT);
+          });
+        });
+        return false;
+      }
+      displayConf(null, function() {
+        return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT);
+      });
+    });
+  };
+
+  CLI.prototype.multiset = function(serial, cb) {
+    var that = this;
+
+    Configuration.multiset(serial, function(err, data) {
+      if (err)
+        return cb ? cb({success:false, err:err}) : that.exitCli(cst.ERROR_EXIT);
+
+      var values = [];
+      var key = serial.match(/(?:[^ "]+|"[^"]*")+/g)[0];
+
+      if (key.indexOf('.') > -1)
+        values = key.split('.');
+
+      if (key.indexOf(':') > -1)
+        values = key.split(':');
+
+      if (values && values.length > 1) {
+        // The first element is the app name (module_conf.json)
+        var app_name = values[0];
+
+        process.env.PM2_PROGRAMMATIC = 'true';
+        that.restart(app_name, {
+          updateEnv : true
+        }, function(err, data) {
+          process.env.PM2_PROGRAMMATIC = 'false';
+          if (!err)
+            Common.printOut(cst.PREFIX_MSG + 'Module %s restarted', app_name);
+          displayConf(app_name, function() {
+            return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT)
+          });
+        });
+        return false;
+      }
+      displayConf(app_name, function() {
+        return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT)
+      });
+    });
+  };
+
+  CLI.prototype.unset = function(key, cb) {
+    var that = this;
+
+    Configuration.unset(key, function(err) {
+      if (err) {
+        return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
+      }
+
+      displayConf(function() { cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT) });
+    });
+  };
+
+  CLI.prototype.conf = function(key, value, cb) {
+    var that = this;
+
+    if (typeof(value) === 'function') {
+      cb = value;
+      value = null;
+    }
+
+    // If key + value = set
+    if (key && value) {
+      that.set(key, value, function(err) {
+        if (err)
+          return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
+        return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT);
+      });
+    }
+    // If only key = get
+    else if (key) {
+      that.get(key, function(err, data) {
+        if (err)
+          return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
+        return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT);
+      });
+    }
+    else {
+      interactiveConfigEdit(function(err) {
+        if (err)
+          return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
+        return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT);
+      });
+    }
+  };
+
+};
+
+function interactiveConfigEdit(cb) {
+  UX.helpers.openEditor(cst.PM2_MODULE_CONF_FILE, function(err, data) {
+    Common.printOut(chalk.bold('Module configuration (%s) edited.'), cst.PM2_MODULE_CONF_FILE);
+    Common.printOut(chalk.bold('To take changes into account, please restart module related.'), cst.PM2_MODULE_CONF_FILE);
+    if (err)
+      return cb(Common.retErr(err));
+    return cb(null, {success:true});
+  });
+
+}
+
+/**
+ * Configuration
+ */
+function displayConf(target_app, cb) {
+  if (typeof(target_app) == 'function') {
+    cb = target_app;
+    target_app = null;
+  }
+
+  Configuration.getAll(function(err, data) {
+    UX.helpers.dispKeys(data, target_app);
+    return cb();
+  });
+}

package/lib/API/Containerizer.js

@@ -0,0 +1,335 @@
+
+var spawn   = require('child_process').spawn;
+var exec    = require('child_process').exec;
+var chalk   = require('ansis');
+var util    = require('util');
+var fmt     = require('../tools/fmt.js');
+var fs      = require('fs');
+var path    = require('path');
+var cst     = require('../../constants.js');
+var Promise = require('../tools/promise.min.js');
+
+function pspawn(cmd) {
+  return new Promise(function(resolve, reject) {
+    var p_cmd = cmd.split(' ');
+
+    var install_instance = spawn(p_cmd[0], p_cmd.splice(1, cmd.length), {
+      stdio : 'inherit',
+      env : process.env,
+      shell : true
+    });
+
+    install_instance.on('close', function(code) {
+      if (code != 0) {
+        console.log(chalk.bold.red('Command failed'));
+        return reject(new Error('Bad cmd return'));
+      }
+      return resolve();
+    });
+
+    install_instance.on('error', function (err) {
+      return reject(err);
+    });
+  });
+}
+
+function checkDockerSetup() {
+  return new Promise(function(resolve, reject) {
+    exec("docker version -f '{{.Client.Version}}'", function(err, stdout, stderr) {
+      if (err) {
+        console.error(chalk.red.bold('[Docker access] Error while trying to use docker command'));
+        if (err.message && err.message.indexOf('Cannot connect to the Docker') > -1) {
+          console.log();
+          console.log(chalk.blue.bold('[Solution] Setup Docker to be able to be used without sudo rights:'));
+          console.log(chalk.bold('$ sudo groupadd docker'));
+          console.log(chalk.bold('$ sudo usermod -aG docker $USER'));
+          console.log(chalk.bold('Then LOGOUT and LOGIN your Linux session'));
+          console.log('Read more: http://bit.ly/29JGdCE');
+        }
+        return reject(err);
+      }
+      return resolve();
+    });
+  });
+}
+
+/**
+ * Switch Dockerfile mode
+ * check test/programmatic/containerizer.mocha.js
+ */
+function parseAndSwitch(file_content, main_file, opts) {
+  var lines = file_content.split('\n');
+  var mode = opts.mode;
+
+  lines[0] = 'FROM keymetrics/pm2:' + opts.node_version;
+
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+
+    if (['## DISTRIBUTION MODE', '## DEVELOPMENT MODE'].indexOf(line) > -1 ||
+        i == lines.length - 1) {
+      lines.splice(i, lines.length);
+      lines[i] = '## ' + mode.toUpperCase() + ' MODE';
+      lines[i + 1] = 'ENV NODE_ENV=' + (mode == 'distribution' ? 'production' : mode);
+
+      if (mode == 'distribution') {
+        lines[i + 2] = 'COPY . /var/app';
+        lines[i + 3] = 'CMD ["pm2-docker", "' + main_file + '", "--env", "production"]';
+      }
+      if (mode == 'development') {
+        lines[i + 2] = 'CMD ["pm2-dev", "' + main_file + '", "--env", "development"]';
+      }
+      break;
+    }
+  };
+  lines = lines.join('\n');
+  return lines;
+};
+
+/**
+ * Replace ENV, COPY and CMD depending on the mode
+ * @param {String} docker_filepath Dockerfile absolute path
+ * @param {String} main_file       Main file to start in container
+ * @param {String} mode            Mode to switch the Dockerfile
+ */
+function switchDockerFile(docker_filepath, main_file, opts) {
+  return new Promise(function(resolve, reject) {
+    var data  = fs.readFileSync(docker_filepath, 'utf8').toString();
+
+    if (['distribution', 'development'].indexOf(opts.mode) == -1)
+      return reject(new Error('Unknown mode'));
+
+    var lines = parseAndSwitch(data, main_file, opts)
+    fs.writeFile(docker_filepath, lines, function(err) {
+      if (err) return reject(err);
+      resolve({
+        Dockerfile_path : docker_filepath,
+        Dockerfile : lines,
+        CMD : ''
+      });
+    })
+  });
+}
+
+/**
+ * Generate sample Dockerfile (lib/templates/Dockerfiles)
+ * @param {String} docker_filepath Dockerfile absolute path
+ * @param {String} main_file       Main file to start in container
+ * @param {String} mode            Mode to switch the Dockerfile
+ */
+function generateDockerfile(docker_filepath, main_file, opts) {
+  return new Promise(function(resolve, reject) {
+    var tpl_file = path.join(cst.TEMPLATE_FOLDER, cst.DOCKERFILE_NODEJS);
+    var template = fs.readFileSync(tpl_file, {encoding: 'utf8'});
+    var CMD;
+
+    template = parseAndSwitch(template, main_file, opts);
+
+    fs.writeFile(docker_filepath, template, function(err) {
+      if (err) return reject(err);
+      resolve({
+        Dockerfile_path : docker_filepath,
+        Dockerfile : template,
+        CMD : CMD
+      });
+    });
+  });
+}
+
+function handleExit(CLI, opts, mode) {
+  process.on('SIGINT', function() {
+    CLI.disconnect();
+
+    if (mode != 'distribution')
+      return false;
+
+    exec('docker ps -lq', function(err, stdout, stderr) {
+      if (err) {
+        console.error(err);
+      }
+      require('vizion').analyze({folder : process.cwd()}, function recur_path(err, meta){
+        if (!err && meta.revision) {
+          var commit_id = util.format('#%s(%s) %s',
+                                      meta.branch,
+                                      meta.revision.slice(0, 5),
+                                      meta.comment);
+
+          console.log(chalk.bold.magenta('$ docker commit -m "%s" %s %s'),
+                      commit_id,
+                      stdout.replace('\n', ''),
+                      opts.imageName);
+        }
+        else
+          console.log(chalk.bold.magenta('$ docker commit %s %s'), stdout.replace('\n', ''), opts.imageName);
+
+        console.log(chalk.bold.magenta('$ docker push %s'), opts.imageName);
+      });
+    });
+  });
+}
+
+module.exports = function(CLI) {
+  CLI.prototype.generateDockerfile = function(script, opts) {
+    var docker_filepath = path.join(process.cwd(), 'Dockerfile');
+    var that = this;
+
+    fs.stat(docker_filepath, function(err, stat) {
+      if (err || opts.force == true) {
+        generateDockerfile(docker_filepath, script, {
+          mode : 'development'
+        })
+          .then(function() {
+            console.log(chalk.bold('New Dockerfile generated in current folder'));
+            console.log(chalk.bold('You can now run\n$ pm2 docker:dev <file|config>'));
+            return that.exitCli(cst.SUCCESS_EXIT);
+          });
+        return false;
+      }
+      console.log(chalk.red.bold('Dockerfile already exists in this folder, use --force if you want to replace it'));
+      that.exitCli(cst.ERROR_EXIT);
+    });
+  };
+
+  CLI.prototype.dockerMode = function(script, opts, mode) {
+    var promptly = require('promptly');
+    var self = this;
+    handleExit(self, opts, mode);
+
+    if (mode == 'distribution' && !opts.imageName) {
+      console.error(chalk.bold.red('--image-name [name] option is missing'));
+      return self.exitCli(cst.ERROR_EXIT);
+    }
+
+    var template;
+    var app_path, main_script;
+    var image_name;
+    var node_version = opts.nodeVersion ? opts.nodeVersion.split('.')[0] : 'latest';
+
+    image_name   = opts.imageName || require('crypto').randomBytes(6).toString('hex');
+
+    if (script.indexOf('/') > -1) {
+      app_path  = path.join(process.cwd(), path.dirname(script));
+      main_script = path.basename(script);
+    }
+    else {
+      app_path  = process.cwd();
+      main_script = script;
+    }
+
+    checkDockerSetup()
+      .then(function() {
+        /////////////////////////
+        // Generate Dockerfile //
+        /////////////////////////
+        return new Promise(function(resolve, reject) {
+          var docker_filepath = path.join(process.cwd(), 'Dockerfile');
+
+          fs.stat(docker_filepath, function(err, stat) {
+            if (err) {
+              // Dockerfile does not exist, generate one
+              // console.log(chalk.blue.bold('Generating new Dockerfile'));
+              if (opts.force == true) {
+                return resolve(generateDockerfile(docker_filepath, main_script, {
+                  node_version : node_version,
+                  mode : mode
+                }));
+              }
+              if (opts.dockerdaemon)
+                return resolve(generateDockerfile(docker_filepath, main_script, {
+                    node_version : node_version,
+                    mode : mode
+                  }));
+              promptly.prompt('No Dockerfile in current directory, ok to generate a new one? (y/n)', function(err, value) {
+                if (value == 'y')
+                  return resolve(generateDockerfile(docker_filepath, main_script, {
+                    node_version : node_version,
+                    mode : mode
+                  }));
+                else
+                  return self.exitCli(cst.SUCCESS_EXIT);
+              });
+              return false;
+            }
+            return resolve(switchDockerFile(docker_filepath, main_script, {
+              node_version : node_version,
+              mode : mode
+            }));
+          });
+        });
+      })
+      .then(function(_template) {
+        template = _template;
+        return Promise.resolve();
+      })
+      .then(function() {
+        //////////////////
+        // Docker build //
+        //////////////////
+
+        var docker_build = util.format('docker build -t %s -f %s',
+                                       image_name,
+                                       template.Dockerfile_path);
+
+        if (opts.fresh == true)
+          docker_build += ' --no-cache';
+        docker_build += ' .';
+
+        console.log();
+        fmt.sep();
+        fmt.title('Building Boot System');
+        fmt.field('Type', chalk.cyan.bold('Docker'));
+        fmt.field('Mode', mode);
+        fmt.field('Image name', image_name);
+        fmt.field('Docker build command', docker_build);
+        fmt.field('Dockerfile path', template.Dockerfile_path);
+        fmt.sep();
+
+        return pspawn(docker_build);
+      })
+      .then(function() {
+        ////////////////
+        // Docker run //
+        ////////////////
+
+        var docker_run = 'docker run --net host';
+
+        if (opts.dockerdaemon == true)
+          docker_run += ' -d';
+        if (mode != 'distribution')
+          docker_run += util.format(' -v %s:/var/app -v /var/app/node_modules', app_path);
+        docker_run += ' ' + image_name;
+        var dockerfile_parsed = template.Dockerfile.split('\n');
+        var base_image = dockerfile_parsed[0];
+        var run_cmd = dockerfile_parsed[dockerfile_parsed.length - 1];
+
+        console.log();
+        fmt.sep();
+        fmt.title('Booting');
+        fmt.field('Type', chalk.cyan.bold('Docker'));
+        fmt.field('Mode', mode);
+        fmt.field('Base Image', base_image);
+        fmt.field('Image Name', image_name);
+        fmt.field('Docker Command', docker_run);
+        fmt.field('RUN Command', run_cmd);
+        fmt.field('CWD', app_path);
+        fmt.sep();
+        return pspawn(docker_run);
+      })
+      .then(function() {
+        console.log(chalk.blue.bold('>>> Leaving Docker instance uuid=%s'), image_name);
+        self.disconnect();
+        return Promise.resolve();
+      })
+      .catch(function(err) {
+        console.log();
+        console.log(chalk.gray('Raw error=', err.message));
+        self.disconnect();
+      });
+
+  };
+
+};
+
+module.exports.generateDockerfile = generateDockerfile;
+module.exports.parseAndSwitch     = parseAndSwitch;
+module.exports.switchDockerFile   = switchDockerFile;