@agilecustoms/envctl 0.10.0 → 0.12.0

package/README.md

@@ -33,7 +33,7 @@ npm view @agilecustoms/envctl version # show latest version available (without i
 `env-api` is a microservice hosted in 'maintenance' account and working as garbage collector: every environment first
 created in `env-api` and then 'managed' by `env-api`: it deletes env when it is not in use anymore OR can extend lifetime.
 Creation API yields unique ID, so you can safely manage env (delete, extend lifetime) via this ID. But creation API
-need to be secured. There are two main use cases:
+needs to be secured. There are two main use cases:
 1. create environment from CI (mainly ephemeral envs)
 2. create env from dev machine
 

package/dist/client/ProcessRunner.js

@@ -9,7 +9,9 @@ export class ProcessRunner {
         return this.run(scriptPath, args, cwd, scanner);
     }
     async run(command, args, cwd, scanner) {
-        const spawnOptions = {};
+        const spawnOptions = {
+            stdio: ['inherit', 'pipe', 'pipe'],
+        };
         if (cwd) {
             spawnOptions.cwd = cwd;
         }
@@ -26,6 +28,10 @@ export class ProcessRunner {
                     scanner(line);
                 console.log(`> ${line}`);
             }
+            if (buffer.includes('Enter a value:')) {
+                console.log(buffer);
+                buffer = '';
+            }
         });
         let errorBuffer = '';
         child.stderr.on('data', (data) => {

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,15 +41,41 @@ export class TerraformAdapter {
             throw new KnownException('Can not find terraform files. Command needs to be run in a directory with terraform files');
         }
     }
-    async deploy(envAttrs, tfArgs, cwd, attemptNo = 1) {
-        const args = [
-            `-var=env=${envAttrs.env}`,
-            `-var=owner=${envAttrs.owner}`,
-            `-var=env_size=${envAttrs.size}`,
-            `-var=env_type=${envAttrs.type}`,
+    tfArgs(envDto, tfArgs) {
+        return [
+            `-var=env=${envDto.env}`,
+            `-var=owner=${envDto.owner}`,
+            `-var=env_size=${envDto.size}`,
+            `-var=env_type=${envDto.type}`,
             ...tfArgs
         ];
-        console.log('Running:', 'terraform apply -auto-approve', ...args);
+    }
+    async plan(envDto, tfArgs, cwd, attemptNo = 1) {
+        const args = this.tfArgs(envDto, tfArgs);
+        console.log('Running: terraform plan -auto-approve', ...args);
+        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(envDto, tfArgs, cwd, attemptNo = 1) {
+        const args = this.tfArgs(envDto, tfArgs);
+        console.log('Running: terraform apply -auto-approve', ...args);
         this.printTime();
         try {
             await this.processRunner.run('terraform', ['apply', '-auto-approve', ...args], cwd);
@@ -58,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/deploy.js

@@ -21,6 +21,10 @@ export function deploy(program) {
         .action(wrap(handler));
 }
 async function handler(tfArgs, options) {
+    const envDto = await parseEnvDto(options);
+    await envCtl.deploy(envDto, tfArgs, options.cwd);
+}
+export async function parseEnvDto(options) {
     let { project, env, owner, size, type, kind, cwd } = options;
     if (!owner) {
         owner = configService.getOwner();
@@ -39,18 +43,15 @@ async function handler(tfArgs, 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');
-    const envAttributes = { project, env, owner, size: envSize, type: envType, kind };
-    await envCtl.deploy(envAttributes, tfArgs, options.cwd);
+    return { project, env, owner, size: envSize, type: envType, kind };
 }

package/dist/commands/index.js

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

package/dist/commands/plan.js

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+import { envCtl } from '../container.js';
+import { parseEnvDto } from './deploy.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)')
+        .allowUnknownOption(true)
+        .argument('[args...]')
+        .action(wrap(handler));
+}
+async function handler(tfArgs, options) {
+    const envDto = await parseEnvDto(options);
+    await envCtl.plan(envDto, tfArgs, options.cwd);
+}

package/dist/commands/utils.js

@@ -25,14 +25,12 @@ 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) {

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 } from './commands/index.js';
+import { configure, deleteIt, deploy, plan } from './commands/index.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
@@ -14,4 +14,5 @@ program
 configure(program);
 deploy(program);
 deleteIt(program);
+plan(program);
 program.parse(process.argv);

package/dist/service/EnvCtl.js

@@ -8,13 +8,25 @@ export class EnvCtl {
         this.envApi = envApi;
         this.terraformAdapter = terraformAdapter;
     }
+    key(project, env) {
+        return project ? `${project}-${env}` : env;
+    }
+    async plan(envDto, tfArgs, cwd) {
+        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) {
-        const key = envDto.project ? `${envDto.project}-${envDto.env}` : envDto.env;
+        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) {
             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;
@@ -22,8 +34,27 @@ export class EnvCtl {
             await this.envApi.create(createEnv);
             return await this.runDeploy(key, envDto, tfArgs, cwd);
         }
+        this.checkEnv(env, envDto);
+        switch (env.status) {
+            case EnvStatus.Creating:
+            case EnvStatus.Updating: {
+                const answerYes = await promptYesNo(`Env status is ${env.status}, likely to be an error from a previous run\n`
+                    + 'Do you want to proceed with deployment?');
+                if (answerYes) {
+                    await this.runDeploy(key, envDto, tfArgs, cwd);
+                }
+                break;
+            }
+            case EnvStatus.Active: {
+                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);
+            }
+        }
+    }
+    checkEnv(env, envDto) {
         if (env.ephemeral) {
-            throw new KnownException(`Attempted to convert ephemeral env ${key} to non-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}`);
@@ -37,33 +68,14 @@ export class EnvCtl {
         if (env.kind !== envDto.kind) {
             throw new KnownException(`Can not change env kind ${env.kind} -> ${envDto.kind}`);
         }
-        switch (env.status) {
-            case EnvStatus.Creating:
-            case EnvStatus.Updating: {
-                const answerYes = await promptYesNo(`Env status is ${env.status}, likely to be an error from a previous run\n
-          Do you want to proceed with deployment? (y/n)`);
-                if (answerYes) {
-                    await this.runDeploy(key, envDto, tfArgs, cwd);
-                }
-                break;
-            }
-            case EnvStatus.Active: {
-                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}`);
+        if (env.status === EnvStatus.Deleting) {
+            const time = EnvSizeAvgTime[env.size];
+            throw new KnownException(`Env status is DELETING, please wait (~${time} min)`);
         }
     }
-    async runDeploy(key, envAttrs, tfArgs, cwd) {
+    async runDeploy(key, envDto, tfArgs, cwd) {
         console.log('Deploying resources');
-        await this.terraformAdapter.deploy(envAttrs, tfArgs, cwd);
+        await this.terraformAdapter.deploy(envDto, tfArgs, cwd);
         console.log('Activating env (to finish creation)');
         await this.envApi.activate(key);
         console.log('Lock env to run db evolution');
@@ -72,14 +84,14 @@ export class EnvCtl {
         await this.envApi.activate(key);
     }
     async delete(envName, project) {
-        const key = project ? `${project}-${envName}` : envName;
+        const key = this.key(project, envName);
         console.log(`Retrieve env`);
         const env = await this.envApi.get(key);
         if (env === null) {
             throw new KnownException(`Environment ${key} does not exist`);
         }
         if (env.status === EnvStatus.Creating) {
-            const answerYes = await promptYesNo('Environment is still being created.\nDo you want to delete it? (y/n) ');
+            const answerYes = await promptYesNo('Environment is still being created.\nDo you want to delete it?');
             if (!answerYes) {
                 throw new KnownException('Aborting env deletion');
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.10.0",
+  "version": "0.12.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-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"
   },