pooliot-client/src/cli/install/run.js

pooliot client

/* eslint-disable no-implied-eval */
import { execSync } from 'child_process';
import { dirname } from 'path';
import { prompt } from 'inquirer';
import createSystemdService from './createSystemdService';
import detectBoard from '../../main-process/utils/detectBoard';
import parseHostPort from '../../main-process/utils/parseHostPort';

export default async (options, pkg) => {
  const board = detectBoard();

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

  const defaults = {
    ...options,
    user: (options.user !== 'root' && options.user) || board.user,
  };
  const webPort = options.webPort || 80;

  const answers = await prompt([
    {
      type: 'input',
      name: 'address',
      message: 'Address (https://host:port)',
      when: !options.address,
      default: defaults.address,
      validate: address => {
        if (!address) return 'address cannot be empty';
        const [host, port] = parseHostPort(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: !options.user,
      default: defaults.user,
      validate: 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: 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: answers => options.interactive && answers.useDisplay,
    },
  ]);

  const { address, token, user, useDisplay, displays } = { ...defaults, ...answers };

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

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

  const execScript = script =>
    execSync(`sh ${script}.sh`, {
      stdio: 'inherit',
      cwd: scriptsDirectory,
      env: { ...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(display => {
      execScript(`display/${display}`);
    });
  }

  console.log(`Write /etc/systemd/system/${pkg.name}.service`);
  createSystemdService(clientDirectory, pkg, { address, token, user, webPort });

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

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

    if (confirmReboot.reboot) {
      execSync('reboot');
    }
  }
};