@pradyumn-el/pollycli/src/main.js

pollycli lets users access the functionalities of Polly over a command line interface

import { parseArgumentsIntoOptions, promptForMissingValues } from './init';
import { login,  isAlreadyLoggedIn, logout, whoami }from './auth';
import { submitJob, displayJobStatus, cancelJob } from './job';
import { helpSection } from './help';
import { listPollyProjects, createProject } from './projects'
import { getJobLogs } from './logs';
import { syncFiles, listFiles, copyFile } from './files';
import { dockerLoginCommand, createADockerRepo, listAllDockerRepos, listAllDockerCommits, dockerLogoutCommand, updateDockerRepo, dockerBuild, dockerBuildStatus } from './docker';
import { appAdd, appUpdate, getAppsList, getLogList, sampleAppFile } from './apps';
import { generateNotebookTemplate, notebookDockerBuild, notebookTestScript, notebookDockerBuildStatus} from './notebooks';
import { buildStudioComponent, componentBuildStatus, generateStudioComponentTemplate } from './studio';
const os = require('os');
const path = require('path');
const pollymsg = require('./message');
import { Store } from 'data-store';
import { createEnvironment, removeEnvironment, updateEnvironment, sampleEnvFormat } from './jupyter-env';
import { deleteWorkflow, getWorkflow, getWorkflowLogs, submitWorkflow } from './workflows';
import { installExtraDependencies, awsIsPresent } from '../scripts/downloader';

/**
 * This is the starting point of this CLI script
 * @param {*} args 
 */
export async function main(args) {

  global.pollystore = new Store(
    { path: path.join(os.homedir(), '.config/pollycli/credentials.json') }
  );

  let options = await parseArgumentsIntoOptions(args);
  await helpSection(options);
  options = await promptForMissingValues(options);

  if(options.type === 'files') {
    try {
      if(!awsIsPresent()) {
        /*
         * Install aws-cli. This is a one time setup. On a successful install, this
         * step won't be performed. The installation should happen as silently as
         * possible
        */
        const update = false
        await installExtraDependencies(update);
      }
    } catch (err) {}
  }

  // When the user login login the user and exit
  if (options.type == 'user-management' && options.action == 'login') {
    const islogged = await login(options.creds.username, options.creds.password);
    if (islogged) {
      pollymsg.pollyMessage("Use the command polly --help to learn how to use the CLI");
      process.exit(0);
    }
  }

  if (options.type == 'user-management' && options.action == 'logout') {
    const isout= await logout();
    if (isout) {
      pollymsg.pollyMessage("Adios, see you soon!");
      process.exit(0);
    }
  }

  if (options.type == 'user-management' && options.action == 'whoami') {
    await whoami();
  }

  // If the user is not logging in but is trying to use other cli facilities
  // check if the user is logged in if not logged in refresh with refresh token
  if (!await isAlreadyLoggedIn()) {
    process.exit(1);
  }

  if (options.type == 'workspaces' && options.action == 'list') {
    let type = null;
    let value = null;
    if(options.latest) {
      type = 'latest'
      value = options.latest;
    } else if(options.oldest) {
      type = 'oldest'
      value = options.oldest;
    }  else if (options.all){
      type = 'all'
      value = true;
    } else {
      pollymsg.pollyError("Unknown option for workspaces");
    }
    await listPollyProjects(type, value);
    process.exit(0);
  }

  if (options.type == 'workspaces' && options.action == 'create') {
    await createProject(options.workspace_name, options.workspace_description);
    process.exit(0);
  }

  // Now the busness logic goes from here
  if (options.type == 'jobs' && options.action == 'submit') {
    await submitJob(options.workspace_id, options.job_file);
    process.exit(0);
  }

  if (options.type == 'jobs' && options.action == 'status' && options.workspace_id) {
    await displayJobStatus(options.workspace_id, options.job_id);
    process.exit(0);
  }

  if (options.type == 'jobs' && options.action == 'logs' && options.workspace_id && options.workspace_id) {
    await getJobLogs(options.workspace_id, options.job_id, 'all', options.attempt_num);
    process.exit(0);
  }

  if (options.type == 'jobs' && options.action == 'cancel' && options.workspace_id && options.workspace_id) {
    await cancelJob(options.workspace_id, options.job_id);
    process.exit(0);
  }

  if (options.type == 'files' && options.action == 'sync') {
    if(global.verbose) {
      options.verbose = true
    }

    await syncFiles(options.workspace_id, options.source_path, 
      options.destination_path, options.verbose, {"is_report": options.is_report});
  }

  if (options.type == 'files' && options.action == 'list') {
    await listFiles(options.workspace_id, options.workspace_path);
  }

  if (options.type == 'files' && options.action == 'copy') {
    await copyFile(options.workspace_id.toString(), options.source_path,
      options.destination_path, {"is_report": options.is_report});
  }

  if (options.type == 'dockers' && options.action == 'login') {
    await dockerLoginCommand();
    process.exit(0);
  }

  if (options.type == 'dockers' && options.action == 'logout') {
    await dockerLogoutCommand();
    process.exit(0);
  }

  if (options.type == 'dockers' && options.action == 'create' && options.name && options.description) {
    await createADockerRepo(options.name, options.description, options.public);
    process.exit(0);
  }

  if (options.type == 'dockers' && options.action == 'update' && options.name) {
    await updateDockerRepo(options.name, options.public);
    process.exit(0);
  }

  if (options.type == 'dockers' && options.action == 'list') {
    await listAllDockerRepos(options.own, options.public, options.all);
    process.exit(0);
  }

  if (options.type == 'dockers' && options.action == 'commit-list' && options.name) {
    await listAllDockerCommits(options.name);
    process.exit(0);
  }

  if (options.type == 'dockers' && options.action == 'build' && options.name && options.path) {
    await dockerBuild(options.name, options.path);
    process.exit(0);
  }

  if (options.type == 'dockers' && options.action == 'build-status') {
    await dockerBuildStatus(options.id);
    process.exit(0);
  }

  if (options.type == 'notebooks' && options.action == 'build') {
    await notebookDockerBuild(".");
    process.exit(0);
  }

  if (options.type == 'notebooks' && options.action == 'build-status' && options.id) {
    await notebookDockerBuildStatus(options.id);
    process.exit(0);
  }

  if (options.type == 'notebooks' && options.action == 'new-environment' && options.name && options.env_type) {
    await generateNotebookTemplate(options.env_type, options.name);
    process.exit(0);
  }

  if (options.type == 'notebooks' && options.action == 'test') {
    await notebookTestScript();
    process.exit(0);
  }

  if (options.type == 'apps' && options.action == 'logs' && options.run_id) {
    await getLogList(options.run_id, options.log_id);
    process.exit(0);
  }

  if (options.type == 'apps' && options.action == 'list') {
    await getAppsList(options.run_id, options.log_id);
    process.exit(0);
  }

  if (options.type == 'apps' && options.action == 'update') {
    await appUpdate(options.name, options.app_file, options.app_info);
    process.exit(0);
  }

  if (options.type == 'apps' && options.action == 'create') {
    await appAdd(options.app_file, options.app_info);
    process.exit(0);
  }

  if (options.type == 'apps' && options.action == 'sample') {
    sampleAppFile();
    process.exit(0);
  }
  
  // if (options.type == 'studio' && options.action == 'build-component') {
  //   await buildStudioComponent(".");
  //   process.exit(0);
  // }

  // if (options.type == 'studio' && options.action == 'component-build-status' && options.id) {
  //   await componentBuildStatus(options.id);
  //   process.exit(0);
  // }

  // if (options.type == 'studio' && options.action == 'new-component' && options.item_type) {
  //   await generateStudioComponentTemplate(options.item_type, options.name);
  //   process.exit(0);
  // }

  if (options.type == 'environment' && options.action == 'create') {
    await createEnvironment(options.env_file, options.env_info);
    process.exit(0);
  }

  if (options.type == 'environment' && options.action == 'update') {
    await updateEnvironment(options.env_name, options.env_info);
    process.exit(0);
  }

  if (options.type == 'environment' && options.action == 'remove') {
    await removeEnvironment(options.env_name);
    process.exit(0);
  }

  if (options.type == 'environment' && options.action == 'sample') {
    sampleEnvFormat();
    process.exit(0);
  }  

  if (options.type == 'workflows' && options.action == 'submit') {
    await submitWorkflow(options.workspace_id, options.config);
    process.exit(0);
  }

  if (options.type == 'workflows' && options.action == 'cancel') {
    await deleteWorkflow(options.run_id);
    process.exit(0);
  }

  if (options.type == 'workflows' && options.action == 'status') {
    await getWorkflow(options.run_id);
    process.exit(0);
  }

  if (options.type == 'workflows' && options.action == 'logs') {
    await getWorkflowLogs(options.run_id);
    process.exit(0);
  }
}