@optimizely/ocp-cli 1.0.0-beta.2

package/src/commands/directory/Status.ts

@@ -0,0 +1,45 @@
+import {command, help, namespace, option, optional, param} from 'oo-cli';
+import {appContext} from '../../lib/AppContext';
+import {die} from '../../lib/die';
+import {formatReviewStatus} from '../../lib/formatReviewStatus';
+import {formatVersionState} from '../../lib/formatVersionState';
+import {formatError} from '../../lib/formatError';
+import {Rivendell} from '../../lib/Rivendell';
+import AppVersionState = Rivendell.AppVersionState;
+import ReviewStatus = Rivendell.ReviewStatus;
+
+@namespace('directory')
+export class StatusCommand {
+  @param
+  @optional
+  @help('The App ID and version to look up')
+  public appId!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('Get the status of a particular app version')
+  public async status() {
+    const context = appContext(this.appId);
+    if (!context.appId || !context.version) {
+      return die('App ID and version are required');
+    }
+
+    try {
+        const appVersion = await Rivendell.fetchAppVersion(context, this.availability);
+        console.log(`Version state: ${formatVersionState(appVersion.state as AppVersionState)}`);
+
+        if (appVersion.reviewStatus) {
+          const reviewStatus = appVersion.reviewStatus as ReviewStatus;
+          const appVersionState = appVersion.state as AppVersionState;
+          if (appVersionState === AppVersionState.PUBLISHED) {
+            console.log(`Review status: ${formatReviewStatus(reviewStatus, appVersionState)}`);
+          }
+        }
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+}

package/src/commands/directory/Uninstall.ts

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import {command, help, namespace, option, param} from 'oo-cli';
+import {die} from '../../lib/die';
+import {Rivendell} from '../../lib/Rivendell';
+import {formatError} from '../../lib/formatError';
+
+@namespace('directory')
+export class UninstallCommand {
+  @param
+  @help('The App ID')
+  public appId!: string;
+
+  @param
+  @help('The Tracker ID of the account to install into')
+  public trackerId!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('Uninstall an app from an account')
+  public async uninstall() {
+    try {
+      const install = await Rivendell.fetchAppInstallation(this.appId, this.trackerId, this.availability);
+      await Rivendell.uninstall(install.id, this.availability);
+      console.log(chalk.green(`Uninstalled ${install.appId} from ${install.trackerId} (${this.availability || 'us'})`));
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+}

package/src/commands/directory/Unpublish.ts

@@ -0,0 +1,173 @@
+import chalk from 'chalk';
+import {command, flag, help, namespace, option, param} from 'oo-cli';
+import {terminal} from 'terminal-kit';
+import {AppContext} from '../../lib/AppContext';
+import {die} from '../../lib/die';
+import {formatVersionState} from '../../lib/formatVersionState';
+import {handleInterrupt} from '../../lib/handleInterrupt';
+import {TerminalSpinner} from '../../lib/TerminalSpinner';
+import {Rivendell} from '../../lib/Rivendell';
+import AppVersionState = Rivendell.AppVersionState;
+import SortDirection = Rivendell.SortDirection;
+import AppInstallation = Rivendell.AppInstallation;
+import {formatError} from '../../lib/formatError';
+import {applicableShards} from '../../lib/Shards';
+import { AppManifest } from '@zaiusinc/app-sdk';
+
+const UNPUBLISHABLE_STATES = [AppVersionState.RUNNING, AppVersionState.START_FAILED, AppVersionState.STOP_FAILED];
+
+@namespace('directory')
+export class UnpublishCommand {
+  @flag('f')
+  public force!: boolean;
+
+  @flag('no-progress')
+  public noProgress!: boolean;
+
+  @param
+  @help('The App ID and version (e.g. my_app@1.0.0)')
+  public appVersion!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  public availability: string = '';
+
+  @command
+  @help('Unpublish an app version (uninstall everywhere and undeploy)')
+  public async unpublish() {
+    handleInterrupt();
+
+    if (!/[\w-]+@\d+\.\d+\.\d+(?:-\w+\.\d+)?/.test(this.appVersion)) {
+      die('appVersion is required in the format of app@1.0.0');
+    }
+
+    const [appId, version] = this.appVersion.split('@');
+
+    try {
+      const appVersion = await Rivendell.fetchAppVersion({appId, version}, 'us');
+
+      if (!UNPUBLISHABLE_STATES.includes(appVersion.state as AppVersionState)) {
+        throw new Error(`AppVersion must be in an unpublishable state. ` +
+                        `Currently: ${formatVersionState(appVersion.state as AppVersionState)}`);
+      }
+
+      const manifest = JSON.parse(appVersion.manifestJson) as AppManifest;
+      const shards = await applicableShards(this.availability, manifest);
+      const errors: string[] = [];
+
+      for (const shard of shards) {
+        if (!(await this.uninstallEverywhere(appId, version, shard))) {
+          process.exit();
+        }
+        try {
+          await Rivendell.unpublish(appId, version, shard);
+          console.log(chalk.green(`${this.appVersion} is being unpublished in ${shard}.`));
+          await this.watchForCompletion({appId, version}, shard);
+        } catch (error) {
+          errors.push(`${formatError(error)} (${shard})`);
+        }
+      }
+
+      if (errors.length) {
+        console.log(chalk.red(errors.join('\n')));
+      }
+
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private async uninstallEverywhere(appId: string, version: string, shard: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      const criteria = {
+        appId,
+        version,
+        sorts: [{
+          field: 'trackerId', direction: SortDirection.DESC
+        }]
+      };
+
+      Rivendell.searchAppInstallations(criteria, shard)
+        .then(async (installations) => {
+          if (!installations.length) {
+            resolve(true);
+          } else {
+            const doIt = async () => {
+              try {
+                for (const appInstallation of installations) {
+                  await this.uninstall(appInstallation, shard);
+                }
+                resolve(true);
+              } catch (e) {
+                reject(e);
+              }
+            };
+
+            if (this.force) {
+              await doIt();
+            } else {
+              const trackers = installations.map((installation) => installation.trackerId);
+              console.log(`${this.appVersion} is currently installed in ${trackers.length} account(s) in ${shard}:`);
+              console.log(`  (${trackers.join(', ')})\n`);
+              console.log(chalk.red('Are you sure you want to uninstall from all these accounts? [y/n]'));
+              terminal.yesOrNo({yes: ['y', 'yes'], no: ['n', 'no']}, async (err, yes) => {
+                if (err) {
+                  reject(err);
+                } else if (yes) {
+                  await doIt();
+                } else {
+                  console.log(`Aborted. No changes made to ${this.appVersion}.`);
+                  resolve(false);
+                }
+              });
+            }
+          }
+        })
+        .catch((e) => reject(e));
+    });
+  }
+
+  private async uninstall(appInstallation: AppInstallation, shard: string) {
+    await Rivendell.uninstall(appInstallation.id, shard);
+    console.log(chalk.gray(`Uninstalled ${appInstallation.appId} from ${appInstallation.trackerId} in ${shard}`));
+  }
+
+  private async watchForCompletion(context: AppContext, shard: string) {
+    console.log(chalk.gray(`Watching for unpublish to complete in ${shard}... CTRL+C to stop checking.`));
+    return new Promise((resolve, reject) => {
+      const spinner = this.noProgress ? null : new TerminalSpinner().start('');
+      let attempts = 0;
+      const checkStatus = () => {
+        attempts++;
+        Rivendell.fetchAppVersion(context, shard)
+          .then((appVersion) => {
+            const state = appVersion.state as AppVersionState;
+            if (state === AppVersionState.STOPPED) {
+              if (spinner) {
+                spinner.stop();
+              }
+              clearInterval(interval);
+              console.log(chalk.green(`${context.appId}@${context.version} has been unpublished in ${shard}.`));
+              resolve();
+            } else {
+              if (attempts > 300) {
+                die('Timed out waiting for completion');
+              }
+              if (spinner) {
+                spinner.update(`Status: ${formatVersionState(state)}`);
+              }
+            }
+          })
+          .catch((e) => {
+              clearInterval(interval);
+              if (spinner) {
+                spinner.stop();
+              }
+              reject(e);
+          });
+      };
+      const interval = setInterval(checkStatus, 2000);
+      checkStatus();
+    });
+  }
+}

package/src/commands/directory/Uprade.ts

@@ -0,0 +1,85 @@
+import chalk from 'chalk';
+import {command, help, namespace, option, param, required} from 'oo-cli';
+import {die} from '../../lib/die';
+import {formatError} from '../../lib/formatError';
+import {handleInterrupt} from '../../lib/handleInterrupt';
+import {TerminalSpinner} from '../../lib/TerminalSpinner';
+import {terminal} from 'terminal-kit';
+import {Rivendell} from '../../lib/Rivendell';
+
+@namespace('directory')
+export class UpgradeCommand {
+  @param
+  @help('The App ID of the app to upgrade (e.g. my_app)')
+  public appId!: string;
+
+  @param
+  @help('The Tracker ID of the account to install into')
+  public trackerId!: string;
+
+  @option('v')
+  @required
+  @help('The desired version (i.e. 1.0.0)')
+  public toVersion!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('Upgrade the Install to a specific app version')
+  public async upgrade() {
+    handleInterrupt();
+    try {
+      const shard = this.availability || 'us';
+      const install = await Rivendell.fetchAppInstallation(this.appId, this.trackerId, shard);
+      if (install.version === this.toVersion) {
+        console.log(
+          chalk.yellow(`${this.trackerId} is currently at ${this.appId}@${install.version} in ${shard}.`)
+        );
+      } else {
+        await Rivendell.upgrade(install.id, this.appId, this.toVersion, shard);
+        console.log(`Upgrading ${this.appId} for ${this.trackerId} to ${this.toVersion} in ${shard}`);
+        await this.watchForCompletion(shard);
+        console.log(
+          chalk.green(`Upgraded ${this.trackerId} to ${this.appId}@${this.toVersion} in ${shard}.`));
+        terminal.removeAllListeners('key');
+      }
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private watchForCompletion(shard: string) {
+    console.log(chalk.gray(`Upgrade was scheduled in ${shard}, watching for completion... CTRL+C to stop checking.`));
+    return new Promise((resolve, reject) => {
+      let attempts = 0;
+      const spinner = new TerminalSpinner().start('');
+      const checkUpgrade = () => {
+        attempts++;
+        Rivendell.fetchAppInstallation(this.appId, this.trackerId, shard)
+          .then((install) => {
+            if (install.version === this.toVersion) {
+              clearInterval(interval);
+              spinner.stop();
+              resolve();
+            } else {
+              if (attempts > 300) {
+                clearInterval(interval);
+                spinner.stop();
+                die('Timed out waiting for completion');
+              }
+            }
+          })
+          .catch((e) => {
+            clearInterval(interval);
+            spinner.stop();
+            reject(e);
+          });
+      };
+
+      const interval = setInterval(checkUpgrade, 2000);
+      checkUpgrade();
+    });
+  }
+}

package/src/commands/env/GetEnvironment.ts

@@ -0,0 +1,14 @@
+import chalk from 'chalk';
+import {command, help, namespace} from 'oo-cli';
+import {getEnv, runtimeConfig} from '../../lib/Config';
+
+@namespace('env')
+export class GetEnvironmentCommand {
+  @command
+  @help('Get the current environment of the CLI')
+  public get() {
+    console.log(`Using ${chalk.yellow(getEnv())} environment\n`);
+    console.log('Configuration:');
+    console.log(chalk.gray(require('js-yaml').dump(runtimeConfig())));
+  }
+}

package/src/commands/env/SetEnvironment.ts

@@ -0,0 +1,52 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import chalk from 'chalk';
+import {command, help, namespace, param} from 'oo-cli';
+import { getEnv } from '../../lib/Config';
+
+const STAGING_ENV = {
+  'OCP_ENV': 'staging',
+  'RIVENDELL': 'https://rivendell.staging.zaius.com',
+  'AWS_REGION': 'us-east-1',
+  'UPLOAD_BUCKET': 'zaius-apps-staging'
+};
+
+const ENV_WHITELIST = ['staging', 'production'];
+
+@namespace('env')
+export class SetEnvironmentCommand {
+  @param
+  @help('The environment name')
+  public env!: string;
+
+  @command
+  @help('Set the current environment for the CLI')
+  public set() {
+    if (ENV_WHITELIST.includes(this.env)) {
+      const envPath = path.join(os.homedir(), '.ocp');
+      const envFile = path.join(envPath, `.env`);
+      const setEnvFile = `${envFile}.${this.env}`;
+
+      if (fs.existsSync(envFile)) {
+        fs.renameSync(envFile, `${envFile}.${getEnv()}`);
+      }
+
+      if (fs.existsSync(setEnvFile)) {
+        fs.renameSync(setEnvFile, envFile);
+      } else if (this.env === 'staging') {
+        try {
+          fs.statSync(envPath);
+        } catch {
+          fs.mkdirSync(envPath);
+        }
+        fs.writeFileSync(envFile, Object.entries(STAGING_ENV).map((x) => x.join('=')).join('\n'));
+      }
+
+      console.log(chalk.yellow(`using ${this.env} environment`));
+    } else {
+      console.log(chalk.red(
+        `Could not switch to environment ${this.env}. Permitted environments are ${ENV_WHITELIST}`));
+    }
+  }
+}

package/src/commands/jobs/List.ts

@@ -0,0 +1,278 @@
+import chalk from 'chalk';
+import {command, help, multiple, namespace, option, param} from 'oo-cli';
+import * as table from 'text-table';
+import {isValidDateOrEpochOrDurationString, parseDate} from '../../lib/parseDate';
+import {die} from '../../lib/die';
+import {styledStringLength} from '../../lib/StringUtils';
+import {Rivendell} from '../../lib/Rivendell';
+import {formatError} from '../../lib/formatError';
+import {default as parseDuration} from 'parse-duration';
+import Job = Rivendell.Job;
+import JobDefinition = Rivendell.JobDefinition;
+import Sort = Rivendell.Sort;
+import SortDirection = Rivendell.SortDirection;
+import JobStatus = Rivendell.JobStatus;
+import JobSearchCriteria = Rivendell.JobSearchCriteria;
+import { formatJobStatus } from '../../lib/formatJobStatus';
+import { jobRuntime } from '../../lib/jobRuntime';
+
+interface Column {
+  long: string;
+  header: string;
+}
+
+interface DisplayJob extends Job {
+  runtime?: number;
+  duration?: string;
+}
+
+const COLUMN_DEFINITIONS: Column[] = [
+  {long: 'id', header: 'Job ID'},
+  {long: 'version', header: 'Version'},
+  {long: 'function', header: 'Job Function'},
+  {long: 'trackerId', header: 'Tracker ID'},
+  {long: 'trigger', header: 'Trigger'},
+  {long: 'status', header: 'Status'},
+  {long: 'error', header: 'Error'},
+  {long: 'createdAt', header: 'Created At'},
+  {long: 'triggeredAt', header: 'Triggered At'},
+  {long: 'scheduledAt', header: 'Scheduled At'},
+  {long: 'terminatedAt', header: 'Terminated At'},
+  {long: 'updatedAt', header: 'Updated At'},
+  {long: 'duration', header: 'Duration'}
+];
+
+const SORT_COLUMNS: Column[] = COLUMN_DEFINITIONS
+  .filter((c) => !['appId', 'trigger', 'version'].includes(c.long));
+
+const DEFAULT_DISPLAY_COLUMNS = COLUMN_DEFINITIONS
+  .filter(
+    (c) => ['id', 'version', 'function', 'trackerId', 'status', 'createdAt', 'updatedAt', 'duration'].includes(c.long)
+  );
+
+function columnLongString(columns: Column[]) {
+  return columns.map((x) => x.long).join(', ');
+}
+
+@namespace('jobs')
+export class ListCommand {
+
+  @param
+  @help('Specific App ID to filter by')
+  private appId!: string;
+
+  @option
+  @help('Specific Versions to filter by')
+  @multiple
+  private version?: string[];
+
+  @option
+  @help('Specific Tracker IDs to filter by')
+  @multiple
+  private trackerId?: string[];
+
+  @option
+  @help('Specific Job Function to filter by')
+  @multiple
+  private function?: string[];
+
+  @option
+  @help(`Specific JobStatus to filter by. Possible values: ${Object.values(JobStatus).join(', ')}`)
+  @multiple
+  private status?: JobStatus[];
+
+  @option
+  @help('Show jobs that have been running longer than the given duration. (e.g. 5m = 5 minutes)')
+  private minDuration?: string;
+
+  @option
+  @help(`Column to sort the jobs by. Possible values: ${columnLongString(SORT_COLUMNS)}; Default: updatedAt`)
+  private sortBy: string = 'updatedAt';
+
+  @option
+  @help('Sort resulting jobs in ascending or descending order. Possible values: asc|desc. Default: desc')
+  private sortDirection: string = 'desc';
+
+  @option
+  @help('Number of jobs to list. Default: 50')
+  private limit?: number = 50;
+
+  @option
+  @help(`Columns to display. Possible values: ${columnLongString(COLUMN_DEFINITIONS)}. Default: ${columnLongString(DEFAULT_DISPLAY_COLUMNS)}`)
+  private columns: string = DEFAULT_DISPLAY_COLUMNS.map((c) => c.long).join(',');
+
+  @option
+  @help('A start time as an ISO string, an epoch timestamp, or relative string (i.e. "5m" for 5 minutes.) Default: 7d')
+  private from: string = '7d';
+
+  @option
+  @help('A end time as an ISO string, an epoch timestamp, or relative string (i.e. "5m" for 5 minutes)')
+  private to?: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('List jobs')
+  public async list(): Promise<void> {
+    try {
+      const criteria: JobSearchCriteria = {
+        appId: this.appId,
+      };
+      if (this.version) {
+        criteria.versions = this.version;
+      }
+      if (this.trackerId) {
+        criteria.trackerIds = this.trackerId;
+      }
+      if (this.status) {
+        criteria.states = this.getJobStatus(this.status);
+      }
+      if (this.function) {
+        criteria.functions = this.function;
+      }
+      if (this.minDuration) {
+        const parsedDurationInMillis = parseDuration(this.minDuration, 'ms');
+        if (!parsedDurationInMillis) {
+          die(chalk.red('Invalid "--minDuration" input, should be a relative string (i.e. "5m" for 5 minutes.'));
+          return;
+        }
+        criteria.minDurationMillis = parsedDurationInMillis;
+      }
+      if (this.limit) {
+        criteria.limit = this.limit;
+      }
+
+      criteria.sort = [this.getSort(this.sortBy, this.sortDirection)];
+
+      if (!isValidDateOrEpochOrDurationString(this.from)) {
+        die(chalk.red('Invalid "--from" input, should be an ISO string,' +
+          'an epoch timestamp, or relative string (i.e. "5m" for 5 minutes.'));
+      }
+      criteria.start = parseDate(this.from)?.valueOf();
+
+      if (this.to) {
+        if (!isValidDateOrEpochOrDurationString(this.to)) {
+          die(chalk.red('Invalid "--to" input, should be an ISO string,' +
+            'an epoch timestamp, or relative string (i.e. "5m" for 5 minutes.'));
+        }
+        criteria.end = parseDate(this.to)?.valueOf();
+      }
+
+      const jobs = await Rivendell.searchJobs(criteria, this.availability);
+      if (jobs.length === 0) {
+        die(chalk.yellow(`No jobs found since ${this.from} ago for given criteria. Try to change the criteria or extend the time range.`));
+      } else {
+        this.render(this.amendWithDuration(jobs));
+      }
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private getJobStatus(status: string[]): JobStatus[] {
+    return status.map((s) => {
+      const key = s.toUpperCase();
+      if (!JobStatus[key as  JobStatus]) {
+        die(`${s} is not a valid JobStatus`);
+      }
+      return JobStatus[key as  JobStatus];
+    });
+  }
+
+  private getSort(sortBy: string, sortDirection: string | undefined) {
+    const sortColumn = SORT_COLUMNS.find((c) => c.long === sortBy);
+    if (!sortColumn) {
+      die(`"${sortBy}" not an available column for sorting`);
+    }
+
+    const sort: Sort = {
+      field: sortColumn!.long
+    };
+    if (sortDirection) {
+      if (sortDirection.toUpperCase() === SortDirection.ASC) {
+        sort.direction = SortDirection.ASC;
+      } else if (sortDirection.toUpperCase() === SortDirection.DESC) {
+        sort.direction = SortDirection.DESC;
+      } else {
+        die(`"${sortDirection}" not valid for sorting`);
+      }
+    }
+    return sort;
+  }
+
+  private amendWithDuration(jobs: Job[]) {
+    const jobsWithRuntime: DisplayJob[] = jobs.map((job) => {
+      const runtime = jobRuntime(job);
+      return {...job, runtime, duration: this.timeToDurationString(runtime)};
+    });
+
+    return jobsWithRuntime;
+  }
+
+  private timeToDurationString(ms: number | undefined) {
+    if (!ms || ms <= 0) {
+      return '-';
+    }
+    const duration = ms / 1000;
+    const hours   = Math.floor(duration / 3600);
+    const minutes = Math.floor((duration - (hours * 3600)) / 60);
+    const seconds = duration - (hours * 3600) - (minutes * 60);
+    const out = [];
+    if (hours > 0) {
+      out.push(`${hours}h`);
+    }
+    if (minutes > 0) {
+      out.push(`${minutes}m`);
+    }
+    if (seconds > 0) {
+      out.push(`${seconds}s`);
+    }
+    return out.join(' ');
+  }
+
+  private render(jobs: DisplayJob[]) {
+    const columns: Column[] = this.columns.split(',')
+      .map((c) => {
+        const col = COLUMN_DEFINITIONS.find((d) => d.long === c);
+        if (!col) {
+          die(`"${c}" is not a valid column name`);
+        }
+        return col!;
+      });
+
+    const header = columns.map((item) => chalk.grey(item.header));
+
+    const rows = jobs.map((job: DisplayJob) => {
+      return columns.map((col) => {
+        if (job[col.long as keyof Job]) {
+          if (col.long === 'status') {
+            return formatJobStatus(job[col.long as keyof Job] as JobStatus);
+          }
+          return job[col.long as keyof Job];
+        } else if (job.definition[col.long as keyof JobDefinition]) {
+          return job.definition[col.long as keyof JobDefinition];
+        } else {
+          return '';
+        }
+      });
+    });
+
+    const t = table(
+      [
+        header,
+        ...rows
+      ],
+      {
+        hsep: ' '.repeat(8),
+        stringLength: styledStringLength
+      }
+    );
+    console.log(`\n${t}\n`);
+
+    if (Number(this.limit) === jobs.length) {
+      console.log(chalk.yellow(`Showing first ${this.limit} results. Use --limit paramter to see more.\n`));
+    }
+  }
+}