@agilecustoms/envctl 0.11.0 → 0.13.0

package/dist/client/TerraformAdapter.js

@@ -19,6 +19,7 @@ export class TerraformAdapter {
         console.log(`\nTime EST: ${est},  UTC: ${utc}\n`);
     }
     async init(key, cwd) {
+        console.log('Run terraform init to download providers, this doesn\'t create any resources in AWS even S3 object');
         let emptyDir = false;
         const scanner = (line) => {
             if (line.includes('Terraform initialized in an empty directory!')) {
@@ -40,22 +41,40 @@ export class TerraformAdapter {
             throw new KnownException('Can not find terraform files. Command needs to be run in a directory with terraform files');
         }
     }
-    tfArgs(envAttrs, tfArgs) {
+    tfArgs(envDto, tfArgs) {
         return [
-            `-var=env=${envAttrs.env}`,
-            `-var=owner=${envAttrs.owner}`,
-            `-var=env_size=${envAttrs.size}`,
-            `-var=env_type=${envAttrs.type}`,
+            `-var=env=${envDto.env}`,
+            `-var=owner=${envDto.owner}`,
+            `-var=env_size=${envDto.size}`,
+            `-var=env_type=${envDto.type}`,
             ...tfArgs
         ];
     }
-    async plan(envAttrs, tfArgs, cwd) {
-        const args = this.tfArgs(envAttrs, tfArgs);
+    async plan(envDto, tfArgs, cwd, attemptNo = 1) {
+        const args = this.tfArgs(envDto, tfArgs);
         console.log('Running: terraform plan -auto-approve', ...args);
-        await this.processRunner.run('terraform', ['plan', ...args], cwd);
+        try {
+            await this.processRunner.run('terraform', ['plan', ...args], cwd);
+        }
+        catch (error) {
+            if (error instanceof ProcessException) {
+                if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
+                    console.warn(`Retrying terraform plan due to error: ${error.message}`);
+                    return this.plan(envDto, tfArgs, cwd, attemptNo + 1);
+                }
+                const lockId = this.lockId(attemptNo, error);
+                if (lockId) {
+                    await this.promptUnlock(lockId, cwd);
+                    console.info('State unlocked, retrying terraform plan');
+                    return this.plan(envDto, tfArgs, cwd, attemptNo + 1);
+                }
+                throw new KnownException(`terraform plan failed with code ${error.code}:\n${error.message}`, { cause: error });
+            }
+            throw error;
+        }
     }
-    async deploy(envAttrs, tfArgs, cwd, attemptNo = 1) {
-        const args = this.tfArgs(envAttrs, tfArgs);
+    async deploy(envDto, tfArgs, cwd, attemptNo = 1) {
+        const args = this.tfArgs(envDto, tfArgs);
         console.log('Running: terraform apply -auto-approve', ...args);
         this.printTime();
         try {
@@ -66,30 +85,36 @@ export class TerraformAdapter {
             if (error instanceof ProcessException) {
                 if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
                     console.warn(`Retrying terraform apply due to error: ${error.message}`);
-                    return this.deploy(envAttrs, tfArgs, cwd, attemptNo + 1);
+                    return this.deploy(envDto, tfArgs, cwd, attemptNo + 1);
                 }
-                if (attemptNo < MAX_ATTEMPTS && error.message.includes('Error acquiring the state lock')) {
-                    const match = error.message.match(/ID:\s+([a-f0-9-]{36})/i);
-                    if (match) {
-                        console.error(error.message);
-                        const answerYes = await promptYesNo('Terraform state is locked. Most often due to previously interrupted process.\n'
-                            + 'Rarely (main lock intention) is when another process actively work with the state to avoid inconsistent modification.\n'
-                            + 'Do you want to force unlock? (y/n): ');
-                        if (answerYes) {
-                            console.log('Force unlocking state');
-                            const id = match[1];
-                            await this.processRunner.run('terraform', ['force-unlock', '-force', id], cwd);
-                            console.info('State unlocked, retrying terraform apply');
-                            return this.deploy(envAttrs, tfArgs, cwd, attemptNo + 1);
-                        }
-                        else {
-                            throw new ExitException();
-                        }
-                    }
+                const lockId = this.lockId(attemptNo, error);
+                if (lockId) {
+                    await this.promptUnlock(lockId, cwd);
+                    console.info('State unlocked, retrying terraform apply');
+                    return this.deploy(envDto, tfArgs, cwd, attemptNo + 1);
                 }
                 throw new KnownException(`terraform apply failed with code ${error.code}:\n${error.message}`, { cause: error });
             }
             throw error;
         }
     }
+    lockId(attemptNo, error) {
+        if (attemptNo < MAX_ATTEMPTS && error.message.includes('Error acquiring the state lock')) {
+            const match = error.message.match(/ID:\s+([a-f0-9-]{36})/i);
+            if (match) {
+                console.error(error.message);
+                return match[1];
+            }
+        }
+    }
+    async promptUnlock(id, cwd) {
+        const answerYes = await promptYesNo('Terraform state is locked. Most often due to previously interrupted process.\n'
+            + 'Rarely (main lock intention) is when another process actively work with the state to avoid inconsistent modification.\n'
+            + 'Do you want to force unlock?: ');
+        if (!answerYes) {
+            throw new ExitException();
+        }
+        console.log('Force unlocking state');
+        await this.processRunner.run('terraform', ['force-unlock', '-force', id], cwd);
+    }
 }

package/dist/commands/delete.js

@@ -1,26 +1,18 @@
 import { Command } from 'commander';
-import { configService, envCtl } from '../container.js';
-import { KnownException } from '../exceptions.js';
+import { envCtl } from '../container.js';
+import { KEYS } from './keys.js';
 import { wrap } from './utils.js';
+import { ensureEnv } from './validation.js';
 export function deleteIt(program) {
     program
         .command('delete')
         .description('Delete a development environment')
-        .option('--env <env>', 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)')
-        .option('--project <project>', 'Project code (like tt). Used when multiple projects deployed in same AWS account')
+        .option('--env <env>', KEYS.ENV)
+        .option('--project <project>', KEYS.PROJECT)
         .action(wrap(handler));
 }
 async function handler(options) {
     let { env, project } = options;
-    if (!env) {
-        const owner = configService.getOwner();
-        if (!owner) {
-            throw new KnownException('--env argument is not provided\n'
-                + 'default to owner from local configuration, but it is not configured\n'
-                + 'please call with --env argument or run \'envctl configure\' to configure owner');
-        }
-        console.log(`Env name not provided, default to owner name ${owner}`);
-        env = owner;
-    }
-    await envCtl.delete(env, project);
+    env = ensureEnv(env);
+    await envCtl.delete(project, env);
 }

package/dist/commands/deploy.js

@@ -4,18 +4,20 @@ import { configService, envCtl } from '../container.js';
 import { KnownException } from '../exceptions.js';
 import { EnvType } from '../model/index.js';
 import { EnvSize } from '../model/index.js';
-import { ensureEnumValue, ensureKind, wrap } from './utils.js';
+import { KEYS } from './keys.js';
+import { wrap } from './utils.js';
+import { ensureEnumValue, ensureKind } from './validation.js';
 export function deploy(program) {
     program
         .command('deploy')
         .description('Create new or update existing dev environment')
-        .option('--project <project>', 'Project code (like tt). Used when multiple projects deployed in same AWS account')
-        .option('--env <env>', 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)')
-        .option('--owner <owner>', 'Environment owner (GH username)')
-        .option('--size <size>', 'Environment size: min, small, full')
-        .option('--type <type>', 'Environment type: dev, prod', 'dev')
-        .option('--kind <kind>', 'Environment kind: complete project (default) or some slice such as tt-core + tt-web')
-        .option('--cwd <cwd>', 'Working directory (default: current directory)')
+        .option('--project <project>', KEYS.PROJECT)
+        .option('--env <env>', KEYS.ENV)
+        .option('--owner <owner>', KEYS.OWNER)
+        .option('--size <size>', KEYS.SIZE)
+        .option('--type <type>', KEYS.TYPE)
+        .option('--kind <kind>', KEYS.KIND)
+        .option('--cwd <cwd>', KEYS.CWD)
         .allowUnknownOption(true)
         .argument('[args...]')
         .action(wrap(handler));
@@ -43,15 +45,13 @@ export async function parseEnvDto(options) {
         envSize = ensureEnumValue(EnvSize, size, 'size');
     }
     else {
-        const answer = await inquirer.prompt([
-            {
+        const answer = await inquirer.prompt([{
                 type: 'list',
                 name: 'size',
                 message: 'Environment size:',
                 choices: Object.values(EnvSize),
                 default: EnvSize.Small,
-            }
-        ]);
+            }]);
         envSize = answer.size;
     }
     const envType = ensureEnumValue(EnvType, type, 'type');

package/dist/commands/index.js

@@ -2,3 +2,4 @@ export { configure } from './configure.js';
 export { deploy } from './deploy.js';
 export { deleteIt } from './delete.js';
 export { plan } from './plan.js';
+export { status } from './status.js';

package/dist/commands/keys.js

@@ -0,0 +1,9 @@
+export const KEYS = {
+    CWD: 'Working directory (default: current directory)',
+    ENV: 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)',
+    KIND: 'Environment kind: complete project (default) or some slice such as tt-core + tt-web',
+    OWNER: 'Environment owner (GH username)',
+    PROJECT: 'Project code (like tt). Used when multiple projects deployed in same AWS account',
+    SIZE: 'Environment size: min, small, full',
+    TYPE: 'Environment type: dev, prod',
+};

package/dist/commands/plan.js

@@ -1,17 +1,18 @@
 import { Command } from 'commander';
 import { envCtl } from '../container.js';
 import { parseEnvDto } from './deploy.js';
+import { KEYS } from './keys.js';
 import { wrap } from './utils.js';
 export function plan(program) {
     program
         .command('plan')
         .description('High level wrapper for terraform plan. Compliments deploy command: if you plan to deploy env with envctl deploy,'
         + ' then it is recommended to do plan with envctl plan to guarantee consistent behavior')
-        .option('--env <env>', 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)')
-        .option('--owner <owner>', 'Environment owner (GH username)')
-        .option('--size <size>', 'Environment size: min, small, full')
-        .option('--type <type>', 'Environment type: dev, prod', 'dev')
-        .option('--cwd <cwd>', 'Working directory (default: current directory)')
+        .option('--env <env>', KEYS.ENV)
+        .option('--owner <owner>', KEYS.OWNER)
+        .option('--size <size>', KEYS.SIZE)
+        .option('--type <type>', KEYS.TYPE)
+        .option('--cwd <cwd>', KEYS.CWD)
         .allowUnknownOption(true)
         .argument('[args...]')
         .action(wrap(handler));

package/dist/commands/status.js

@@ -0,0 +1,18 @@
+import { Command } from 'commander';
+import { envCtl } from '../container.js';
+import { KEYS } from './keys.js';
+import { wrap } from './utils.js';
+import { ensureEnv } from './validation.js';
+export function status(program) {
+    program
+        .command('status')
+        .description('Get env status')
+        .option('--env <env>', KEYS.ENV)
+        .option('--project <project>', KEYS.PROJECT)
+        .action(wrap(handler));
+}
+async function handler(options) {
+    let { env, project } = options;
+    env = ensureEnv(env);
+    await envCtl.status(project, env);
+}

package/dist/commands/utils.js

@@ -1,4 +1,3 @@
-import path from 'path';
 import { ExitPromptError } from '@inquirer/core';
 import inquirer from 'inquirer';
 import { BusinessException, ExitException, KnownException } from '../exceptions.js';
@@ -25,41 +24,11 @@ export function wrap(callable) {
     };
 }
 export async function promptYesNo(message, defaultValue = false) {
-    const { answer } = await inquirer.prompt([
-        {
+    const { answer } = await inquirer.prompt([{
             type: 'confirm',
             name: 'answer',
             message,
             default: defaultValue,
-        },
-    ]);
+        }]);
     return answer;
 }
-export function ensureKind(kind, cwd) {
-    if (kind) {
-        return kind;
-    }
-    kind = getDirName(cwd);
-    console.log(`Inferred kind from directory name: ${kind}`);
-    return kind;
-}
-function getDirName(cwd) {
-    cwd = resolveCwd(cwd);
-    return path.basename(cwd);
-}
-function resolveCwd(cwd) {
-    if (!cwd) {
-        return process.cwd();
-    }
-    if (path.isAbsolute(cwd)) {
-        return cwd;
-    }
-    return path.resolve(process.cwd(), cwd);
-}
-export function ensureEnumValue(enumObj, value, name) {
-    const values = Object.values(enumObj);
-    if (!values.includes(value)) {
-        throw new KnownException(`Invalid ${name}: "${value}". Must be one of: ${values.join(', ')}`);
-    }
-    return value;
-}

package/dist/commands/validation.js

@@ -0,0 +1,44 @@
+import path from 'path';
+import { configService } from '../container.js';
+import { KnownException } from '../exceptions.js';
+export function ensureKind(kind, cwd) {
+    if (kind) {
+        return kind;
+    }
+    kind = getDirName(cwd);
+    console.log(`Inferred kind from directory name: ${kind}`);
+    return kind;
+}
+function getDirName(cwd) {
+    cwd = resolveCwd(cwd);
+    return path.basename(cwd);
+}
+function resolveCwd(cwd) {
+    if (!cwd) {
+        return process.cwd();
+    }
+    if (path.isAbsolute(cwd)) {
+        return cwd;
+    }
+    return path.resolve(process.cwd(), cwd);
+}
+export function ensureEnumValue(enumObj, value, name) {
+    const values = Object.values(enumObj);
+    if (!values.includes(value)) {
+        throw new KnownException(`Invalid ${name}: "${value}". Must be one of: ${values.join(', ')}`);
+    }
+    return value;
+}
+export function ensureEnv(env) {
+    if (env) {
+        return env;
+    }
+    const owner = configService.getOwner();
+    if (!owner) {
+        throw new KnownException('--env argument is not provided\n'
+            + 'default to owner from local configuration, but it is not configured\n'
+            + 'please call with --env argument or run \'envctl configure\' to configure owner');
+    }
+    console.log(`Env name not provided, default to owner name ${owner}`);
+    return owner;
+}

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from 'module';
 import { Command } from 'commander';
 import updateNotifier from 'update-notifier';
-import { configure, deleteIt, deploy, plan } from './commands/index.js';
+import { configure, deleteIt, deploy, plan, status } from './commands/index.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
@@ -15,4 +15,5 @@ configure(program);
 deploy(program);
 deleteIt(program);
 plan(program);
+status(program);
 program.parse(process.argv);

package/dist/service/EnvCtl.js

@@ -11,8 +11,24 @@ export class EnvCtl {
     key(project, env) {
         return project ? `${project}-${env}` : env;
     }
+    async status(project, envName) {
+        const key = this.key(project, envName);
+        console.log(`Retrieve env ${key}`);
+        const env = await this.envApi.get(key);
+        if (env === null) {
+            console.log(`Env ${key} does not exist`);
+            return;
+        }
+        console.log(`Env ${key} status: ${env.status}`);
+    }
     async plan(envDto, tfArgs, cwd) {
-        console.log('Deploying resources');
+        const key = this.key(envDto.project, envDto.env);
+        console.log(`Check if env ${key} already exists`);
+        const env = await this.envApi.get(key);
+        if (env !== null) {
+            this.checkEnv(env, envDto);
+        }
+        await this.terraformAdapter.init(key, cwd);
         await this.terraformAdapter.plan(envDto, tfArgs, cwd);
     }
     async deploy(envDto, tfArgs, cwd) {
@@ -21,7 +37,6 @@ export class EnvCtl {
         const env = await this.envApi.get(key);
         if (env === null) {
             console.log(`Env ${key} does not exist, creating it`);
-            console.log('First run terraform init to download providers, this doesn\'t create any resources in AWS even S3 object');
             await this.terraformAdapter.init(key, cwd);
             console.log('Creating env tracking record in DynamoDB');
             const { owner, size, type, kind } = envDto;
@@ -29,21 +44,7 @@ export class EnvCtl {
             await this.envApi.create(createEnv);
             return await this.runDeploy(key, envDto, tfArgs, cwd);
         }
-        if (env.ephemeral) {
-            throw new KnownException(`Attempted to convert ephemeral env ${key} to non-ephemeral`);
-        }
-        if (env.owner !== envDto.owner) {
-            throw new KnownException(`Can not change env owner ${env.owner} -> ${envDto.owner}`);
-        }
-        if (env.size !== envDto.size) {
-            throw new KnownException(`Can not change env size ${env.size} -> ${envDto.size}`);
-        }
-        if (env.type !== envDto.type) {
-            throw new KnownException(`Can not change env type ${env.type} -> ${envDto.type}`);
-        }
-        if (env.kind !== envDto.kind) {
-            throw new KnownException(`Can not change env kind ${env.kind} -> ${envDto.kind}`);
-        }
+        this.checkEnv(env, envDto);
         switch (env.status) {
             case EnvStatus.Creating:
             case EnvStatus.Updating: {
@@ -58,14 +59,28 @@ export class EnvCtl {
                 console.log('Env status is ACTIVE\nWill lock for update and run terraform apply (to update resources)');
                 await this.envApi.lockForUpdate(key);
                 await this.runDeploy(key, envDto, tfArgs, cwd);
-                break;
-            }
-            case EnvStatus.Deleting: {
-                const time = EnvSizeAvgTime[env.size];
-                throw new KnownException(`Env status is DELETING, please wait (~${time} min)`);
             }
-            default:
-                throw new KnownException(`Unsupported environment status: ${env.status}`);
+        }
+    }
+    checkEnv(env, envDto) {
+        if (env.ephemeral) {
+            throw new KnownException(`Attempted to convert ephemeral env to non-ephemeral`);
+        }
+        if (env.owner !== envDto.owner) {
+            throw new KnownException(`Can not change env owner ${env.owner} -> ${envDto.owner}`);
+        }
+        if (env.size !== envDto.size) {
+            throw new KnownException(`Can not change env size ${env.size} -> ${envDto.size}`);
+        }
+        if (env.type !== envDto.type) {
+            throw new KnownException(`Can not change env type ${env.type} -> ${envDto.type}`);
+        }
+        if (env.kind !== envDto.kind) {
+            throw new KnownException(`Can not change env kind ${env.kind} -> ${envDto.kind}`);
+        }
+        if (env.status === EnvStatus.Deleting) {
+            const time = EnvSizeAvgTime[env.size];
+            throw new KnownException(`Env status is DELETING, please wait (~${time} min)`);
         }
     }
     async runDeploy(key, envDto, tfArgs, cwd) {
@@ -78,7 +93,7 @@ export class EnvCtl {
         console.log('Unlock env after db evolution');
         await this.envApi.activate(key);
     }
-    async delete(envName, project) {
+    async delete(project, envName) {
         const key = this.key(project, envName);
         console.log(`Retrieve env`);
         const env = await this.envApi.get(key);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
     "run": "node dist/index.js",
     "run-version": "tsc --sourceMap true && npm run run -- --version",
     "run-configure": "tsc --sourceMap true && npm run run -- configure",
+    "run-status": "tsc --sourceMap true && npm run run -- status",
     "run-plan": "tsc --sourceMap true && npm run run -- plan --size min --cwd ../tt-core",
     "run-deploy": "tsc --sourceMap true && npm run run -- deploy --size min --cwd ../tt-core",
     "run-delete": "tsc --sourceMap true && npm run run -- delete"