@agilecustoms/envctl 0.24.0 → 0.26.0

package/dist/client/CliHelper.js

@@ -16,17 +16,17 @@ export class CliHelper {
             }]);
         return answer;
     }
-    ensureEnv(env) {
-        if (env) {
-            return env;
+    ensureEnv(key) {
+        if (key) {
+            return key;
         }
         const owner = this.configService.getOwner();
         if (!owner) {
-            throw new KnownException('--env argument is not provided\n'
+            throw new KnownException('--key 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');
+                + 'please call with --key argument or run \'envctl configure\' to configure owner');
         }
-        console.log(`Env name not provided, default to owner name ${owner}`);
+        console.log(`Key is not provided, default to owner name ${owner}`);
         return owner;
     }
     ensureOwner(owner) {

package/dist/client/TerraformAdapter.js

@@ -22,54 +22,10 @@ export class TerraformAdapter {
         });
         console.log(`\nTime EST: ${est},  UTC: ${utc}\n`);
     }
-    async init(key, cwd, upgrade = false) {
-        let accAlias = '';
-        const accAliasScanner = (line) => {
-            accAlias = line;
-        };
-        await this.processRunner.runScript('get-acc-alias.sh', [], cwd, accAliasScanner);
-        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!')) {
-                emptyDir = true;
-            }
-        };
-        const bucket = `agilecustoms-${accAlias}-tf-state`;
-        const args = [
-            'init',
-            '-reconfigure',
-            `-backend-config=bucket=${bucket}`,
-            `-backend-config=key=${key}`
-        ];
-        if (upgrade) {
-            args.push('-upgrade');
-        }
-        this.printTime();
-        try {
-            await this.processRunner.run('terraform', args, cwd, scanner);
-            this.printTime();
-        }
-        catch (error) {
-            if (error instanceof ProcessException) {
-                if (!upgrade && error.message.includes('Failed to query available provider packages')) {
-                    args.push('-upgrade');
-                    await this.processRunner.run('terraform', args, cwd);
-                    this.printTime();
-                    return;
-                }
-                throw new KnownException(`terraform init failed with code ${error.code}:\n${error.message}`, { cause: error });
-            }
-            throw error;
-        }
-        if (emptyDir) {
-            throw new KnownException('Can not find terraform files. Command needs to be run in a directory with terraform files');
-        }
-    }
     tfArgs(env, cwd) {
         const varDefs = this.getVarDefs(cwd);
         const argVars = this.getArgVars(env.args);
-        const specialFields = { ...env, env: env.envName };
+        const specialFields = { ...env, env: env.key };
         const extraArgs = [];
         for (const name of ['env', 'owner', 'ephemeral']) {
             if (varDefs[name] && !argVars[name]) {

package/dist/commands/_keys.js

@@ -1,7 +1,7 @@
 export const _keys = {
     CWD: 'Working directory (default: current directory)',
-    ENV: 'Environment name (can be git hash). = key used to store env state (s3 key in case of AWS)',
     FORCE: 'Force deletion without confirmation',
+    KEY: 'Environment name/identifier - taken from remote stake key, must be unique for a given customer',
     KIND: 'Environment kind: complete project (default) or some slice such as tt-core + tt-web',
     OWNER: 'Environment owner (GH username)'
 };

package/dist/commands/createEphemeral.js

@@ -6,12 +6,12 @@ export function createEphemeral(program) {
     program
         .command('create-ephemeral')
         .description('Create bare env w/o resources. Used in CI as first step just to pre-generate token for extension')
-        .requiredOption('--env <env>', _keys.ENV)
+        .requiredOption('--key <key>', _keys.KEY)
         .option('--owner <owner>', _keys.OWNER)
         .action(wrap(handler));
 }
 async function handler(options) {
-    const { env, owner } = options;
-    const token = await envCtl.createEphemeral(env, owner);
+    const { key, owner } = options;
+    const token = await envCtl.createEphemeral(key, owner);
     console.log(token);
 }

package/dist/commands/delete.js

@@ -6,13 +6,13 @@ export function deleteIt(program) {
     program
         .command('delete')
         .description('Delete a development environment')
-        .option('--env <env>', _keys.ENV)
+        .option('--key <key>', _keys.KEY)
         .option('--force', _keys.FORCE)
         .option('--cwd <cwd>', _keys.CWD)
         .action(wrap(handler));
 }
 async function handler(options) {
-    const { env, force, cwd } = options;
-    const envName = cliHelper.ensureEnv(env);
-    await envCtl.delete(envName, Boolean(force), cwd);
+    const { key, force, cwd } = options;
+    const theKey = cliHelper.ensureEnv(key);
+    await envCtl.delete(theKey, Boolean(force), cwd);
 }

package/dist/commands/deploy.js

@@ -6,7 +6,7 @@ export function deploy(program) {
     program
         .command('deploy')
         .description('Create new or update existing dev environment')
-        .option('--env <env>', _keys.ENV)
+        .option('--key <key>', _keys.KEY)
         .option('--owner <owner>', _keys.OWNER)
         .option('--kind <kind>', _keys.KIND)
         .option('--cwd <cwd>', _keys.CWD)
@@ -16,7 +16,6 @@ export function deploy(program) {
 }
 async function handler(tfArgs, options) {
     await awsCredsHelper.ensureCredentials();
-    const { cwd, env, ...envDto } = options;
-    envDto.envName = env;
+    const { cwd, ...envDto } = options;
     await envCtl.deploy(envDto, tfArgs, cwd);
 }

package/dist/commands/destroy.js

@@ -8,7 +8,7 @@ export function destroy(program) {
         .description('Destroy environment resources. This is thin wrapper for terraform destroy.'
         + ' Unlike "delete" command (which just schedule deletion) this command deletes resources synchronously.'
         + ' Main use case - test deletion process, basically that you have enough permissions to delete resources')
-        .option('--env <env>', _keys.ENV)
+        .option('--key <key>', _keys.KEY)
         .option('--force', _keys.FORCE)
         .option('--cwd <cwd>', _keys.CWD)
         .allowUnknownOption(true)
@@ -16,7 +16,7 @@ export function destroy(program) {
         .action(wrap(handler));
 }
 async function handler(tfArgs, options) {
-    const { env, force, cwd } = options;
-    const envName = cliHelper.ensureEnv(env);
-    await envCtl.destroy(envName, tfArgs, Boolean(force), cwd);
+    const { key, force, cwd } = options;
+    const theKey = cliHelper.ensureEnv(key);
+    await envCtl.destroy(theKey, tfArgs, Boolean(force), cwd);
 }

package/dist/commands/index.js

@@ -3,6 +3,5 @@ export { createEphemeral } from './createEphemeral.js';
 export { deleteIt } from './delete.js';
 export { deploy } from './deploy.js';
 export { destroy } from './destroy.js';
-export { init } from './init.js';
 export { plan } from './plan.js';
 export { status } from './status.js';

package/dist/commands/plan.js

@@ -7,7 +7,7 @@ export function plan(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>', _keys.ENV)
+        .option('--key <key>', _keys.KEY)
         .option('--owner <owner>', _keys.OWNER)
         .option('--cwd <cwd>', _keys.CWD)
         .allowUnknownOption(true)
@@ -16,7 +16,6 @@ export function plan(program) {
 }
 async function handler(tfArgs, options) {
     await awsCredsHelper.ensureCredentials();
-    const { cwd, env, ...envDto } = options;
-    envDto.envName = env;
+    const { cwd, ...envDto } = options;
     await envCtl.plan(envDto, tfArgs, cwd);
 }

package/dist/commands/status.js

@@ -6,12 +6,12 @@ export function status(program) {
     program
         .command('status')
         .description('Get env status')
-        .option('--env <env>', _keys.ENV)
+        .option('--key <key>', _keys.KEY)
         .option('--cwd <cwd>', _keys.CWD)
         .action(wrap(handler));
 }
 async function handler(options) {
-    const { env, cwd } = options;
-    const envName = cliHelper.ensureEnv(env);
-    await envCtl.status(envName, cwd);
+    const { key, cwd } = options;
+    const theKey = cliHelper.ensureEnv(key);
+    await envCtl.status(theKey, cwd);
 }

package/dist/index.js

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

package/dist/service/EnvCtl.js

@@ -9,11 +9,7 @@ export class EnvCtl {
         this.envApi = envApi;
         this.terraformAdapter = terraformAdapter;
     }
-    key(env) {
-        return env;
-    }
-    async status(envName, cwd) {
-        const key = this.key(envName);
+    async status(key, cwd) {
         console.log(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (env === null) {
@@ -27,14 +23,13 @@ export class EnvCtl {
         }
     }
     async tryGetEnv(input) {
-        let envName = input.envName;
+        let key = input.key;
         let owner = input.owner;
-        if (!envName) {
+        if (!key) {
             owner = this.cliHelper.ensureOwner(owner);
             console.log(`Env name not provided, default to owner name ${owner}`);
-            envName = owner;
+            key = owner;
         }
-        const key = this.key(envName);
         console.log(`Check if env ${key} already exists`);
         const env = await this.envApi.get(key);
         if (env) {
@@ -43,7 +38,7 @@ export class EnvCtl {
         else {
             console.log(`Env ${key} does not exist`);
         }
-        return { envName, anOwner: owner, key, env };
+        return { anOwner: owner, key, env };
     }
     checkInput(env, input, cwd) {
         if (input.owner && env.owner !== input.owner) {
@@ -63,15 +58,11 @@ export class EnvCtl {
         }
         throw new KnownException(`Env ${env.key} status is ${env.status}, can not run this command`);
     }
-    async init(envName, cwd) {
-        const key = this.key(envName);
-        await this.terraformAdapter.init(key, cwd, true);
-    }
     async plan(input, tfArgs, cwd) {
-        const { envName, anOwner, key, env } = await this.tryGetEnv(input);
+        const { anOwner, key, env } = await this.tryGetEnv(input);
         if (env == null) {
             const owner = this.cliHelper.ensureOwner(anOwner);
-            await this.runPlan(key, envName, owner, tfArgs, undefined, cwd);
+            await this.runPlan(key, owner, tfArgs, undefined, cwd);
             return;
         }
         this.checkInput(env, input, cwd);
@@ -81,15 +72,13 @@ export class EnvCtl {
         if (env.status !== EnvStatus.Active) {
             throw new KnownException(`Env ${env.key} status is ${env.status}, can not run plan`);
         }
-        await this.runPlan(key, envName, owner, tfArgs, env.vars, cwd);
+        await this.runPlan(key, owner, tfArgs, env.vars, cwd);
     }
-    async runPlan(key, envName, owner, args, vars, cwd) {
-        const envTerraform = { envName, ephemeral: false, owner, args, vars };
-        await this.terraformAdapter.init(key, cwd);
+    async runPlan(key, owner, args, vars, cwd) {
+        const envTerraform = { key, ephemeral: false, owner, args, vars };
         await this.terraformAdapter.plan(envTerraform, cwd);
     }
-    async createEphemeral(envName, owner) {
-        const key = this.key(envName);
+    async createEphemeral(key, owner) {
         const env = await this.envApi.get(key);
         if (env !== null) {
             throw new KnownException(`Env ${key} already exists`);
@@ -98,14 +87,14 @@ export class EnvCtl {
         return await this.envApi.createEphemeral(createEnv);
     }
     async deploy(input, tfArgs, cwd) {
-        const { envName, anOwner, key, env } = await this.tryGetEnv(input);
+        const { anOwner, key, env } = await this.tryGetEnv(input);
         if (env === null) {
             const owner = this.cliHelper.ensureOwner(anOwner);
             const kind = this.cliHelper.ensureKind(input.kind, cwd);
             console.log('Creating env tracking record in DynamoDB');
             const createEnv = { key, owner, kind };
             const newEnv = await this.envApi.create(createEnv);
-            return await this.runDeploy(newEnv, envName, tfArgs, cwd);
+            return await this.runDeploy(newEnv, key, tfArgs, cwd);
         }
         this.checkInput(env, input, cwd);
         this.checkStatus(env);
@@ -124,13 +113,12 @@ export class EnvCtl {
             console.log('Env status is ACTIVE\nWill lock for update and run terraform apply (to update resources)');
             await this.envApi.lockForUpdate(env);
         }
-        await this.runDeploy(env, envName, tfArgs, cwd);
+        await this.runDeploy(env, key, tfArgs, cwd);
     }
-    async runDeploy(env, envName, tfArgs, cwd) {
-        await this.terraformAdapter.init(env.key, cwd);
+    async runDeploy(env, key, tfArgs, cwd) {
         console.log('Deploying resources');
         const { ephemeral, vars } = env;
-        const envTerraform = { envName, ephemeral, owner: env.owner || 'system', args: tfArgs, vars };
+        const envTerraform = { key, ephemeral, owner: env.owner || 'system', args: tfArgs, vars };
         const onDemandVars = {};
         try {
             await this.terraformAdapter.apply(envTerraform, onDemandVars, cwd);
@@ -146,8 +134,8 @@ export class EnvCtl {
         console.log('Activating env (to finish creation)');
         await this.envApi.activate(env);
     }
-    async delete(envName, force, cwd) {
-        const env = await this.get(envName);
+    async delete(key, force, cwd) {
+        const env = await this.get(key);
         if (!force) {
             this.checkStatus(env);
             if (env.status === EnvStatus.Init) {
@@ -174,8 +162,8 @@ export class EnvCtl {
         const message = await this.envApi.delete(env);
         console.log(message);
     }
-    async destroy(envName, tfArgs, force, cwd) {
-        const env = await this.get(envName);
+    async destroy(key, tfArgs, force, cwd) {
+        const env = await this.get(key);
         this.checkStatus(env);
         if (env.status === EnvStatus.Init) {
             console.log(`Env ${env.key} has no resources, nothing to destroy, call 'delete' command instead`);
@@ -196,9 +184,8 @@ export class EnvCtl {
             await this.envApi.lockForUpdate(env);
         }
         const { ephemeral, owner, vars } = env;
-        const envTerraform = { envName, ephemeral, owner: owner || 'system', args: tfArgs, vars };
+        const envTerraform = { key, ephemeral, owner: owner || 'system', args: tfArgs, vars };
         console.log('Destroying env resources');
-        await this.terraformAdapter.init(env.key, cwd);
         await this.terraformAdapter.destroy(envTerraform, force, cwd);
         console.log('Unlock env');
         await this.envApi.activate(env);
@@ -206,8 +193,7 @@ export class EnvCtl {
         await this.envApi.delete(env);
         console.log('Please wait for ~15 sec before you can create env with same name');
     }
-    async get(envName) {
-        const key = this.key(envName);
+    async get(key) {
         console.log(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (!env) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {
@@ -29,16 +29,16 @@
     "run-version": "  tsc --sourceMap true && npm run run -- --version",
     "run-configure": "tsc --sourceMap true && npm run run -- configure",
     "~": "",
+    "run-init": "cd ../tt-core && terraform init -backend-config=key=laxa1986 -upgrade",
     "run-status": " tsc --sourceMap true && npm run run -- status  --cwd ../tt-core",
-    "run-init": "   tsc --sourceMap true && npm run run -- init    --cwd ../tt-core",
     "run-plan": "   tsc --sourceMap true && npm run run -- plan    --cwd ../tt-core",
     "run-deploy": " tsc --sourceMap true && npm run run -- deploy  --cwd ../tt-core -var=\"env_size=min\"",
     "run-delete": " tsc --sourceMap true && npm run run -- delete  --cwd ../tt-core",
     "run-destroy": "tsc --sourceMap true && npm run run -- destroy --cwd ../tt-core",
     "-": "",
+    "run-ephemeral-init": "cd ../tt-gitops && terraform init -backend-config=key=test",
     "run-ephemeral-create": " tsc --sourceMap true && npm run run -- create-ephemeral --env test",
     "run-ephemeral-status": " tsc --sourceMap true && npm run run -- status  --env test",
-    "run-ephemeral-init": "   tsc --sourceMap true && npm run run -- init    --env test --cwd ../tt-gitops",
     "run-ephemeral-deploy": " tsc --sourceMap true && npm run run -- deploy  --env test --cwd ../tt-gitops -var-file=versions.tfvars",
     "run-ephemeral-delete": " tsc --sourceMap true && npm run run -- delete  --env test --cwd ../tt-gitops --force",
     "run-ephemeral-destroy": "tsc --sourceMap true && npm run run -- destroy --env test --cwd ../tt-gitops --force -var-file=versions.tfvars"

package/dist/commands/init.js

@@ -1,17 +0,0 @@
-import { Command } from 'commander';
-import { cliHelper, envCtl } from '../container.js';
-import { _keys } from './_keys.js';
-import { wrap } from './_utils.js';
-export function init(program) {
-    program
-        .command('init')
-        .description('Terraform init wrapper')
-        .option('--env <env>', _keys.ENV)
-        .option('--cwd <cwd>', _keys.CWD)
-        .action(wrap(handler));
-}
-async function handler(options) {
-    const { env, cwd } = options;
-    const envName = cliHelper.ensureEnv(env);
-    await envCtl.init(envName, cwd);
-}