@gershy/lilac 0.0.12 → 0.0.13

package/cmp/cjs/soil/soil.js

@@ -0,0 +1,291 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Soil = void 0;
+const disk_1 = require("@gershy/disk");
+const nodejs_proc_1 = __importDefault(require("@gershy/nodejs-proc"));
+const main_ts_1 = require("../main.js");
+const util_retry_1 = __importDefault(require("@gershy/util-retry"));
+const clearing_1 = require("@gershy/clearing");
+const util_http_1 = __importDefault(require("@gershy/util-http"));
+const aws_ts_1 = require("../util/aws.js");
+var Soil;
+(function (Soil) {
+    class Base {
+        registry;
+        constructor(args) {
+            this.registry = args.registry;
+        }
+        async getTerraformPetals(ctx) {
+            throw Error('not implemented');
+        }
+    }
+    Soil.Base = Base;
+    ;
+    class LocalStack extends Base {
+        static localStackInternalPort = 4566;
+        aws;
+        localStackDocker;
+        procArgs;
+        constructor(args) {
+            super(args);
+            this.aws = args.aws;
+            this.localStackDocker = {
+                image: 'localstack/localstack:latest',
+                port: LocalStack.localStackInternalPort,
+                containerName: 'gershyLilacLocalStack'
+            }[merge](args.localStackDocker ?? {});
+            this.procArgs = { cwd: disk_1.rootFact, env: process.env };
+        }
+        getAwsServices() {
+            // Note that "overhead" services are essential for initializing localstack:
+            // - s3 + ddb used for terraform state locking
+            // - sts is used for credential validation
+            // - iam is needed for role creation
+            const overheadAwsServices = ['s3', 'dynamodb', 'sts', 'iam'];
+            return new Set([...overheadAwsServices, ...this.registry.getAwsServices()]);
+        }
+        async getDockerContainers() {
+            const { containerName } = this.localStackDocker;
+            const dockerPs = await (0, nodejs_proc_1.default)(`docker ps -a --filter "name=${containerName}" --format "{{.Names}},{{.State}}"`, this.procArgs);
+            return dockerPs
+                .output
+                .split('\n')[map](v => v.trim() || clearing_1.skip)[map](v => v[cut](',', 1))[map](([name, state]) => ({ name, state }))
+            // Exclude containers which match the `docker ps` filter but don't have the prefix
+            [map](v => (v.name === containerName || v.name[hasHead](`${containerName}-`)) ? v : clearing_1.skip);
+        }
+        run(args) {
+            return args.logger.scope('localStack', {}, async (logger) => {
+                // Run a localStack container in docker, enabling `terraform apply` on an aws-like target
+                const { image, port, containerName } = this.localStackDocker;
+                const awsServices = this.getAwsServices();
+                await logger.scope('dockerDeploy', { image, containerName, port }, async (logger) => {
+                    await (0, nodejs_proc_1.default)('docker info', this.procArgs).catch(({ output }) => Error('docker unavailable')[fire]({ output }));
+                    logger.log({ $$: 'dockerActive' });
+                    const containers = await this.getDockerContainers();
+                    let state = containers.find(c => c.name === containerName)?.state ?? 'nonexistent';
+                    // First if a container already exists ensure it's compatible with our given config
+                    if (['running', 'paused', 'exited'][has](state)) {
+                        const isExistingContainerReusable = await (async () => {
+                            const { output: inspectJson } = await (0, nodejs_proc_1.default)(`docker inspect ${containerName}`, this.procArgs);
+                            const [containerInfo] = JSON.parse(inspectJson);
+                            console.log('DOCKER INSPECT', containerInfo);
+                            const containerImage = containerInfo.Config.Image;
+                            const containerEnv = containerInfo.Config.Env[toObj](v => v[cut]('=', 1));
+                            const containerPort = Number(containerInfo.HostConfig.PortBindings[`${LocalStack.localStackInternalPort}/tcp`]?.[0]?.HostPort ?? 0);
+                            const services = (containerEnv.SERVICES ?? '').split(',').sort().join(',');
+                            return true
+                                && containerImage === image
+                                && containerPort === port
+                                && containerEnv.DEFAULT_REGION === this.aws.region
+                                && services === awsServices[toArr](v => v).sort().join(',');
+                        })();
+                        if (isExistingContainerReusable) {
+                            if (state === 'paused')
+                                await (0, nodejs_proc_1.default)(`docker unpause ${containerName}`, this.procArgs);
+                            if (state === 'exited')
+                                await (0, nodejs_proc_1.default)(`docker start ${containerName}`, this.procArgs);
+                            logger.log({ $$: 'containerReused' });
+                            state = 'running';
+                        }
+                        else {
+                            await this.end({ containers });
+                            logger.log({ $$: 'previousLocalStackRemoved', containers });
+                            state = 'nonexistent';
+                        }
+                    }
+                    if (state === 'nonexistent') {
+                        const runCmd = String[baseline](`
+            | docker run
+            | --rm
+            | -d
+            | --privileged${'' /* TODO: consider removing? */}
+            | --name ${containerName}
+            | -p ${port}:${LocalStack.localStackInternalPort}
+            | -v /var/run/docker.sock:/var/run/docker.sock
+            | -e SERVICES=${awsServices[toArr](v => v).join(',')}
+            | -e DEFAULT_REGION=${this.aws.region}
+            | ${image}
+          `).split('\n')[map](ln => ln.trim() || clearing_1.skip).join(' ');
+                        await (0, nodejs_proc_1.default)(runCmd, this.procArgs);
+                        state = 'running';
+                    }
+                    if (state !== 'running')
+                        throw Error('container state unexpected')[mod]({ state });
+                });
+                const readyEndpoint = {
+                    $req: null,
+                    $res: null,
+                    netProc: { proto: 'http', addr: 'localhost', port },
+                    path: ['_localstack', 'health'],
+                    method: 'get'
+                };
+                const { val: { services } } = await (0, util_retry_1.default)({
+                    // TODO: If the container already exists, it seems its "s3" and "sts" services become unavailable when we try to reinitialize Soil pointing at it??
+                    attempts: 20,
+                    delay: n => Math.min(500, 50 * n),
+                    fn: async () => {
+                        // Retry all failures and non-200s
+                        const res = await (0, util_http_1.default)(readyEndpoint, {}).catch(err => err[fire]({ retry: true }));
+                        if (res.code !== 200)
+                            throw Error('unhealthy')[mod]({ retry: true });
+                        const { ya = [], no = [] } = res.body.services[group](v => v === 'available' ? 'ya' : 'no')[map](group => group[toArr]((v, k) => k));
+                        const missingServices = no[map](svc => awsServices.has(svc) ? svc : clearing_1.skip);
+                        if (missingServices.length)
+                            throw Error('services unavailable')[mod]({ missingServices })[mod]({ retry: true });
+                        return { services: ya };
+                    },
+                    retryable: err => !!err.retry,
+                }).catch(err => err[fire]({ numErrs: err.errs.length, errs: null }));
+                logger.log({ $$: 'localStackActive', services });
+                return {
+                    aws: { services: [...awsServices], region: this.aws.region, },
+                    netProc: { proto: 'http', addr: 'localhost', port },
+                    url: `http://localhost:${port}`
+                };
+            });
+        }
+        async end(args) {
+            const containers = args?.containers ?? await this.getDockerContainers();
+            await (0, nodejs_proc_1.default)(`docker rm -f ${containers.map(c => c.name).join(' ')}`, this.procArgs)
+                .catch(err => {
+                console.log('ERROR ENDING LOCALSTACK DOCKER CONTAINER:\n', err.output);
+                return;
+            });
+            return containers;
+        }
+        async getTerraformPetals(ctx) {
+            const { aws } = this;
+            const awsServices = [...this.getAwsServices()];
+            const netProc = { proto: 'http', addr: 'localhost', port: this.localStackDocker.port };
+            const localStackUrl = `${netProc.proto}://${netProc.addr}:${netProc.port}`;
+            return {
+                boot: () => [
+                    new main_ts_1.PetalTerraform.Terraform({
+                        $requiredProviders: {
+                            aws: {
+                                source: 'hashicorp/aws',
+                                version: `~> 5.0`
+                            }
+                        }
+                    }),
+                    new main_ts_1.PetalTerraform.Provider('aws', {
+                        region: aws.region,
+                        skipCredentialsValidation: true,
+                        skipRequestingAccountId: true,
+                        s3UsePathStyle: true, // Otherwise requests can go to "bucket.s3.amazonaws.com", outside localStack
+                        // Note our localStack setup always includes s3 and ddb (required for tf state storage)
+                        $endpoints: awsServices[toObj](svc => [svc, localStackUrl])
+                    })
+                ],
+                main: function* (args) {
+                    yield new main_ts_1.PetalTerraform.Terraform({
+                        $requiredProviders: {
+                            aws: {
+                                source: 'hashicorp/aws',
+                                version: `~> 5.0` // Consider parameterizing??
+                            }
+                        },
+                        '$backend.s3': {
+                            region: aws.region,
+                            encrypt: true,
+                            bucket: args.s3Name,
+                            key: `tf`,
+                            dynamodbTable: args.ddbName,
+                            usePathStyle: true,
+                            // Point the S3 backend at LocalStack when testing
+                            endpoints: awsServices[toObj](svc => [svc, localStackUrl]),
+                        }
+                    });
+                    for (const { term } of aws_ts_1.regions)
+                        yield new main_ts_1.PetalTerraform.Provider('aws', {
+                            region: term,
+                            skipCredentialsValidation: true,
+                            skipRequestingAccountId: true,
+                            // Omit the alias for the default provider!
+                            ...(term !== aws.region && { alias: term.split('-').join('_') }),
+                            // Point providers at LocalStack when testing
+                            s3UsePathStyle: true,
+                            $endpoints: awsServices[toObj](svc => [svc, localStackUrl])
+                        });
+                }
+            };
+        }
+    }
+    Soil.LocalStack = LocalStack;
+    ;
+    class AwsCloud extends Base {
+        aws;
+        constructor(args) {
+            super(args);
+            this.aws = args.aws;
+        }
+        async getTerraformPetals(ctx) {
+            const { aws } = this;
+            return {
+                boot: function* () {
+                    const tfAwsCredsFile = new main_ts_1.PetalTerraform.File('creds.ini', String[baseline](`
+            | [default]
+            | aws_region            = ${aws.region}
+            | aws_access_key_id     = ${aws.accessKey.id}
+            | aws_secret_access_key = ${aws.accessKey['!secret']}
+          `));
+                    yield tfAwsCredsFile;
+                    yield new main_ts_1.PetalTerraform.Terraform({
+                        $requiredProviders: {
+                            aws: {
+                                source: 'hashicorp/aws',
+                                version: `~> 5.0`
+                            }
+                        }
+                    });
+                    yield new main_ts_1.PetalTerraform.Provider('aws', {
+                        sharedCredentialsFiles: [tfAwsCredsFile.refStr()],
+                        profile: 'default', // References a section within the credentials file
+                        region: aws.region,
+                    });
+                },
+                main: function* (args) {
+                    const credFileProfile = 'default';
+                    const tfAwsCredsFile = new main_ts_1.PetalTerraform.File('creds.ini', String[baseline](`
+            | [${credFileProfile}]
+            | aws_region            = ${aws.region}
+            | aws_access_key_id     = ${aws.accessKey.id}
+            | aws_secret_access_key = ${aws.accessKey['!secret']}
+          `));
+                    yield tfAwsCredsFile;
+                    yield new main_ts_1.PetalTerraform.Terraform({
+                        $requiredProviders: {
+                            aws: {
+                                source: 'hashicorp/aws',
+                                version: `~> 5.0` // Consider parameterizing??
+                            }
+                        },
+                        '$backend.s3': {
+                            sharedCredentialsFiles: [tfAwsCredsFile.refStr()],
+                            profile: credFileProfile,
+                            region: aws.region,
+                            encrypt: true,
+                            bucket: args.s3Name,
+                            key: `tf`,
+                            dynamodbTable: args.ddbName
+                        }
+                    });
+                    for (const { term } of aws_ts_1.regions)
+                        yield new main_ts_1.PetalTerraform.Provider('aws', {
+                            sharedCredentialsFiles: [tfAwsCredsFile.refStr()],
+                            profile: credFileProfile,
+                            region: term,
+                            // Omit the alias for the default provider!
+                            ...(term !== aws.region && { alias: term.split('-').join('_') }),
+                        });
+                }
+            };
+        }
+    }
+    Soil.AwsCloud = AwsCloud;
+    ;
+})(Soil || (exports.Soil = Soil = {}));
+;

package/cmp/cjs/util/aws.d.ts

@@ -1,5 +1,19 @@
 export declare const capitalKeys: (v: any) => any;
-export declare const regions: {
-    term: string;
-    mini: string;
-}[];
+export declare const regions: readonly [{
+    term: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
+    mini: `${"ca" | "us"}${"c" | "u"}${"c" | "u" | "e" | "w"}${"1" | "2"}`;
+}, {
+    term: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
+    mini: `${"ca" | "us"}${"c" | "u"}${"c" | "u" | "e" | "w"}${"1" | "2"}`;
+}, {
+    term: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
+    mini: `${"ca" | "us"}${"c" | "u"}${"c" | "u" | "e" | "w"}${"1" | "2"}`;
+}, {
+    term: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
+    mini: `${"ca" | "us"}${"c" | "u"}${"c" | "u" | "e" | "w"}${"1" | "2"}`;
+}, {
+    term: "ca-central-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2";
+    mini: `${"ca" | "us"}${"c" | "u"}${"c" | "u" | "e" | "w"}${"1" | "2"}`;
+}];
+export type RegionTerm = (typeof regions)[number]['term'];
+export type RegionMini = (typeof regions)[number]['mini'];

package/cmp/cjs/util/aws.js

@@ -57,5 +57,8 @@ exports.regions = [
 ][map](region => {
     const [c, z, num] = region.split('-');
     const [dir0, dir1 = dir0] = z.match(/central|north|south|east|west/g);
-    return { term: region, mini: [c, dir0[0], dir1[0], num].join('') };
+    return {
+        term: region,
+        mini: [c, dir0[0], dir1[0], num].join('')
+    };
 });

package/cmp/cjs/util/procTerraform.d.ts

@@ -1,8 +1,10 @@
-import { rootFact } from '@gershy/disk';
-import { ProcOpts } from '@gershy/util-nodejs-proc';
-type Fact = typeof rootFact;
-declare const _default: (fact: Fact, cmd: string, opts?: ProcOpts) => Promise<{
-    logDb: import("@gershy/disk").Fact;
+import { Fact } from '@gershy/disk';
+import { ProcOpts } from '@gershy/nodejs-proc';
+export type ProcTerraformArgs = ProcOpts & {};
+declare const _default: (fact: Fact, cmd: string, opts?: ProcTerraformArgs) => Promise<{
+    logDb: Fact;
     output: string;
-}>;
+}> & {
+    proc: import("child_process").ChildProcessWithoutNullStreams;
+};
 export default _default;

package/cmp/cjs/util/procTerraform.js

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const util_nodejs_proc_1 = __importDefault(require("@gershy/util-nodejs-proc"));
-exports.default = (fact, cmd, opts) => {
+const nodejs_proc_1 = __importDefault(require("@gershy/nodejs-proc"));
+exports.default = (fact, cmd, opts = {}) => {
     const numTailingTfLogLines = 20;
     const writeLog = async (result) => {
         const [yr, mo, dy, hr, mn, sc, ms] = new Date().toISOString().match(/([0-9]{4})[-]([0-9]{2})[-]([0-9]{2})[T]([0-9]{2})[:]([0-9]{2})[:]([0-9]{2})[.]([0-9]+)[Z]/).slice(1);
@@ -13,12 +13,13 @@ exports.default = (fact, cmd, opts) => {
         await logDb.setData(result);
         return logDb;
     };
-    return (0, util_nodejs_proc_1.default)(cmd, {
+    const prm = (0, nodejs_proc_1.default)(cmd, {
         timeoutMs: 0,
         ...opts,
         cwd: fact,
         env: { TF_DATA_DIR: '' }
-    }).then(async (result) => {
+    });
+    return Object.assign(prm.then(async (result) => {
         const logDb = await writeLog(result.output);
         return { logDb, output: result.output.split('\n').slice(-numTailingTfLogLines).join('\n') };
     }, async (err) => {
@@ -27,5 +28,5 @@ exports.default = (fact, cmd, opts) => {
             logDb,
             ...(err.output ? { output: err.output.split('\n').slice(-numTailingTfLogLines).join('\n') } : { cause: err })
         });
-    });
+    }), { proc: prm.proc });
 };

package/cmp/cjs/util/superIterable.d.ts

@@ -0,0 +1 @@
+export type SuperIterable<T> = Iterable<T> | Promise<Iterable<T>> | AsyncIterable<T>;

package/cmp/cjs/util/superIterable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cmp/cjs/util/terraform.js

@@ -1,4 +1,5 @@
 "use strict";
+// TODO: Flower definers (Lilac consumers) will want to use these - make sure they're well-exposed
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.json = exports.embed = void 0;
 const embed = (v) => '${' + v + '}';

package/cmp/mjs/main.d.ts

@@ -2,27 +2,22 @@ import '../sideEffects.js';
 import { PetalTerraform } from './petal/terraform/terraform.ts';
 import Logger from '@gershy/logger';
 import { Fact } from '@gershy/disk';
+import { Soil } from './soil/soil.ts';
+import { SuperIterable } from './util/superIterable.ts';
 export type Context = {
     name: string;
     logger: Logger;
     fact: Fact;
     patioFact: Fact;
-    aws: {
-        accountId: string;
-        accessKey: {
-            id: string;
-            '!secret': string;
-        };
-        region: string;
-    };
     maturity: string;
     debug: boolean;
     pfx: string;
 };
 export declare class Flower {
+    static getAwsServices(): Soil.LocalStackAwsService[];
     constructor();
     getDependencies(): Generator<Flower>;
-    getPetals(ctx: Context): Iterable<PetalTerraform.Base> | AsyncIterable<PetalTerraform.Base>;
+    getPetals(ctx: Context): SuperIterable<PetalTerraform.Base>;
 }
 type RegistryFlowers<R extends Registry<any>, M extends 'real' | 'test'> = R extends Registry<infer Flowers> ? {
     [K in keyof Flowers]: Flowers[K][M];
@@ -33,6 +28,7 @@ export declare class Registry<Flowers extends Obj<{
 }> = Obj<never>> {
     private flowers;
     constructor(flowers: Flowers);
+    getAwsServices(): Soil.LocalStackAwsService[];
     add<MoreFlowers extends Obj<{
         real: typeof Flower;
         test: typeof Flower;
@@ -41,32 +37,23 @@ export declare class Registry<Flowers extends Obj<{
 }
 export declare class Garden<Reg extends Registry<any>> {
     private ctx;
-    private registry;
-    private define;
+    private reg;
+    private def;
     constructor(args: {
-        name: string;
-        logger: Logger;
-        fact: Fact;
-        patioFact: Fact;
-        aws: {
-            accountId: string;
-            accessKey: {
-                id: string;
-                '!secret': string;
-            };
-            region: string;
-        };
-        maturity: string;
-        debug: boolean;
-        pfx: string;
+        context: Context;
         registry: Reg;
-        define: Garden<Reg>['define'];
+        define: Garden<Reg>['def'];
     });
     private getPetals;
-    prepare(): Promise<Obj<Fact>>;
+    genTerraform(deployTarget: Soil.Base): Promise<Obj<Fact>>;
     private terraformInit;
     private terraformPlan;
     private terraformApply;
-    grow(mode: 'real' | 'test'): Promise<void>;
+    grow(deploy: {
+        type: 'real';
+        soil: Soil.Base;
+    } | {
+        type: 'test';
+    }): Promise<void>;
 }
 export * from './petal/terraform/terraform.ts';