@fishawack/lab-env 5.7.0-beta.1 → 5.7.0-beta.3

package/commands/create/services/aws/elasticache.js

@@ -0,0 +1,159 @@
+const {
+    ElastiCacheClient,
+    CreateCacheSubnetGroupCommand,
+    CreateReplicationGroupCommand,
+    DeleteReplicationGroupCommand,
+    DescribeCacheSubnetGroupsCommand,
+    DescribeReplicationGroupsCommand,
+} = require("@aws-sdk/client-elasticache");
+const { Spinner, poll } = require("../../libs/utilities");
+const { awsClientConfig } = require("../../libs/vars");
+
+const getClient = () => new ElastiCacheClient(awsClientConfig);
+
+module.exports.ensureCacheSubnetGroup = async (privateSubnetIds) => {
+    const name = "fw-auto-private-cache-subnet-group";
+
+    try {
+        await getClient().send(
+            new DescribeCacheSubnetGroupsCommand({
+                CacheSubnetGroupName: name,
+            }),
+        );
+
+        return name;
+    } catch (e) {
+        if (e.name !== "CacheSubnetGroupNotFoundFault") {
+            throw e;
+        }
+    }
+
+    await Spinner.prototype.simple(
+        `Creating cache subnet group ${name}`,
+        () => {
+            return getClient().send(
+                new CreateCacheSubnetGroupCommand({
+                    CacheSubnetGroupName: name,
+                    CacheSubnetGroupDescription:
+                        "Private subnets for lab-env ElastiCache clusters",
+                    SubnetIds: privateSubnetIds,
+                }),
+            );
+        },
+    );
+
+    return name;
+};
+
+module.exports.createCacheCluster = async (
+    name,
+    securityGroupId,
+    subnetGroupName,
+    authToken,
+    tags = [],
+) => {
+    const res = await Spinner.prototype.simple(
+        `Creating ElastiCache cluster ${name}`,
+        () => {
+            return getClient().send(
+                new CreateReplicationGroupCommand({
+                    ReplicationGroupId: name,
+                    ReplicationGroupDescription: `lab-env Valkey cluster for ${name}`,
+                    Engine: "valkey",
+                    EngineVersion: "8.0",
+                    CacheNodeType: "cache.t3.small",
+                    NumCacheClusters: 1,
+                    Port: 6380,
+                    TransitEncryptionEnabled: true,
+                    AuthToken: authToken,
+                    CacheSubnetGroupName: subnetGroupName,
+                    SecurityGroupIds: [securityGroupId],
+                    Tags: [
+                        { Key: "client", Value: process.env.AWS_PROFILE },
+                    ].concat(tags),
+                }),
+            );
+        },
+    );
+
+    return res;
+};
+
+module.exports.waitForCacheCluster = async (name) => {
+    const res = await Spinner.prototype.simple(
+        `Waiting for ElastiCache cluster to become available`,
+        (spinner) => {
+            return poll(
+                async () => {
+                    const { ReplicationGroups } = await getClient().send(
+                        new DescribeReplicationGroupsCommand({
+                            ReplicationGroupId: name,
+                        }),
+                    );
+                    return ReplicationGroups[0];
+                },
+                (group) => group.Status !== "available",
+                undefined,
+                spinner,
+            );
+        },
+    );
+
+    return res;
+};
+
+module.exports.describeCacheCluster = async (name) => {
+    const res = await Spinner.prototype.simple(
+        `Describing ElastiCache cluster ${name}`,
+        () => {
+            return getClient().send(
+                new DescribeReplicationGroupsCommand({
+                    ReplicationGroupId: name,
+                }),
+            );
+        },
+    );
+
+    return res.ReplicationGroups[0];
+};
+
+module.exports.deleteCacheCluster = async (name) => {
+    await Spinner.prototype.simple(
+        `Deleting ElastiCache cluster ${name}`,
+        () => {
+            return getClient().send(
+                new DeleteReplicationGroupCommand({
+                    ReplicationGroupId: name,
+                }),
+            );
+        },
+    );
+};
+
+module.exports.waitForCacheDeletion = async (name) => {
+    await Spinner.prototype.simple(
+        `Waiting for ElastiCache cluster to be deleted`,
+        (spinner) => {
+            return poll(
+                async () => {
+                    try {
+                        const { ReplicationGroups } = await getClient().send(
+                            new DescribeReplicationGroupsCommand({
+                                ReplicationGroupId: name,
+                            }),
+                        );
+                        return ReplicationGroups[0];
+                    } catch (e) {
+                        if (e.name === "ReplicationGroupNotFoundFault") {
+                            return { deleted: true };
+                        }
+                        throw e;
+                    }
+                },
+                (group) => !group.deleted,
+                undefined,
+                spinner,
+            );
+        },
+    );
+};

package/commands/create/services/aws/elasticbeanstalk.js

@@ -1,5 +1,7 @@
 const fs = require("fs-extra");
+const crypto = require("crypto");
 const glob = require("glob");
+const inquirer = require("inquirer");
 const {
     ElasticBeanstalkClient,
     CreateApplicationCommand,
@@ -14,18 +16,26 @@ const {
     UpdateEnvironmentCommand,
     CreateApplicationVersionCommand,
     ListAvailableSolutionStacksCommand,
+    ListTagsForResourceCommand,
+    RestartAppServerCommand,
 } = require("@aws-sdk/client-elastic-beanstalk");
 const { Spinner, poll } = require("../../libs/utilities");
-const { eb } = require("../../libs/vars");
+const { eb, secretGroups, awsClientConfig } = require("../../libs/vars");
+const { template } = require("lodash");
 
-module.exports.createElasticBeanstalkApplication = async (name) => {
-    const client = new ElasticBeanstalkClient({});
+const getClient = () => new ElasticBeanstalkClient(awsClientConfig);
 
+module.exports.createElasticBeanstalkApplication = async (name, tags = []) => {
     let res = await Spinner.prototype.simple(
         `Creating elasticbeanstalk application ${name}`,
         () => {
-            return client.send(
-                new CreateApplicationCommand({ ApplicationName: name }),
+            return getClient().send(
+                new CreateApplicationCommand({
+                    ApplicationName: name,
+                    Tags: [
+                        { Key: "client", Value: process.env.AWS_PROFILE },
+                    ].concat(tags),
+                }),
             );
         },
     );
@@ -34,15 +44,36 @@ module.exports.createElasticBeanstalkApplication = async (name) => {
 };
 
 module.exports.describeEnvironment = async (name) => {
-    const client = new ElasticBeanstalkClient({});
-
-    return client.send(
+    return getClient().send(
         new DescribeEnvironmentsCommand({
             EnvironmentNames: [name],
         }),
     );
 };
 
+module.exports.listEnvironments = async (applicationName) => {
+    const res = await Spinner.prototype.simple(
+        `Retrieving environments for ${applicationName}`,
+        () => {
+            return getClient().send(
+                new DescribeEnvironmentsCommand({
+                    ApplicationName: applicationName,
+                    IncludeDeleted: false,
+                }),
+            );
+        },
+    );
+
+    return (res.Environments || []).filter((e) => e.Status !== "Terminated");
+};
+
+module.exports.getEnvironmentTags = async (environmentArn) => {
+    const res = await getClient().send(
+        new ListTagsForResourceCommand({ ResourceArn: environmentArn }),
+    );
+    return res.ResourceTags || [];
+};
+
 module.exports.createElasticBeanstalkEnvironment = async (
     name,
     { language },
@@ -50,13 +81,12 @@ module.exports.createElasticBeanstalkEnvironment = async (
     OptionSettings,
     CNAMEPrefix,
     tags = [],
+    versionLabel,
 ) => {
-    const client = new ElasticBeanstalkClient({});
-
     const solutions = await Spinner.prototype.simple(
         `Retrieving available solution stacks`,
         () => {
-            return client.send(new ListAvailableSolutionStacksCommand());
+            return getClient().send(new ListAvailableSolutionStacksCommand());
         },
     );
 
@@ -74,21 +104,23 @@ module.exports.createElasticBeanstalkEnvironment = async (
         d.includes(stackName),
     )[0];
 
+    const createParams = {
+        ApplicationName,
+        EnvironmentName: name,
+        SolutionStackName,
+        OptionSettings,
+        CNAMEPrefix,
+        Tags: [{ Key: "client", Value: process.env.AWS_PROFILE }].concat(tags),
+    };
+
+    if (versionLabel) {
+        createParams.VersionLabel = versionLabel;
+    }
+
     await Spinner.prototype.simple(
         `Creating elasticbeanstalk environment ${name}`,
         () => {
-            return client.send(
-                new CreateEnvironmentCommand({
-                    ApplicationName,
-                    EnvironmentName: name,
-                    SolutionStackName,
-                    OptionSettings,
-                    CNAMEPrefix,
-                    Tags: [
-                        { Key: "client", Value: process.env.AWS_PROFILE },
-                    ].concat(tags),
-                }),
-            );
+            return getClient().send(new CreateEnvironmentCommand(createParams));
         },
     );
 
@@ -111,12 +143,10 @@ module.exports.waitForElasticBeanstalkEnvironment = async (
     waitFor = "Ready",
     failIf,
 ) => {
-    const client = new ElasticBeanstalkClient({});
-
     const res = await poll(
         async () =>
             (
-                await client.send(
+                await getClient().send(
                     new DescribeEnvironmentsCommand({
                         EnvironmentNames: [name],
                     }),
@@ -130,12 +160,10 @@ module.exports.waitForElasticBeanstalkEnvironment = async (
 };
 
 module.exports.removeElasticBeanstalkApplication = async (name) => {
-    const client = new ElasticBeanstalkClient({});
-
     await Spinner.prototype.simple(
         `Removing elasticbeanstalk application ${name}`,
         () => {
-            return client.send(
+            return getClient().send(
                 new DeleteApplicationCommand({ ApplicationName: name }),
             );
         },
@@ -143,12 +171,10 @@ module.exports.removeElasticBeanstalkApplication = async (name) => {
 };
 
 module.exports.removeElasticBeanstalkEnvironment = async (name) => {
-    const client = new ElasticBeanstalkClient({});
-
     await Spinner.prototype.simple(
         `Removing elasticbeanstalk environment ${name}`,
         () => {
-            return client.send(
+            return getClient().send(
                 new TerminateEnvironmentCommand({ EnvironmentName: name }),
             );
         },
@@ -165,25 +191,93 @@ module.exports.removeElasticBeanstalkEnvironment = async (name) => {
     );
 };
 
-module.exports.copyElasticBeanstalkConfigs = async (configurations) => {
+module.exports.copyElasticBeanstalkConfigs = async (configurations, branch) => {
     const templates = `${__dirname}/../../templates/elasticbeanstalk`;
+    const templateData = {
+        ...process.env,
+        SECRET_GROUPS: secretGroups.join(" "),
+    };
+
+    const checksumPath = `_IaC/${branch}/.lab-env-checksums.json`;
+    const checksums = fs.existsSync(checksumPath)
+        ? JSON.parse(fs.readFileSync(checksumPath, "utf8"))
+        : {};
+
+    for (const globbed of configurations) {
+        const files = glob.sync(globbed, { cwd: `${templates}` });
+
+        for (const config of files) {
+            const content = fs.readFileSync(`${templates}/${config}`, "utf8");
+            const output = content.includes("<%=")
+                ? template(content, { interpolate: /<%=([\s\S]+?)%>/g })(
+                      templateData,
+                  )
+                : content;
+
+            const dest = `_IaC/${branch}/${config}`;
+            const newHash = crypto
+                .createHash("md5")
+                .update(output)
+                .digest("hex");
+
+            if (fs.existsSync(dest)) {
+                const existing = fs.readFileSync(dest, "utf8");
+
+                if (existing === output) {
+                    checksums[config] = newHash;
+                    continue;
+                }
+
+                const existingHash = crypto
+                    .createHash("md5")
+                    .update(existing)
+                    .digest("hex");
+
+                let shouldOverwrite;
+
+                if (checksums[config] && existingHash === checksums[config]) {
+                    const { overwrite } = await inquirer.prompt([
+                        {
+                            type: "confirm",
+                            name: "overwrite",
+                            message: `${dest} has an updated template, overwrite?`,
+                            default: true,
+                        },
+                    ]);
+                    shouldOverwrite = overwrite;
+                } else {
+                    const { overwrite } = await inquirer.prompt([
+                        {
+                            type: "confirm",
+                            name: "overwrite",
+                            message: `${dest} has been modified, overwrite?`,
+                            default: false,
+                        },
+                    ]);
+                    shouldOverwrite = overwrite;
+                }
+
+                if (!shouldOverwrite) continue;
+            }
+
+            fs.outputFileSync(dest, output);
+            checksums[config] = newHash;
+        }
+    }
 
-    configurations.forEach((globbed) => {
-        glob.sync(globbed, { cwd: `${templates}` }).forEach((config) =>
-            fs.copySync(`${templates}/${config}`, config),
-        );
-    });
+    fs.outputFileSync(checksumPath, JSON.stringify(checksums, null, 2));
 
-    fs.outputFileSync(`.elasticbeanstalk/config.yml`, eb.config());
+    fs.outputFileSync(
+        `_IaC/${branch}/.elasticbeanstalk/config.yml`,
+        eb.config(),
+    );
 };
 
 module.exports.listApplications = async () => {
-    const client = new ElasticBeanstalkClient({});
-
     const res = await Spinner.prototype.simple(
         `Retrieving elasticbeanstalk applications`,
         () => {
-            return client.send(new DescribeApplicationsCommand({}));
+            return getClient().send(new DescribeApplicationsCommand({}));
         },
     );
 
@@ -191,13 +285,11 @@ module.exports.listApplications = async () => {
 };
 
 module.exports.listApplicationVersions = async (applicationName) => {
-    const client = new ElasticBeanstalkClient({});
-
     let versions = [];
     let nextToken;
 
     do {
-        const res = await client.send(
+        const res = await getClient().send(
             new DescribeApplicationVersionsCommand({
                 ApplicationName: applicationName,
                 ...(nextToken ? { NextToken: nextToken } : {}),
@@ -215,9 +307,7 @@ module.exports.createApplicationVersion = async (
     applicationName,
     versionLabel,
 ) => {
-    const client = new ElasticBeanstalkClient({});
-
-    const res = await client.send(
+    const res = await getClient().send(
         new CreateApplicationVersionCommand({
             ApplicationName: applicationName,
             VersionLabel: versionLabel,
@@ -232,9 +322,7 @@ module.exports.deleteApplicationVersion = async (
     applicationName,
     versionLabel,
 ) => {
-    const client = new ElasticBeanstalkClient({});
-
-    await client.send(
+    await getClient().send(
         new DeleteApplicationVersionCommand({
             ApplicationName: applicationName,
             VersionLabel: versionLabel,
@@ -247,12 +335,10 @@ module.exports.describeConfigurationSettings = async (
     applicationName,
     environmentName,
 ) => {
-    const client = new ElasticBeanstalkClient({});
-
     const res = await Spinner.prototype.simple(
         `Retrieving configuration for ${environmentName}`,
         () => {
-            return client.send(
+            return getClient().send(
                 new DescribeConfigurationSettingsCommand({
                     ApplicationName: applicationName,
                     EnvironmentName: environmentName,
@@ -269,12 +355,10 @@ module.exports.updateEnvironmentSettings = async (
     optionSettings = [],
     optionsToRemove = [],
 ) => {
-    const client = new ElasticBeanstalkClient({});
-
     await Spinner.prototype.simple(
         `Updating environment ${environmentName}`,
         () => {
-            return client.send(
+            return getClient().send(
                 new UpdateEnvironmentCommand({
                     EnvironmentName: environmentName,
                     OptionSettings: optionSettings,
@@ -284,3 +368,16 @@ module.exports.updateEnvironmentSettings = async (
         },
     );
 };
+
+module.exports.restartAppServer = async (environmentName) => {
+    await Spinner.prototype.simple(
+        `Restarting app server for ${environmentName}`,
+        () => {
+            return getClient().send(
+                new RestartAppServerCommand({
+                    EnvironmentName: environmentName,
+                }),
+            );
+        },
+    );
+};