@fishawack/lab-env 5.7.0-beta.2 → 5.7.0-beta.4

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

@@ -20,14 +20,15 @@ const {
     DescribeInternetGatewaysCommand,
 } = require("@aws-sdk/client-ec2");
 const { Spinner, poll } = require("../../libs/utilities");
+const { awsClientConfig } = require("../../libs/vars");
 
-module.exports.getKeyPair = async (KeyName) => {
-    const client = new EC2Client({});
+const getClient = () => new EC2Client(awsClientConfig);
 
+module.exports.getKeyPair = async (KeyName) => {
     let res = await Spinner.prototype.simple(
         `Retrieving the KeyPair ${KeyName}`,
         () => {
-            return client.send(
+            return getClient().send(
                 new DescribeKeyPairsCommand({ KeyNames: [KeyName] }),
             );
         },
@@ -37,15 +38,13 @@ module.exports.getKeyPair = async (KeyName) => {
 };
 
 module.exports.createRDSSecurityGroup = async (name, tags = []) => {
-    const client = new EC2Client({});
-
     const groupName = `${name}-rds`;
 
     try {
         const sg = await Spinner.prototype.simple(
             `Creating security group ${groupName}`,
             () => {
-                return client.send(
+                return getClient().send(
                     new CreateSecurityGroupCommand({
                         GroupName: groupName,
                         Description: `RDS access for ${name}`,
@@ -84,12 +83,10 @@ module.exports.authorizeRDSIngress = async (
     rdsSecurityGroupId,
     sourceSecurityGroupId,
 ) => {
-    const client = new EC2Client({});
-
     await Spinner.prototype.simple(
         `Adding MySQL inbound rule from EB security group`,
         () => {
-            return client.send(
+            return getClient().send(
                 new AuthorizeSecurityGroupIngressCommand({
                     GroupId: rdsSecurityGroupId,
                     IpPermissions: [
@@ -116,12 +113,10 @@ module.exports.revokeRDSIngress = async (
     rdsSecurityGroupId,
     sourceSecurityGroupId,
 ) => {
-    const client = new EC2Client({});
-
     await Spinner.prototype.simple(
         `Removing MySQL inbound rule from RDS security group`,
         () => {
-            return client.send(
+            return getClient().send(
                 new RevokeSecurityGroupIngressCommand({
                     GroupId: rdsSecurityGroupId,
                     IpPermissions: [
@@ -143,15 +138,13 @@ module.exports.revokeRDSIngress = async (
 };
 
 module.exports.createOpenSearchSecurityGroup = async (name, tags = []) => {
-    const client = new EC2Client({});
-
     const groupName = `${name}-os`;
 
     try {
         const sg = await Spinner.prototype.simple(
             `Creating security group ${groupName}`,
             () => {
-                return client.send(
+                return getClient().send(
                     new CreateSecurityGroupCommand({
                         GroupName: groupName,
                         Description: `OpenSearch access for ${name}`,
@@ -190,12 +183,10 @@ module.exports.authorizeOpenSearchIngress = async (
     osSecurityGroupId,
     sourceSecurityGroupId,
 ) => {
-    const client = new EC2Client({});
-
     await Spinner.prototype.simple(
         `Adding HTTPS inbound rule from EB security group`,
         () => {
-            return client.send(
+            return getClient().send(
                 new AuthorizeSecurityGroupIngressCommand({
                     GroupId: osSecurityGroupId,
                     IpPermissions: [
@@ -222,12 +213,10 @@ module.exports.revokeOpenSearchIngress = async (
     osSecurityGroupId,
     sourceSecurityGroupId,
 ) => {
-    const client = new EC2Client({});
-
     await Spinner.prototype.simple(
         `Removing HTTPS inbound rule from OpenSearch security group`,
         () => {
-            return client.send(
+            return getClient().send(
                 new RevokeSecurityGroupIngressCommand({
                     GroupId: osSecurityGroupId,
                     IpPermissions: [
@@ -248,13 +237,111 @@ module.exports.revokeOpenSearchIngress = async (
     );
 };
 
-module.exports.findSecurityGroupByTag = async (filters = []) => {
-    const client = new EC2Client({});
+module.exports.createCacheSecurityGroup = async (name, tags = []) => {
+    const groupName = `${name}-cache`;
 
+    try {
+        const sg = await Spinner.prototype.simple(
+            `Creating security group ${groupName}`,
+            () => {
+                return getClient().send(
+                    new CreateSecurityGroupCommand({
+                        GroupName: groupName,
+                        Description: `ElastiCache access for ${name}`,
+                        TagSpecifications: [
+                            {
+                                ResourceType: "security-group",
+                                Tags: [
+                                    {
+                                        Key: "Name",
+                                        Value: groupName,
+                                    },
+                                    {
+                                        Key: "client",
+                                        Value: process.env.AWS_PROFILE,
+                                    },
+                                ].concat(tags),
+                            },
+                        ],
+                    }),
+                );
+            },
+        );
+
+        return sg.GroupId;
+    } catch (e) {
+        if (e.Code === "InvalidGroup.Duplicate") {
+            const existing =
+                await module.exports.findSecurityGroupByName(groupName);
+            return existing.GroupId;
+        }
+        throw e;
+    }
+};
+
+module.exports.authorizeCacheIngress = async (
+    cacheSecurityGroupId,
+    sourceSecurityGroupId,
+) => {
+    await Spinner.prototype.simple(
+        `Adding Redis inbound rule from EB security group`,
+        () => {
+            return getClient().send(
+                new AuthorizeSecurityGroupIngressCommand({
+                    GroupId: cacheSecurityGroupId,
+                    IpPermissions: [
+                        {
+                            IpProtocol: "tcp",
+                            FromPort: 6380,
+                            ToPort: 6380,
+                            UserIdGroupPairs: [
+                                {
+                                    GroupId: sourceSecurityGroupId,
+                                    Description:
+                                        "Redis/Valkey access for EB instances",
+                                },
+                            ],
+                        },
+                    ],
+                }),
+            );
+        },
+    );
+};
+
+module.exports.revokeCacheIngress = async (
+    cacheSecurityGroupId,
+    sourceSecurityGroupId,
+) => {
+    await Spinner.prototype.simple(
+        `Removing Redis inbound rule from cache security group`,
+        () => {
+            return getClient().send(
+                new RevokeSecurityGroupIngressCommand({
+                    GroupId: cacheSecurityGroupId,
+                    IpPermissions: [
+                        {
+                            IpProtocol: "tcp",
+                            FromPort: 6380,
+                            ToPort: 6380,
+                            UserIdGroupPairs: [
+                                {
+                                    GroupId: sourceSecurityGroupId,
+                                },
+                            ],
+                        },
+                    ],
+                }),
+            );
+        },
+    );
+};
+
+module.exports.findSecurityGroupByTag = async (filters = []) => {
     const res = await Spinner.prototype.simple(
         `Looking up security group by filters`,
         () => {
-            return client.send(
+            return getClient().send(
                 new DescribeSecurityGroupsCommand({
                     Filters: filters,
                 }),
@@ -266,12 +353,10 @@ module.exports.findSecurityGroupByTag = async (filters = []) => {
 };
 
 module.exports.findSecurityGroupByName = async (name) => {
-    const client = new EC2Client({});
-
     const res = await Spinner.prototype.simple(
         `Looking up security group ${name}`,
         () => {
-            return client.send(
+            return getClient().send(
                 new DescribeSecurityGroupsCommand({
                     Filters: [{ Name: "group-name", Values: [name] }],
                 }),
@@ -283,23 +368,21 @@ module.exports.findSecurityGroupByName = async (name) => {
 };
 
 module.exports.deleteSecurityGroup = async (groupId) => {
-    const client = new EC2Client({});
-
     await Spinner.prototype.simple(`Deleting security group ${groupId}`, () => {
-        return client.send(
+        return getClient().send(
             new DeleteSecurityGroupCommand({ GroupId: groupId }),
         );
     });
 };
 
-const discoverPublicSubnets = async (client, vpcId, excludeIds, azs) => {
-    const { Subnets: allSubnets } = await client.send(
+const discoverPublicSubnets = async (vpcId, excludeIds, azs) => {
+    const { Subnets: allSubnets } = await getClient().send(
         new DescribeSubnetsCommand({
             Filters: [{ Name: "vpc-id", Values: [vpcId] }],
         }),
     );
 
-    const { RouteTables } = await client.send(
+    const { RouteTables } = await getClient().send(
         new DescribeRouteTablesCommand({
             Filters: [{ Name: "vpc-id", Values: [vpcId] }],
         }),
@@ -334,10 +417,8 @@ const discoverPublicSubnets = async (client, vpcId, excludeIds, azs) => {
 };
 
 module.exports.ensurePrivateSubnets = async () => {
-    const client = new EC2Client({});
-
     // Get default VPC
-    const { Vpcs } = await client.send(
+    const { Vpcs } = await getClient().send(
         new DescribeVpcsCommand({
             Filters: [{ Name: "isDefault", Values: ["true"] }],
         }),
@@ -351,7 +432,7 @@ module.exports.ensurePrivateSubnets = async () => {
     const vpcId = vpc.VpcId;
 
     // Preflight: check all private networking resources
-    const { Subnets: existingSubnets } = await client.send(
+    const { Subnets: existingSubnets } = await getClient().send(
         new DescribeSubnetsCommand({
             Filters: [
                 { Name: "vpc-id", Values: [vpcId] },
@@ -360,7 +441,7 @@ module.exports.ensurePrivateSubnets = async () => {
         }),
     );
 
-    const { NatGateways: allNats } = await client.send(
+    const { NatGateways: allNats } = await getClient().send(
         new DescribeNatGatewaysCommand({
             Filter: [
                 { Name: "vpc-id", Values: [vpcId] },
@@ -372,7 +453,7 @@ module.exports.ensurePrivateSubnets = async () => {
         (n) => n.State !== "deleted" && n.State !== "deleting",
     );
 
-    const { RouteTables: existingRtbs } = await client.send(
+    const { RouteTables: existingRtbs } = await getClient().send(
         new DescribeRouteTablesCommand({
             Filters: [
                 { Name: "vpc-id", Values: [vpcId] },
@@ -409,7 +490,6 @@ module.exports.ensurePrivateSubnets = async () => {
     // All resources exist — nothing to do
     if (!needsSubnets && !needsNats && !needsRtbs) {
         const publicSubnetIds = await discoverPublicSubnets(
-            client,
             vpcId,
             existingSubnets.map((s) => s.SubnetId),
             existingSubnets.slice(0, 2).map((s) => s.AvailabilityZone),
@@ -430,7 +510,7 @@ module.exports.ensurePrivateSubnets = async () => {
             azs = existingSubnets.slice(0, 2).map((s) => s.AvailabilityZone);
         } else {
             spinner.ora.text = "Discovering availability zones";
-            const { AvailabilityZones } = await client.send(
+            const { AvailabilityZones } = await getClient().send(
                 new DescribeAvailabilityZonesCommand({
                     Filters: [{ Name: "state", Values: ["available"] }],
                 }),
@@ -446,7 +526,7 @@ module.exports.ensurePrivateSubnets = async () => {
         let privateSubnetIds;
         if (needsSubnets) {
             spinner.ora.text = "Discovering available CIDR blocks";
-            const { Subnets: allSubnets } = await client.send(
+            const { Subnets: allSubnets } = await getClient().send(
                 new DescribeSubnetsCommand({
                     Filters: [{ Name: "vpc-id", Values: [vpcId] }],
                 }),
@@ -504,7 +584,7 @@ module.exports.ensurePrivateSubnets = async () => {
             privateSubnetIds = [];
             for (let i = 0; i < 2; i++) {
                 spinner.ora.text = `Creating private subnet in ${azs[i]}`;
-                const subnet = await client.send(
+                const subnet = await getClient().send(
                     new CreateSubnetCommand({
                         VpcId: vpcId,
                         CidrBlock: availableBlocks[i],
@@ -534,7 +614,7 @@ module.exports.ensurePrivateSubnets = async () => {
         if (needsNats) {
             // Find public subnets per AZ
             spinner.ora.text = "Identifying public subnets";
-            const { InternetGateways } = await client.send(
+            const { InternetGateways } = await getClient().send(
                 new DescribeInternetGatewaysCommand({
                     Filters: [{ Name: "attachment.vpc-id", Values: [vpcId] }],
                 }),
@@ -544,13 +624,13 @@ module.exports.ensurePrivateSubnets = async () => {
                 throw new Error("No Internet Gateway found on default VPC");
             }
 
-            const { Subnets: vpcSubnets } = await client.send(
+            const { Subnets: vpcSubnets } = await getClient().send(
                 new DescribeSubnetsCommand({
                     Filters: [{ Name: "vpc-id", Values: [vpcId] }],
                 }),
             );
 
-            const { RouteTables } = await client.send(
+            const { RouteTables } = await getClient().send(
                 new DescribeRouteTablesCommand({
                     Filters: [{ Name: "vpc-id", Values: [vpcId] }],
                 }),
@@ -597,7 +677,7 @@ module.exports.ensurePrivateSubnets = async () => {
             natGatewayIds = [];
             for (let i = 0; i < 2; i++) {
                 spinner.ora.text = `Allocating Elastic IP for NAT gateway in ${azs[i]}`;
-                const eip = await client.send(
+                const eip = await getClient().send(
                     new AllocateAddressCommand({
                         Domain: "vpc",
                         TagSpecifications: [
@@ -616,7 +696,7 @@ module.exports.ensurePrivateSubnets = async () => {
                 );
 
                 spinner.ora.text = `Creating NAT gateway in ${azs[i]}`;
-                const nat = await client.send(
+                const nat = await getClient().send(
                     new CreateNatGatewayCommand({
                         SubnetId: publicSubnetsByAz[azs[i]],
                         AllocationId: eip.AllocationId,
@@ -642,7 +722,7 @@ module.exports.ensurePrivateSubnets = async () => {
                 spinner.ora.text = `Waiting for NAT gateway in ${azs[i]} to become available`;
                 await poll(
                     async () => {
-                        const res = await client.send(
+                        const res = await getClient().send(
                             new DescribeNatGatewaysCommand({
                                 NatGatewayIds: [natGatewayIds[i]],
                             }),
@@ -660,7 +740,7 @@ module.exports.ensurePrivateSubnets = async () => {
         if (needsRtbs) {
             for (let i = 0; i < 2; i++) {
                 spinner.ora.text = `Creating route table for ${azs[i]}`;
-                const rt = await client.send(
+                const rt = await getClient().send(
                     new CreateRouteTableCommand({
                         VpcId: vpcId,
                         TagSpecifications: [
@@ -679,7 +759,7 @@ module.exports.ensurePrivateSubnets = async () => {
                 );
 
                 spinner.ora.text = `Adding NAT gateway route for ${azs[i]}`;
-                await client.send(
+                await getClient().send(
                     new CreateRouteCommand({
                         RouteTableId: rt.RouteTable.RouteTableId,
                         DestinationCidrBlock: "0.0.0.0/0",
@@ -688,7 +768,7 @@ module.exports.ensurePrivateSubnets = async () => {
                 );
 
                 spinner.ora.text = `Associating route table with private subnet in ${azs[i]}`;
-                await client.send(
+                await getClient().send(
                     new AssociateRouteTableCommand({
                         RouteTableId: rt.RouteTable.RouteTableId,
                         SubnetId: privateSubnetIds[i],
@@ -700,7 +780,6 @@ module.exports.ensurePrivateSubnets = async () => {
         spinner.ora.succeed("Private subnets configured");
 
         const publicSubnetIds = await discoverPublicSubnets(
-            client,
             vpcId,
             privateSubnetIds,
             azs,

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,
+            );
+        },
+    );
+};