@agilecustoms/envctl 0.11.0 → 0.12.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/deploy.js

@@ -43,15 +43,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/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/service/EnvCtl.js

@@ -12,7 +12,13 @@ export class EnvCtl {
         return project ? `${project}-${env}` : env;
     }
     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 +27,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 +34,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 +49,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) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {