@agilecustoms/envctl 1.6.1 → 1.7.0

package/dist/client/Cli.js

@@ -5,34 +5,59 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
+import { clearTimeout } from 'node:timers';
 import path from 'path';
 import * as readline from 'readline';
 import inquirer from 'inquirer';
-import { ProcessException } from '../exceptions.js';
+import { ProcessException, TimeoutException } from '../exceptions.js';
+export const NO_TIMEOUT = 0;
 export class Cli {
-    async run(command, args, out_scanner, in_scanner) {
+    async run(command, args, timeoutMs = NO_TIMEOUT, out_scanner, in_scanner) {
+        const needsInteractive = !!in_scanner;
         const spawnOptions = {
-            stdio: ['pipe', 'pipe', 'pipe'],
+            stdio: [needsInteractive ? 'pipe' : 'ignore', 'pipe', 'pipe'],
         };
         const child = spawn(command, args, spawnOptions);
         child.stdout.setEncoding('utf8');
         child.stderr.setEncoding('utf8');
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        rl.on('line', (line) => {
-            if (in_scanner) {
-                in_scanner(line);
+        const rl = needsInteractive
+            ? readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            })
+            : null;
+        let timeoutId = null;
+        let timedOut = false;
+        if (timeoutMs > 0) {
+            timeoutId = setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+                timeoutId = null;
+            }, timeoutMs);
+        }
+        function clearTimeoutIfNeeded() {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+        }
+        const handlers = [];
+        function on(sig) {
+            const h = () => child.kill(sig);
+            process.on(sig, h);
+            handlers.push([sig, h]);
+        }
+        on('SIGINT');
+        on('SIGTERM');
+        on('SIGHUP');
+        rl?.on('line', (line) => {
+            in_scanner?.(line);
+            if (child.stdin.writable) {
+                child.stdin.write(line + '\n');
             }
-            child.stdin.write(line + '\n');
-        });
-        rl.on('SIGINT', () => {
-            child.kill('SIGINT');
         });
         function processLine(line) {
-            if (out_scanner)
-                out_scanner(line);
+            out_scanner?.(line);
             console.log(line);
         }
         let buffer = '';
@@ -50,12 +75,22 @@ export class Cli {
         child.stderr.on('data', (data) => {
             errorBuffer += data;
         });
+        function cleanup() {
+            for (const [sig, h] of handlers)
+                process.off(sig, h);
+            clearTimeoutIfNeeded();
+            rl?.close();
+        }
         return new Promise((resolve, reject) => {
-            child.on('close', (code) => {
-                rl.close();
+            child.on('close', (code, signal) => {
+                cleanup();
                 if (buffer !== '') {
                     processLine(buffer);
                 }
+                if (timedOut) {
+                    reject(new TimeoutException(`Process killed after timeout of ${timeoutMs}ms`));
+                    return;
+                }
                 if (code === 0) {
                     if (errorBuffer) {
                         console.warn('Process completed successfully, but there were errors:\n' + errorBuffer);
@@ -63,11 +98,11 @@ export class Cli {
                     resolve();
                 }
                 else {
-                    reject(new ProcessException(code, errorBuffer));
+                    reject(new ProcessException(code, errorBuffer, signal));
                 }
             });
             child.on('error', (err) => {
-                rl.close();
+                cleanup();
                 const code = err?.errno ?? 1;
                 reject(new ProcessException(code, err.message));
             });

package/dist/client/HttpClient.js

@@ -42,6 +42,6 @@ export class HttpClient {
         if (response.status === 422) {
             throw new BusinessException(message);
         }
-        throw new HttpException(response.status, message);
+        throw new HttpException(message);
     }
 }

package/dist/client/index.js

@@ -1,3 +1,2 @@
 export { EnvApiClient } from './EnvApiClient.js';
 export { HttpClient } from './HttpClient.js';
-export { TerraformAdapter } from './TerraformAdapter.js';

package/dist/container.js

@@ -1,7 +1,7 @@
 import { S3Backend } from './backend/S3Backend.js';
 import { Cli } from './client/Cli.js';
-import { EnvApiClient, HttpClient, TerraformAdapter } from './client/index.js';
-import { ConfigService, EnvService } from './service/index.js';
+import { EnvApiClient, HttpClient } from './client/index.js';
+import { ConfigService, EnvService, TerraformAdapter } from './service/index.js';
 import { LocalStateService } from './service/LocalStateService.js';
 import { LogService } from './service/LogService.js';
 const cli = new Cli();
@@ -12,7 +12,7 @@ const backends = [
 const httpClient = new HttpClient();
 const envApiClient = new EnvApiClient(httpClient);
 const localStateService = new LocalStateService();
-const terraformAdapter = new TerraformAdapter(cli, localStateService, backends);
+const terraformAdapter = new TerraformAdapter(Date.now, cli, localStateService, backends);
 const envService = new EnvService(cli, envApiClient, terraformAdapter);
 const logService = new LogService(cli, envApiClient, terraformAdapter);
 export { configService, envService, logService };

package/dist/exceptions.js

@@ -11,34 +11,36 @@ export class AbortedException extends Error {
     }
 }
 export class HttpException extends Error {
-    statusCode;
-    responseBody;
-    constructor(statusCode, responseBody) {
-        super(`Received ${statusCode} response`);
-        this.statusCode = statusCode;
-        this.responseBody = responseBody;
+    constructor(message) {
+        super(message);
         this.name = 'HttpException';
     }
 }
 export class BusinessException extends HttpException {
-    message;
     constructor(message) {
-        super(422, message);
-        this.message = message;
+        super(message);
         this.name = 'BusinessException';
     }
 }
 export class NotFoundException extends HttpException {
     constructor(message) {
-        super(404, message);
+        super(message);
         this.name = 'NotFoundException';
     }
 }
 export class ProcessException extends Error {
     code;
-    constructor(code, message) {
+    signal;
+    constructor(code, message, signal = null) {
         super(message);
         this.code = code;
+        this.signal = signal;
         this.name = 'ProcessException';
     }
 }
+export class TimeoutException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TimeoutException';
+    }
+}

package/dist/service/BaseService.js

@@ -1,4 +1,3 @@
-import { TerraformAdapter } from '../client/index.js';
 export class BaseService {
     terraformAdapter;
     constructor(terraformAdapter) {

package/dist/service/EnvService.js

@@ -1,5 +1,5 @@
 import { Cli } from '../client/Cli.js';
-import { EnvApiClient, TerraformAdapter } from '../client/index.js';
+import { EnvApiClient } from '../client/index.js';
 import { KnownException } from '../exceptions.js';
 import { EnvStatus } from '../model/index.js';
 import { BaseService } from './BaseService.js';
@@ -68,7 +68,8 @@ export class EnvService extends BaseService {
             this.checkKind(env);
             this.handleDeleteStatuses(env);
         }
-        await this.lockTerraform(env, env === null);
+        const newEnv = env === null;
+        await this.lockTerraform(env, newEnv);
         await this.terraformAdapter.plan(env, tfArgs);
     }
     async createEphemeral(key) {
@@ -158,7 +159,7 @@ export class EnvService extends BaseService {
     }
     async runDeploy(env, tfArgs) {
         console.log('Deploying resources');
-        await this.terraformAdapter.apply(tfArgs);
+        await this.terraformAdapter.apply(tfArgs, env.ttl);
         console.log('Activating env (to finish creation)');
         await this.envApi.activate(env);
     }

package/dist/service/LogService.js

@@ -1,5 +1,5 @@
 import { basename } from 'node:path';
-import { TerraformAdapter } from '../client/index.js';
+import {} from '../client/index.js';
 import { KnownException } from '../exceptions.js';
 import { BaseService } from './BaseService.js';
 export class LogService extends BaseService {

package/dist/{client → service}/TerraformAdapter.js

@@ -1,10 +1,11 @@
 import fs from 'fs';
 import { createHash } from 'node:crypto';
 import path from 'path';
-import { AbortedException, KnownException, ProcessException } from '../exceptions.js';
-import { LocalStateService } from '../service/LocalStateService.js';
-const MAX_ATTEMPTS = 2;
-const RETRYABLE_ERRORS = [
+import { NO_TIMEOUT } from '../client/Cli.js';
+import { AbortedException, KnownException, ProcessException, TimeoutException } from '../exceptions.js';
+import { LocalStateService } from './LocalStateService.js';
+export const MAX_ATTEMPTS = 2;
+export const RETRYABLE_ERRORS = [
     'ConcurrentModificationException',
     'public policies are blocked by the BlockPublicPolicy block public access setting',
     'operation error Lambda: AddPermission, https response error StatusCode: 404',
@@ -14,11 +15,13 @@ function hash(data) {
     return createHash('sha256').update(data).digest('hex');
 }
 export class TerraformAdapter {
+    now;
     cli;
     localStateService;
     backends;
     backend = undefined;
-    constructor(cli, localStateService, backends) {
+    constructor(now, cli, localStateService, backends) {
+        this.now = now;
         this.cli = cli;
         this.localStateService = localStateService;
         this.backends = backends.reduce((acc, backend) => {
@@ -191,9 +194,9 @@ export class TerraformAdapter {
         if (env) {
             args = this.tfArgs(env, args);
         }
-        await this._plan(args, onDemandVars);
+        await this._plan(args, onDemandVars, 1);
     }
-    async _plan(args, onDemandVars, attemptNo = 1) {
+    async _plan(args, onDemandVars, attemptNo) {
         let inputTfVariable = false;
         let tfVarName = '';
         function out_scanner(line) {
@@ -214,7 +217,7 @@ export class TerraformAdapter {
         }
         console.log('Running: terraform plan', ...args, '\n');
         try {
-            await this.cli.run('terraform', ['plan', ...args], out_scanner, in_scanner);
+            await this.cli.run('terraform', ['plan', ...args], NO_TIMEOUT, out_scanner, in_scanner);
         }
         catch (error) {
             if (!(error instanceof ProcessException)) {
@@ -233,11 +236,31 @@ export class TerraformAdapter {
             throw new KnownException(`terraform plan failed with code ${error.code}:\n${error.message}`, { cause: error });
         }
     }
-    async apply(args, attemptNo = 1) {
+    async apply(args, ttl) {
         console.log('Running: terraform apply', ...args, '\n');
+        try {
+            await this._apply(args, ttl, 1);
+        }
+        catch (error) {
+            if (error instanceof TimeoutException) {
+                throw new KnownException('Reached environment ttl while running \'terraform apply\' command\n'
+                    + 'Command was stopped to avoid race condition with deletion process\n'
+                    + 'Please wait env deletion', { cause: error });
+            }
+            throw error;
+        }
+    }
+    async _apply(args, ttl, attemptNo) {
         this.printTime();
+        const nowUtcSeconds = Math.floor(this.now() / 1000);
+        const gracePeriod = 10;
+        const timeout = (ttl - nowUtcSeconds - gracePeriod) * 1000;
+        if (timeout <= 0) {
+            throw new KnownException('TTL expired before terraform apply could start');
+        }
+        console.debug('timeout: ', timeout);
         try {
-            await this.cli.run('terraform', ['apply', ...args]);
+            await this.cli.run('terraform', ['apply', ...args], timeout);
             this.printTime();
         }
         catch (error) {
@@ -246,13 +269,13 @@ export class TerraformAdapter {
             }
             if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
                 console.warn(`Retrying terraform apply due to error: ${error.message}`);
-                return this.apply(args, attemptNo + 1);
+                return this._apply(args, ttl, attemptNo + 1);
             }
             const lockId = this.lockId(error, attemptNo);
             if (lockId) {
                 await this.promptUnlock(lockId);
                 console.info('State unlocked, retrying terraform apply');
-                return this.apply(args, attemptNo + 1);
+                return this._apply(args, ttl, attemptNo + 1);
             }
             throw new KnownException(`terraform apply failed with code ${error.code}:\n${error.message}`, { cause: error });
         }
@@ -270,7 +293,7 @@ export class TerraformAdapter {
         };
         console.log('Running: terraform destroy -auto-approve', ...args, '\n');
         try {
-            await this.cli.run('terraform', ['destroy', '-auto-approve', ...args], scanner);
+            await this.cli.run('terraform', ['destroy', '-auto-approve', ...args], NO_TIMEOUT, scanner);
         }
         catch (error) {
             if (!(error instanceof ProcessException)) {

package/dist/service/index.js

@@ -1,2 +1,3 @@
 export { EnvService } from './EnvService.js';
 export { ConfigService } from './ConfigService.js';
+export { TerraformAdapter } from './TerraformAdapter.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilecustoms/envctl",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "node.js CLI client for manage environments",
   "keywords": [
     "terraform wrapper",