pooliot-client/lib-node6/cli/install/run.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _child_process = require('child_process');

var _path = require('path');

var _inquirer = require('inquirer');

var _config = require('../../config');

var _config2 = _interopRequireDefault(_config);

var _createSystemdService = require('./createSystemdService');

var _createSystemdService2 = _interopRequireDefault(_createSystemdService);

var _createConfigFile = require('./createConfigFile');

var _createConfigFile2 = _interopRequireDefault(_createConfigFile);

var _detectBoard = require('../../main-process/utils/detectBoard');

var _detectBoard2 = _interopRequireDefault(_detectBoard);

var _parseHostPort = require('../../main-process/utils/parseHostPort');

var _parseHostPort2 = _interopRequireDefault(_parseHostPort);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } /* eslint-disable no-implied-eval */


exports.default = (() => {
  var _ref = _asyncToGenerator(function* (options, pkg) {
    const board = (0, _detectBoard2.default)();

    if (process.env.USER !== 'root') {
      throw new Error('The install script must be run with root user. Use : sudo pooliot-client install');
    }

    options = {
      webPort: options.webPort || _config2.default.WEB_PORT || 80,
      address: options.address || _config2.default.ADDRESS,
      token: options.token || _config2.default.TOKEN,
      user: options.user !== 'root' && options.user || _config2.default.USER,
      interactive: options.interactive
    };

    const defaults = Object.assign({}, options, {
      user: options.user || board.user
    });

    const answers = yield (0, _inquirer.prompt)([{
      type: 'input',
      name: 'address',
      message: 'Address (https://host:port)',
      when: !options.address,
      default: defaults.address,
      validate: function (address) {
        if (!address) return 'address cannot be empty';
        const [host, port] = (0, _parseHostPort2.default)(address);
        if (!host) return 'host is invalid';
        if (!port || !Number.isInteger(Number(port))) return 'port must be an integer';
        return true;
      }
    }, {
      type: 'input',
      name: 'token',
      message: 'Token',
      when: !options.token,
      default: defaults.token
    }, {
      type: 'input',
      name: 'user',
      message: 'User',
      when: Boolean(options.interactive && !defaults.user),
      default: defaults.user,
      validate: function (user) {
        if (!user) return 'user must be provided';
        if (user === 'root') return 'root is not allowed';
        return true;
      }
    }, {
      type: 'confirm',
      name: 'useDisplay',
      message: 'Use your device for display ?',
      default: true,
      when: Boolean(options.interactive)
    }, {
      type: 'checkbox',
      name: 'displays',
      message: 'What displays do you want to install ?',
      choices: [{ value: 'chromium', name: 'chromium: a web browser', checked: true }, { value: 'firefox', name: 'firefox: a web browser' }, {
        value: 'livestreamer',
        name: 'livestreamer: video streams - http://docs.livestreamer.io/',
        checked: true
      }, board.os.id === 'raspbian' && {
        value: 'omxplayer',
        name: 'omxplayer: video player - https://github.com/popcornmix/omxplayer',
        checked: true
      }].filter(Boolean),
      when: function (answers) {
        return options.interactive && answers.useDisplay;
      }
    }]);

    const { address, token, user, useDisplay, displays } = Object.assign({}, defaults, answers);

    console.log(`Add user ${user} if missing`);
    try {
      (0, _child_process.execSync)(`useradd ${user} --create-home`, { stdio: 'inherit' });
    } catch (err) {}

    const clientDirectory = (0, _path.dirname)((0, _path.dirname)((0, _path.dirname)(__dirname)));
    const scriptsDirectory = `${clientDirectory}/scripts/install/`;

    const execScript = function (script) {
      return (0, _child_process.execSync)(`sh ${script}.sh`, {
        stdio: 'inherit',
        cwd: scriptsDirectory,
        env: Object.assign({}, process.env, { POOLIOT_USER: user })
      });
    };

    execScript('essentials');

    if (board.id === 'rpi' && board.os.id === 'raspbian') {
      execScript('raspbian/prepare');
    } else if (board.id === 'tkb') {
      // TODO detect tinker os
      execScript('tinker-os/prepare');
    }

    if (useDisplay) {
      execScript('display/essentials', {
        env: { BOARD_ID: board.id }
      });

      displays.forEach(function (display) {
        execScript(`display/${display}`);
      });
    }

    console.log(`Write /etc/systemd/system/${pkg.name}.service`);
    (0, _createSystemdService2.default)(clientDirectory, pkg);
    (0, _createConfigFile2.default)({ address, token, user, webPort: options.webPort });

    console.log('Enable and start systemctl service');
    (0, _child_process.execSync)(`systemctl enable ${pkg.name}`, { stdio: 'inherit' });
    (0, _child_process.execSync)(`systemctl start ${pkg.name}`, { stdio: 'inherit' });

    if (options.interactive) {
      const confirmReboot = yield (0, _inquirer.prompt)([{
        type: 'confirm',
        name: 'reboot',
        message: 'reboot ?'
      }]);

      if (confirmReboot.reboot) {
        (0, _child_process.execSync)('reboot');
      }
    }
  });

  return function () {
    return _ref.apply(this, arguments);
  };
})();
//# sourceMappingURL=run.js.map