terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/machine-image/machine-image.js

@@ -0,0 +1,566 @@
+"use strict";
+var _a, _b, _c, _d, _e, _f, _g, _h;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LookupMachineImage = exports.GenericWindowsImage = exports.GenericLinuxImage = exports.AmazonLinuxKernel = exports.AmazonLinuxImage = exports.WindowsImage = exports.ResolveSsmParameterAtLaunchImage = exports.GenericSSMParameterImage = exports.MachineImage = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/41cd57290e03e9256cc77466fd39e7f3e7a295b4/packages/aws-cdk-lib/aws-ec2/lib/machine-image/machine-image.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const amazon_linux_2022_1 = require("./amazon-linux-2022");
+const amazon_linux_2023_1 = require("./amazon-linux-2023");
+const amazon_linux2_1 = require("./amazon-linux2");
+const common_1 = require("./common");
+const utils_1 = require("./utils");
+const aws_stack_1 = require("../../aws-stack");
+const ssm = require("../../storage");
+const user_data_1 = require("../user-data");
+const windows_versions_1 = require("../windows-versions");
+/**
+ * Factory functions for standard Amazon Machine Image objects.
+ */
+class MachineImage {
+    /**
+     * A Windows image that is automatically kept up-to-date
+     *
+     * This Machine Image automatically updates to the latest version on every
+     * deployment. Be aware this will cause your instances to be replaced when a
+     * new version of the image becomes available. Do not store stateful information
+     * on the instance if you are using this image.
+     */
+    static latestWindows(version, props) {
+        return new WindowsImage(version, props);
+    }
+    /**
+     * An Amazon Linux 2 image that is automatically kept up-to-date
+     *
+     * This Machine Image automatically updates to the latest version on every
+     * deployment. Be aware this will cause your instances to be replaced when a
+     * new version of the image becomes available. Do not store stateful information
+     * on the instance if you are using this image.
+     */
+    static latestAmazonLinux2(props) {
+        return new amazon_linux2_1.AmazonLinux2ImageSsmParameter({
+            cachedInContext: false,
+            ...props,
+            kernel: amazon_linux2_1.AmazonLinux2Kernel.CDK_LATEST,
+        });
+    }
+    /**
+     * An Amazon Linux 2022 image that is automatically kept up-to-date
+     *
+     * This Machine Image automatically updates to the latest version on every
+     * deployment. Be aware this will cause your instances to be replaced when a
+     * new version of the image becomes available. Do not store stateful information
+     * on the instance if you are using this image.
+     *
+     * @deprecated - use latestAmazonLinux2023() instead
+     */
+    static latestAmazonLinux2022(props) {
+        return new amazon_linux_2022_1.AmazonLinux2022ImageSsmParameter({
+            cachedInContext: false,
+            ...props,
+            kernel: amazon_linux_2022_1.AmazonLinux2022Kernel.CDK_LATEST,
+        });
+    }
+    /**
+     * An Amazon Linux 2023 image that is automatically kept up-to-date
+     *
+     * This Machine Image automatically updates to the latest version on every
+     * deployment. Be aware this will cause your instances to be replaced when a
+     * new version of the image becomes available. Do not store stateful information
+     * on the instance if you are using this image.
+     */
+    static latestAmazonLinux2023(props) {
+        return new amazon_linux_2023_1.AmazonLinux2023ImageSsmParameter({
+            cachedInContext: false,
+            ...props,
+            kernel: amazon_linux_2023_1.AmazonLinux2023Kernel.CDK_LATEST,
+        });
+    }
+    /**
+     * An Amazon Linux image that is automatically kept up-to-date
+     *
+     * This Machine Image automatically updates to the latest version on every
+     * deployment. Be aware this will cause your instances to be replaced when a
+     * new version of the image becomes available. Do not store stateful information
+     * on the instance if you are using this image.
+     *
+     * N.B.: "latest" in the name of this function indicates that it always uses the most recent
+     * image of a particular generation of Amazon Linux, not that it uses the "latest generation".
+     * For backwards compatibility, this function uses Amazon Linux 1 if no generation
+     * is specified.
+     *
+     * Specify the desired generation using the `generation` property:
+     *
+     * ```ts
+     * compute.MachineImage.latestAmazonLinux({
+     *   // Use Amazon Linux 2
+     *   generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2,
+     * })
+     * ```
+     * @deprecated use MachineImage.latestAmazonLinux2 instead
+     */
+    static latestAmazonLinux(props) {
+        return new AmazonLinuxImage(props);
+    }
+    /**
+     * A Linux image where you specify the AMI ID for every region
+     *
+     * @param amiMap For every region where you are deploying the stack,
+     * specify the AMI ID for that region.
+     * @param props Customize the image by supplying additional props
+     */
+    static genericLinux(amiMap, props) {
+        return new GenericLinuxImage(amiMap, props);
+    }
+    /**
+     * A Windows image where you specify the AMI ID for every region
+     *
+     * @param amiMap For every region where you are deploying the stack,
+     * specify the AMI ID for that region.
+     * @param props Customize the image by supplying additional props
+     */
+    static genericWindows(amiMap, props) {
+        return new GenericWindowsImage(amiMap, props);
+    }
+    /**
+     * An image specified in SSM parameter store that is automatically kept up-to-date
+     *
+     * This Machine Image automatically updates to the latest version on every
+     * deployment. Be aware this will cause your instances to be replaced when a
+     * new version of the image becomes available. Do not store stateful information
+     * on the instance if you are using this image.
+     *
+     * @param parameterName The name of SSM parameter containing the AMi id
+     * @param os The operating system type of the AMI
+     * @param userData optional user data for the given image
+     * @deprecated Use `MachineImage.fromSsmParameter()` instead
+     */
+    static fromSSMParameter(parameterName, os, userData) {
+        return new GenericSSMParameterImage(parameterName, os, userData);
+    }
+    /**
+     * An image specified in SSM parameter store
+     *
+     * By default, the SSM parameter is refreshed at every deployment,
+     * causing your instances to be replaced whenever a new version of the AMI
+     * is released.
+     *
+     * Pass `{ cachedInContext: true }` to keep the AMI ID stable. If you do, you
+     * will have to remember to periodically invalidate the context to refresh
+     * to the newest AMI ID.
+     */
+    static fromSsmParameter(parameterName, options) {
+        return new GenericSsmParameterImage(parameterName, options);
+    }
+    /**
+     * An image specified in SSM parameter store that will be resolved at instance launch time.
+     *
+     * The AMI ID will be resolved at instance launch time.
+     *
+     * @param parameterName The name of SSM parameter containing the AMI ID
+     * @param options The parameter image options
+     *
+     * @see https://docs.aws.amazon.com/autoscaling/ec2/userguide/using-systems-manager-parameters.html
+     *
+     */
+    static resolveSsmParameterAtLaunch(parameterName, options) {
+        return new ResolveSsmParameterAtLaunchImage(parameterName, options);
+    }
+    /**
+     * Look up a shared Machine Image using DescribeImages
+     *
+     * The most recent, available, launchable image matching the given filter
+     * criteria will be used. Looking up AMIs may take a long time; specify
+     * as many filter criteria as possible to narrow down the search.
+     *
+     * The AMI selected will be cached in `cdk.context.json` and the same value
+     * will be used on future runs. To refresh the AMI lookup, you will have to
+     * evict the value from the cache using the `cdk context` command. See
+     * https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.
+     *
+     * This function can not be used in environment-agnostic stacks.
+     */
+    static lookup(props) {
+        return new LookupMachineImage(props);
+    }
+}
+exports.MachineImage = MachineImage;
+_a = JSII_RTTI_SYMBOL_1;
+MachineImage[_a] = { fqn: "terraconstructs.aws.compute.MachineImage", version: "0.0.12" };
+/**
+ * Select the image based on a given SSM parameter at deployment time of the CloudFormation Stack.
+ *
+ * This Machine Image automatically updates to the latest version on every
+ * deployment. Be aware this will cause your instances to be replaced when a
+ * new version of the image becomes available. Do not store stateful information
+ * on the instance if you are using this image.
+ *
+ * The AMI ID is selected using the values published to the SSM parameter store.
+ */
+class GenericSSMParameterImage {
+    constructor(parameterName, os, userData) {
+        this.os = os;
+        this.userData = userData;
+        this.parameterName = parameterName;
+    }
+    /**
+     * Return the image to use in the given context
+     */
+    getImage(scope) {
+        const ami = ssm.StringParameter.valueForTypedStringParameterV2(scope, this.parameterName, ssm.ParameterValueType.AWS_EC2_IMAGE_ID);
+        return {
+            imageId: ami,
+            osType: this.os,
+            userData: this.userData ??
+                (this.os === common_1.OperatingSystemType.WINDOWS
+                    ? user_data_1.UserData.forWindows()
+                    : user_data_1.UserData.forLinux()),
+        };
+    }
+}
+exports.GenericSSMParameterImage = GenericSSMParameterImage;
+_b = JSII_RTTI_SYMBOL_1;
+GenericSSMParameterImage[_b] = { fqn: "terraconstructs.aws.compute.GenericSSMParameterImage", version: "0.0.12" };
+/**
+ * Select the image based on a given SSM parameter at instance launch time.
+ *
+ * This Machine Image comes with an imageId as `resolve:ssm:parameter-name` or `resolve:ssm:parameter-name:version` format
+ * as described in the document:
+ *
+ * @see https://docs.aws.amazon.com/autoscaling/ec2/userguide/using-systems-manager-parameters.html
+ *
+ * The AMI ID would be selected at instance launch time.
+ */
+class ResolveSsmParameterAtLaunchImage {
+    constructor(parameterName, props = {}) {
+        this.props = props;
+        this.parameterName = parameterName;
+    }
+    /**
+     * Return the image to use in the given context
+     */
+    getImage(_) {
+        const versionString = this.props.parameterVersion
+            ? `:${this.props.parameterVersion}`
+            : "";
+        const osType = this.props.os ?? common_1.OperatingSystemType.LINUX;
+        return {
+            imageId: `resolve:ssm:${this.parameterName}${versionString}`,
+            osType,
+            userData: this.props.userData ??
+                (osType === common_1.OperatingSystemType.WINDOWS
+                    ? user_data_1.UserData.forWindows()
+                    : user_data_1.UserData.forLinux()),
+        };
+    }
+}
+exports.ResolveSsmParameterAtLaunchImage = ResolveSsmParameterAtLaunchImage;
+_c = JSII_RTTI_SYMBOL_1;
+ResolveSsmParameterAtLaunchImage[_c] = { fqn: "terraconstructs.aws.compute.ResolveSsmParameterAtLaunchImage", version: "0.0.12" };
+/**
+ * Select the image based on a given SSM parameter at deployment time of the CloudFormation Stack.
+ *
+ * This Machine Image automatically updates to the latest version on every
+ * deployment. Be aware this will cause your instances to be replaced when a
+ * new version of the image becomes available. Do not store stateful information
+ * on the instance if you are using this image.
+ *
+ * The AMI ID is selected using the values published to the SSM parameter store.
+ */
+class GenericSsmParameterImage {
+    constructor(parameterName, props = {}) {
+        this.parameterName = parameterName;
+        this.props = props;
+    }
+    /**
+     * Return the image to use in the given context
+     */
+    getImage(scope) {
+        const imageId = (0, utils_1.lookupImage)(scope, this.props.cachedInContext, this.parameterName);
+        const osType = this.props.os ?? common_1.OperatingSystemType.LINUX;
+        return {
+            imageId,
+            osType,
+            userData: this.props.userData ??
+                (osType === common_1.OperatingSystemType.WINDOWS
+                    ? user_data_1.UserData.forWindows()
+                    : user_data_1.UserData.forLinux()),
+        };
+    }
+}
+/**
+ * Select the latest version of the indicated Windows version
+ *
+ * This Machine Image automatically updates to the latest version on every
+ * deployment. Be aware this will cause your instances to be replaced when a
+ * new version of the image becomes available. Do not store stateful information
+ * on the instance if you are using this image.
+ *
+ * The AMI ID is selected using the values published to the SSM parameter store.
+ *
+ * https://aws.amazon.com/blogs/mt/query-for-the-latest-windows-ami-using-systems-manager-parameter-store/
+ */
+class WindowsImage extends GenericSSMParameterImage {
+    constructor(version, props = {}) {
+        const nonDeprecatedVersionName = WindowsImage.DEPRECATED_VERSION_NAME_MAP[version] ?? version;
+        super("/aws/service/ami-windows-latest/" + nonDeprecatedVersionName, common_1.OperatingSystemType.WINDOWS, props.userData);
+    }
+}
+exports.WindowsImage = WindowsImage;
+_d = JSII_RTTI_SYMBOL_1;
+WindowsImage[_d] = { fqn: "terraconstructs.aws.compute.WindowsImage", version: "0.0.12" };
+WindowsImage.DEPRECATED_VERSION_NAME_MAP = {
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2016_GERMAL_FULL_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2016_GERMAN_FULL_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_R2_SP1_PORTUGESE_BRAZIL_64BIT_CORE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_R2_SP1_PORTUGUESE_BRAZIL_64BIT_CORE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2016_PORTUGESE_PORTUGAL_FULL_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2016_PORTUGUESE_PORTUGAL_FULL_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_R2_RTM_PORTUGESE_BRAZIL_64BIT_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_R2_RTM_PORTUGUESE_BRAZIL_64BIT_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_R2_RTM_PORTUGESE_PORTUGAL_64BIT_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_R2_RTM_PORTUGUESE_PORTUGAL_64BIT_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2016_PORTUGESE_BRAZIL_FULL_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2016_PORTUGUESE_BRAZIL_FULL_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_SP2_PORTUGESE_BRAZIL_64BIT_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_SP2_PORTUGUESE_BRAZIL_64BIT_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_RTM_PORTUGESE_BRAZIL_64BIT_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_RTM_PORTUGUESE_BRAZIL_64BIT_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2008_R2_SP1_PORTUGESE_BRAZIL_64BIT_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2008_R2_SP1_PORTUGUESE_BRAZIL_64BIT_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2008_SP2_PORTUGESE_BRAZIL_32BIT_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2008_SP2_PORTUGUESE_BRAZIL_32BIT_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_RTM_PORTUGESE_PORTUGAL_64BIT_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2012_RTM_PORTUGUESE_PORTUGAL_64BIT_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2019_PORTUGESE_BRAZIL_FULL_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2019_PORTUGUESE_BRAZIL_FULL_BASE,
+    [windows_versions_1.WindowsVersion.WINDOWS_SERVER_2019_PORTUGESE_PORTUGAL_FULL_BASE]: windows_versions_1.WindowsVersion.WINDOWS_SERVER_2019_PORTUGUESE_PORTUGAL_FULL_BASE,
+};
+/**
+ * Selects the latest version of Amazon Linux
+ *
+ * This Machine Image automatically updates to the latest version on every
+ * deployment. Be aware this will cause your instances to be replaced when a
+ * new version of the image becomes available. Do not store stateful information
+ * on the instance if you are using this image.
+ *
+ * The AMI ID is selected using the values published to the SSM parameter store.
+ */
+class AmazonLinuxImage extends GenericSSMParameterImage {
+    /**
+     * Return the SSM parameter name that will contain the Amazon Linux image with the given attributes
+     */
+    static ssmParameterName(props = {}) {
+        const generation = (props && props.generation) || common_1.AmazonLinuxGeneration.AMAZON_LINUX;
+        const edition = (props && props.edition) || common_1.AmazonLinuxEdition.STANDARD;
+        const cpu = (props && props.cpuType) || common_1.AmazonLinuxCpuType.X86_64;
+        let kernel = (props && props.kernel) || undefined;
+        let virtualization;
+        let storage;
+        if (generation === common_1.AmazonLinuxGeneration.AMAZON_LINUX_2022) {
+            kernel = AmazonLinuxKernel.KERNEL5_X;
+            if (props && props.storage) {
+                throw new Error("Storage parameter does not exist in SSM parameter name for Amazon Linux 2022.");
+            }
+            if (props && props.virtualization) {
+                throw new Error("Virtualization parameter does not exist in SSM parameter name for Amazon Linux 2022.");
+            }
+        }
+        else if (generation === common_1.AmazonLinuxGeneration.AMAZON_LINUX_2023) {
+            kernel = AmazonLinuxKernel.KERNEL6_1;
+            if (props && props.storage) {
+                throw new Error("Storage parameter does not exist in SSM parameter name for Amazon Linux 2023.");
+            }
+            if (props && props.virtualization) {
+                throw new Error("Virtualization parameter does not exist in SSM parameter name for Amazon Linux 2023.");
+            }
+        }
+        else {
+            virtualization = (props && props.virtualization) || common_1.AmazonLinuxVirt.HVM;
+            storage = (props && props.storage) || common_1.AmazonLinuxStorage.GENERAL_PURPOSE;
+        }
+        const parts = [
+            generation,
+            "ami",
+            edition !== common_1.AmazonLinuxEdition.STANDARD ? edition : undefined,
+            kernel,
+            virtualization,
+            cpu,
+            storage,
+        ].filter((x) => x !== undefined); // Get rid of undefineds
+        return "/aws/service/ami-amazon-linux-latest/" + parts.join("-");
+    }
+    constructor(props = {}) {
+        super(AmazonLinuxImage.ssmParameterName(props), common_1.OperatingSystemType.LINUX, props.userData);
+        this.props = props;
+        this.cachedInContext = props.cachedInContext ?? false;
+    }
+    /**
+     * Return the image to use in the given context
+     */
+    getImage(scope) {
+        const imageId = (0, utils_1.lookupImage)(scope, this.cachedInContext, this.parameterName);
+        const osType = common_1.OperatingSystemType.LINUX;
+        return {
+            imageId,
+            osType,
+            userData: this.props.userData ?? user_data_1.UserData.forLinux(),
+        };
+    }
+}
+exports.AmazonLinuxImage = AmazonLinuxImage;
+_e = JSII_RTTI_SYMBOL_1;
+AmazonLinuxImage[_e] = { fqn: "terraconstructs.aws.compute.AmazonLinuxImage", version: "0.0.12" };
+/**
+ * Amazon Linux Kernel
+ */
+var AmazonLinuxKernel;
+(function (AmazonLinuxKernel) {
+    /**
+     * Kernel version 5.10
+     */
+    AmazonLinuxKernel["KERNEL5_X"] = "kernel-5.10";
+    /**
+     * Kernel version 6.1
+     */
+    AmazonLinuxKernel["KERNEL6_1"] = "kernel-6.1";
+})(AmazonLinuxKernel || (exports.AmazonLinuxKernel = AmazonLinuxKernel = {}));
+/**
+ * Construct a Linux machine image from an AMI map
+ *
+ * Linux images IDs are not published to SSM parameter store yet, so you'll have to
+ * manually specify an AMI map.
+ */
+class GenericLinuxImage {
+    constructor(amiMap, props = {}) {
+        this.amiMap = amiMap;
+        this.props = props;
+    }
+    getImage(scope) {
+        const userData = this.props.userData ?? user_data_1.UserData.forLinux();
+        const osType = common_1.OperatingSystemType.LINUX;
+        const region = aws_stack_1.AwsStack.ofAwsConstruct(scope).region;
+        // // Grid stacks are single region, region is always known
+        // if (Token.isUnresolved(region)) {
+        //   const mapping: { [k1: string]: { [k2: string]: any } } = {};
+        //   for (const [rgn, ami] of Object.entries(this.amiMap)) {
+        //     mapping[rgn] = { ami };
+        //   }
+        //   const amiMap = new TerraformLocal(scope, "AmiMap", { mapping });
+        //   return {
+        //     imageId: Fn.lookupNested(amiMap, Aws.REGION, "ami"),
+        //     userData,
+        //     osType,
+        //   };
+        // }
+        const imageId = region !== "test-region" ? this.amiMap[region] : "ami-12345";
+        if (!imageId) {
+            throw new Error(`Unable to find AMI in AMI map: no AMI specified for region '${region}'`);
+        }
+        return {
+            imageId,
+            userData,
+            osType,
+        };
+    }
+}
+exports.GenericLinuxImage = GenericLinuxImage;
+_f = JSII_RTTI_SYMBOL_1;
+GenericLinuxImage[_f] = { fqn: "terraconstructs.aws.compute.GenericLinuxImage", version: "0.0.12" };
+/**
+ * Construct a Windows machine image from an AMI map
+ *
+ * Allows you to create a generic Windows EC2 , manually specify an AMI map.
+ */
+class GenericWindowsImage {
+    constructor(amiMap, props = {}) {
+        this.amiMap = amiMap;
+        this.props = props;
+    }
+    getImage(scope) {
+        const userData = this.props.userData ?? user_data_1.UserData.forWindows();
+        const osType = common_1.OperatingSystemType.WINDOWS;
+        const region = aws_stack_1.AwsStack.ofAwsConstruct(scope).region;
+        // // Grid stacks are single region, region is always known
+        // if (Token.isUnresolved(region)) {
+        //   const mapping: { [k1: string]: { [k2: string]: any } } = {};
+        //   for (const [rgn, ami] of Object.entries(this.amiMap)) {
+        //     mapping[rgn] = { ami };
+        //   }
+        //   const amiMap = new TerraformLocal(scope, "AmiMap", { mapping });
+        //   return {
+        //     imageId: Fn.lookupNested(amiMap, Aws.REGION, "ami"),
+        //     userData,
+        //     osType,
+        //   };
+        // }
+        const imageId = region !== "test-region" ? this.amiMap[region] : "ami-12345";
+        if (!imageId) {
+            throw new Error(`Unable to find AMI in AMI map: no AMI specified for region '${region}'`);
+        }
+        return {
+            imageId,
+            userData,
+            osType,
+        };
+    }
+}
+exports.GenericWindowsImage = GenericWindowsImage;
+_g = JSII_RTTI_SYMBOL_1;
+GenericWindowsImage[_g] = { fqn: "terraconstructs.aws.compute.GenericWindowsImage", version: "0.0.12" };
+/**
+ * A machine image whose AMI ID will be searched using DescribeImages.
+ *
+ * The most recent, available, launchable image matching the given filter
+ * criteria will be used. Looking up AMIs may take a long time; specify
+ * as many filter criteria as possible to narrow down the search.
+ *
+ * The AMI selected will be cached in `grid.context.json` and the same value
+ * will be used on future runs. To refresh the AMI lookup, you will have to
+ * evict the value from the cache using the `grid context` command. See
+ * https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.
+ */
+class LookupMachineImage {
+    constructor(props) {
+        this.props = props;
+    }
+    getImage(scope) {
+        // Need to know 'windows' or not before doing the query to return the right
+        // osType for the dummy value, so might as well add it to the filter.
+        const filters = {
+            name: [this.props.name],
+            state: ["available"],
+            "image-type": ["machine"],
+            platform: this.props.windows ? ["windows"] : undefined,
+        };
+        Object.assign(filters, this.props.filters);
+        let uniqueId = "Ami";
+        let counter = 1;
+        while (scope.node.tryFindChild(uniqueId)) {
+            uniqueId = `Ami${counter++}`;
+        }
+        const dataSource = new provider_aws_1.dataAwsAmi.DataAwsAmi(scope, uniqueId, {
+            owners: this.props.owners,
+            filter: Object.entries(filters)
+                .filter(([_key, values]) => values !== undefined)
+                .map(([name, values]) => ({
+                name,
+                values: values,
+            })),
+        });
+        const value = dataSource.id;
+        // // TODO: Use Grid as contextProvider
+        // const value = ContextProvider.getValue(scope, {
+        //   provider: cxschema.ContextProvider.AMI_PROVIDER,
+        //   props: {
+        //     owners: this.props.owners,
+        //     filters,
+        //   } as cxschema.AmiContextQuery,
+        //   dummyValue: "ami-1234",
+        // }).value as cxapi.AmiContextResponse;
+        //
+        // if (typeof value !== "string") {
+        //   throw new Error(`Response to AMI lookup invalid, got: ${value}`);
+        // }
+        const osType = this.props.windows
+            ? common_1.OperatingSystemType.WINDOWS
+            : common_1.OperatingSystemType.LINUX;
+        return {
+            imageId: value,
+            osType,
+            userData: this.props.userData ?? user_data_1.UserData.forOperatingSystem(osType),
+        };
+    }
+}
+exports.LookupMachineImage = LookupMachineImage;
+_h = JSII_RTTI_SYMBOL_1;
+LookupMachineImage[_h] = { fqn: "terraconstructs.aws.compute.LookupMachineImage", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"machine-image.js","sourceRoot":"","sources":["../../../../src/aws/compute/machine-image/machine-image.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/41cd57290e03e9256cc77466fd39e7f3e7a295b4/packages/aws-cdk-lib/aws-ec2/lib/machine-image/machine-image.ts\n\nimport { dataAwsAmi } from \"@cdktf/provider-aws\";\n// import {\n//   // TODO: Use Grid as contextProvider\n//   // ContextProvider,\n//   // CfnMapping,\n//   // Aws,\n//   Token,\n// } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  AmazonLinux2022ImageSsmParameter,\n  AmazonLinux2022ImageSsmParameterProps,\n  AmazonLinux2022Kernel,\n} from \"./amazon-linux-2022\";\nimport {\n  AmazonLinux2023ImageSsmParameter,\n  AmazonLinux2023ImageSsmParameterProps,\n  AmazonLinux2023Kernel,\n} from \"./amazon-linux-2023\";\nimport {\n  AmazonLinux2ImageSsmParameter,\n  AmazonLinux2ImageSsmParameterProps,\n  AmazonLinux2Kernel,\n} from \"./amazon-linux2\";\nimport {\n  AmazonLinuxCpuType,\n  AmazonLinuxEdition,\n  AmazonLinuxGeneration,\n  AmazonLinuxStorage,\n  AmazonLinuxVirt,\n  IMachineImage,\n  MachineImageConfig,\n  OperatingSystemType,\n} from \"./common\";\nimport { lookupImage } from \"./utils\";\nimport { AwsStack } from \"../../aws-stack\";\nimport * as ssm from \"../../storage\";\nimport { UserData } from \"../user-data\";\nimport { WindowsVersion } from \"../windows-versions\";\n\n/**\n * Factory functions for standard Amazon Machine Image objects.\n */\nexport abstract class MachineImage {\n  /**\n   * A Windows image that is automatically kept up-to-date\n   *\n   * This Machine Image automatically updates to the latest version on every\n   * deployment. Be aware this will cause your instances to be replaced when a\n   * new version of the image becomes available. Do not store stateful information\n   * on the instance if you are using this image.\n   */\n  public static latestWindows(\n    version: WindowsVersion,\n    props?: WindowsImageProps,\n  ): IMachineImage {\n    return new WindowsImage(version, props);\n  }\n\n  /**\n   * An Amazon Linux 2 image that is automatically kept up-to-date\n   *\n   * This Machine Image automatically updates to the latest version on every\n   * deployment. Be aware this will cause your instances to be replaced when a\n   * new version of the image becomes available. Do not store stateful information\n   * on the instance if you are using this image.\n   */\n  public static latestAmazonLinux2(\n    props?: AmazonLinux2ImageSsmParameterProps,\n  ): IMachineImage {\n    return new AmazonLinux2ImageSsmParameter({\n      cachedInContext: false,\n      ...props,\n      kernel: AmazonLinux2Kernel.CDK_LATEST,\n    });\n  }\n\n  /**\n   * An Amazon Linux 2022 image that is automatically kept up-to-date\n   *\n   * This Machine Image automatically updates to the latest version on every\n   * deployment. Be aware this will cause your instances to be replaced when a\n   * new version of the image becomes available. Do not store stateful information\n   * on the instance if you are using this image.\n   *\n   * @deprecated - use latestAmazonLinux2023() instead\n   */\n  public static latestAmazonLinux2022(\n    props?: AmazonLinux2022ImageSsmParameterProps,\n  ): IMachineImage {\n    return new AmazonLinux2022ImageSsmParameter({\n      cachedInContext: false,\n      ...props,\n      kernel: AmazonLinux2022Kernel.CDK_LATEST,\n    });\n  }\n\n  /**\n   * An Amazon Linux 2023 image that is automatically kept up-to-date\n   *\n   * This Machine Image automatically updates to the latest version on every\n   * deployment. Be aware this will cause your instances to be replaced when a\n   * new version of the image becomes available. Do not store stateful information\n   * on the instance if you are using this image.\n   */\n  public static latestAmazonLinux2023(\n    props?: AmazonLinux2023ImageSsmParameterProps,\n  ): IMachineImage {\n    return new AmazonLinux2023ImageSsmParameter({\n      cachedInContext: false,\n      ...props,\n      kernel: AmazonLinux2023Kernel.CDK_LATEST,\n    });\n  }\n\n  /**\n   * An Amazon Linux image that is automatically kept up-to-date\n   *\n   * This Machine Image automatically updates to the latest version on every\n   * deployment. Be aware this will cause your instances to be replaced when a\n   * new version of the image becomes available. Do not store stateful information\n   * on the instance if you are using this image.\n   *\n   * N.B.: \"latest\" in the name of this function indicates that it always uses the most recent\n   * image of a particular generation of Amazon Linux, not that it uses the \"latest generation\".\n   * For backwards compatibility, this function uses Amazon Linux 1 if no generation\n   * is specified.\n   *\n   * Specify the desired generation using the `generation` property:\n   *\n   * ```ts\n   * compute.MachineImage.latestAmazonLinux({\n   *   // Use Amazon Linux 2\n   *   generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2,\n   * })\n   * ```\n   * @deprecated use MachineImage.latestAmazonLinux2 instead\n   */\n  public static latestAmazonLinux(\n    props?: AmazonLinuxImageProps,\n  ): IMachineImage {\n    return new AmazonLinuxImage(props);\n  }\n\n  /**\n   * A Linux image where you specify the AMI ID for every region\n   *\n   * @param amiMap For every region where you are deploying the stack,\n   * specify the AMI ID for that region.\n   * @param props Customize the image by supplying additional props\n   */\n  public static genericLinux(\n    amiMap: Record<string, string>,\n    props?: GenericLinuxImageProps,\n  ): IMachineImage {\n    return new GenericLinuxImage(amiMap, props);\n  }\n\n  /**\n   * A Windows image where you specify the AMI ID for every region\n   *\n   * @param amiMap For every region where you are deploying the stack,\n   * specify the AMI ID for that region.\n   * @param props Customize the image by supplying additional props\n   */\n  public static genericWindows(\n    amiMap: Record<string, string>,\n    props?: GenericWindowsImageProps,\n  ): IMachineImage {\n    return new GenericWindowsImage(amiMap, props);\n  }\n\n  /**\n   * An image specified in SSM parameter store that is automatically kept up-to-date\n   *\n   * This Machine Image automatically updates to the latest version on every\n   * deployment. Be aware this will cause your instances to be replaced when a\n   * new version of the image becomes available. Do not store stateful information\n   * on the instance if you are using this image.\n   *\n   * @param parameterName The name of SSM parameter containing the AMi id\n   * @param os The operating system type of the AMI\n   * @param userData optional user data for the given image\n   * @deprecated Use `MachineImage.fromSsmParameter()` instead\n   */\n  public static fromSSMParameter(\n    parameterName: string,\n    os: OperatingSystemType,\n    userData?: UserData,\n  ): IMachineImage {\n    return new GenericSSMParameterImage(parameterName, os, userData);\n  }\n\n  /**\n   * An image specified in SSM parameter store\n   *\n   * By default, the SSM parameter is refreshed at every deployment,\n   * causing your instances to be replaced whenever a new version of the AMI\n   * is released.\n   *\n   * Pass `{ cachedInContext: true }` to keep the AMI ID stable. If you do, you\n   * will have to remember to periodically invalidate the context to refresh\n   * to the newest AMI ID.\n   */\n  public static fromSsmParameter(\n    parameterName: string,\n    options?: SsmParameterImageOptions,\n  ): IMachineImage {\n    return new GenericSsmParameterImage(parameterName, options);\n  }\n\n  /**\n   * An image specified in SSM parameter store that will be resolved at instance launch time.\n   *\n   * The AMI ID will be resolved at instance launch time.\n   *\n   * @param parameterName The name of SSM parameter containing the AMI ID\n   * @param options The parameter image options\n   *\n   * @see https://docs.aws.amazon.com/autoscaling/ec2/userguide/using-systems-manager-parameters.html\n   *\n   */\n  public static resolveSsmParameterAtLaunch(\n    parameterName: string,\n    options?: SsmParameterImageOptions,\n  ): IMachineImage {\n    return new ResolveSsmParameterAtLaunchImage(parameterName, options);\n  }\n\n  /**\n   * Look up a shared Machine Image using DescribeImages\n   *\n   * The most recent, available, launchable image matching the given filter\n   * criteria will be used. Looking up AMIs may take a long time; specify\n   * as many filter criteria as possible to narrow down the search.\n   *\n   * The AMI selected will be cached in `cdk.context.json` and the same value\n   * will be used on future runs. To refresh the AMI lookup, you will have to\n   * evict the value from the cache using the `cdk context` command. See\n   * https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.\n   *\n   * This function can not be used in environment-agnostic stacks.\n   */\n  public static lookup(props: LookupMachineImageProps): IMachineImage {\n    return new LookupMachineImage(props);\n  }\n}\n\n/**\n * Select the image based on a given SSM parameter at deployment time of the CloudFormation Stack.\n *\n * This Machine Image automatically updates to the latest version on every\n * deployment. Be aware this will cause your instances to be replaced when a\n * new version of the image becomes available. Do not store stateful information\n * on the instance if you are using this image.\n *\n * The AMI ID is selected using the values published to the SSM parameter store.\n */\nexport class GenericSSMParameterImage implements IMachineImage {\n  // FIXME: this class ought to be `@deprecated` and removed from v2, but that\n  // is causing build failure right now. Ref: https://github.com/aws/jsii/issues/3025\n  // @-deprecated Use `MachineImage.fromSsmParameter()` instead\n\n  /**\n   * Name of the SSM parameter we're looking up\n   */\n  public readonly parameterName: string;\n\n  constructor(\n    parameterName: string,\n    private readonly os: OperatingSystemType,\n    private readonly userData?: UserData,\n  ) {\n    this.parameterName = parameterName;\n  }\n\n  /**\n   * Return the image to use in the given context\n   */\n  public getImage(scope: Construct): MachineImageConfig {\n    const ami = ssm.StringParameter.valueForTypedStringParameterV2(\n      scope,\n      this.parameterName,\n      ssm.ParameterValueType.AWS_EC2_IMAGE_ID,\n    );\n    return {\n      imageId: ami,\n      osType: this.os,\n      userData:\n        this.userData ??\n        (this.os === OperatingSystemType.WINDOWS\n          ? UserData.forWindows()\n          : UserData.forLinux()),\n    };\n  }\n}\n\n/**\n * Select the image based on a given SSM parameter at instance launch time.\n *\n * This Machine Image comes with an imageId as `resolve:ssm:parameter-name` or `resolve:ssm:parameter-name:version` format\n * as described in the document:\n *\n * @see https://docs.aws.amazon.com/autoscaling/ec2/userguide/using-systems-manager-parameters.html\n *\n * The AMI ID would be selected at instance launch time.\n */\nexport class ResolveSsmParameterAtLaunchImage implements IMachineImage {\n  /**\n   * Name of the SSM parameter we're looking up\n   */\n  public readonly parameterName: string;\n\n  constructor(\n    parameterName: string,\n    private readonly props: SsmParameterImageOptions = {},\n  ) {\n    this.parameterName = parameterName;\n  }\n\n  /**\n   * Return the image to use in the given context\n   */\n  public getImage(_: Construct): MachineImageConfig {\n    const versionString = this.props.parameterVersion\n      ? `:${this.props.parameterVersion}`\n      : \"\";\n    const osType = this.props.os ?? OperatingSystemType.LINUX;\n    return {\n      imageId: `resolve:ssm:${this.parameterName}${versionString}`,\n      osType,\n      userData:\n        this.props.userData ??\n        (osType === OperatingSystemType.WINDOWS\n          ? UserData.forWindows()\n          : UserData.forLinux()),\n    };\n  }\n}\n\n/**\n * Properties for GenericSsmParameterImage\n */\nexport interface SsmParameterImageOptions {\n  /**\n   * Operating system\n   *\n   * @default OperatingSystemType.LINUX\n   */\n  readonly os?: OperatingSystemType;\n\n  /**\n   * Custom UserData\n   *\n   * @default - UserData appropriate for the OS\n   */\n  readonly userData?: UserData;\n\n  /**\n   * Whether the AMI ID is cached to be stable between deployments\n   *\n   * By default, the newest image is used on each deployment. This will cause\n   * instances to be replaced whenever a new version is released, and may cause\n   * downtime if there aren't enough running instances in the AutoScalingGroup\n   * to reschedule the tasks on.\n   *\n   * If set to true, the AMI ID will be cached in `cdk.context.json` and the\n   * same value will be used on future runs. Your instances will not be replaced\n   * but your AMI version will grow old over time. To refresh the AMI lookup,\n   * you will have to evict the value from the cache using the `cdk context`\n   * command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for\n   * more information.\n   *\n   * Can not be set to `true` in environment-agnostic stacks.\n   *\n   * @default false\n   */\n  readonly cachedInContext?: boolean;\n\n  /**\n   * The version of the SSM parameter.\n   *\n   * @default no version specified.\n   */\n  readonly parameterVersion?: string;\n}\n\n/**\n * Select the image based on a given SSM parameter at deployment time of the CloudFormation Stack.\n *\n * This Machine Image automatically updates to the latest version on every\n * deployment. Be aware this will cause your instances to be replaced when a\n * new version of the image becomes available. Do not store stateful information\n * on the instance if you are using this image.\n *\n * The AMI ID is selected using the values published to the SSM parameter store.\n */\nclass GenericSsmParameterImage implements IMachineImage {\n  constructor(\n    private readonly parameterName: string,\n    private readonly props: SsmParameterImageOptions = {},\n  ) {}\n\n  /**\n   * Return the image to use in the given context\n   */\n  public getImage(scope: Construct): MachineImageConfig {\n    const imageId = lookupImage(\n      scope,\n      this.props.cachedInContext,\n      this.parameterName,\n    );\n\n    const osType = this.props.os ?? OperatingSystemType.LINUX;\n    return {\n      imageId,\n      osType,\n      userData:\n        this.props.userData ??\n        (osType === OperatingSystemType.WINDOWS\n          ? UserData.forWindows()\n          : UserData.forLinux()),\n    };\n  }\n}\n\n/**\n * Configuration options for WindowsImage\n */\nexport interface WindowsImageProps {\n  /**\n   * Initial user data\n   *\n   * @default - Empty UserData for Windows machines\n   */\n  readonly userData?: UserData;\n}\n\n/**\n * Select the latest version of the indicated Windows version\n *\n * This Machine Image automatically updates to the latest version on every\n * deployment. Be aware this will cause your instances to be replaced when a\n * new version of the image becomes available. Do not store stateful information\n * on the instance if you are using this image.\n *\n * The AMI ID is selected using the values published to the SSM parameter store.\n *\n * https://aws.amazon.com/blogs/mt/query-for-the-latest-windows-ami-using-systems-manager-parameter-store/\n */\nexport class WindowsImage extends GenericSSMParameterImage {\n  private static DEPRECATED_VERSION_NAME_MAP: Partial<\n    Record<WindowsVersion, WindowsVersion>\n  > = {\n    [WindowsVersion.WINDOWS_SERVER_2016_GERMAL_FULL_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2016_GERMAN_FULL_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2012_R2_SP1_PORTUGESE_BRAZIL_64BIT_CORE]:\n      WindowsVersion.WINDOWS_SERVER_2012_R2_SP1_PORTUGUESE_BRAZIL_64BIT_CORE,\n    [WindowsVersion.WINDOWS_SERVER_2016_PORTUGESE_PORTUGAL_FULL_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2016_PORTUGUESE_PORTUGAL_FULL_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2012_R2_RTM_PORTUGESE_BRAZIL_64BIT_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2012_R2_RTM_PORTUGUESE_BRAZIL_64BIT_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2012_R2_RTM_PORTUGESE_PORTUGAL_64BIT_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2012_R2_RTM_PORTUGUESE_PORTUGAL_64BIT_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2016_PORTUGESE_BRAZIL_FULL_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2016_PORTUGUESE_BRAZIL_FULL_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2012_SP2_PORTUGESE_BRAZIL_64BIT_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2012_SP2_PORTUGUESE_BRAZIL_64BIT_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2012_RTM_PORTUGESE_BRAZIL_64BIT_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2012_RTM_PORTUGUESE_BRAZIL_64BIT_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2008_R2_SP1_PORTUGESE_BRAZIL_64BIT_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2008_R2_SP1_PORTUGUESE_BRAZIL_64BIT_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2008_SP2_PORTUGESE_BRAZIL_32BIT_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2008_SP2_PORTUGUESE_BRAZIL_32BIT_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2012_RTM_PORTUGESE_PORTUGAL_64BIT_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2012_RTM_PORTUGUESE_PORTUGAL_64BIT_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2019_PORTUGESE_BRAZIL_FULL_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2019_PORTUGUESE_BRAZIL_FULL_BASE,\n    [WindowsVersion.WINDOWS_SERVER_2019_PORTUGESE_PORTUGAL_FULL_BASE]:\n      WindowsVersion.WINDOWS_SERVER_2019_PORTUGUESE_PORTUGAL_FULL_BASE,\n  };\n  constructor(version: WindowsVersion, props: WindowsImageProps = {}) {\n    const nonDeprecatedVersionName =\n      WindowsImage.DEPRECATED_VERSION_NAME_MAP[version] ?? version;\n    super(\n      \"/aws/service/ami-windows-latest/\" + nonDeprecatedVersionName,\n      OperatingSystemType.WINDOWS,\n      props.userData,\n    );\n  }\n}\n\n/**\n * Amazon Linux image properties\n */\nexport interface AmazonLinuxImageProps {\n  /**\n   * What generation of Amazon Linux to use\n   *\n   * @default AmazonLinux\n   */\n  readonly generation?: AmazonLinuxGeneration;\n\n  /**\n   * What edition of Amazon Linux to use\n   *\n   * @default Standard\n   */\n  readonly edition?: AmazonLinuxEdition;\n\n  /**\n   * What kernel version of Amazon Linux to use\n   *\n   * @default -\n   */\n  readonly kernel?: AmazonLinuxKernel;\n\n  /**\n   * What storage backed image to use\n   *\n   * @default GeneralPurpose\n   */\n  readonly storage?: AmazonLinuxStorage;\n\n  /**\n   * Initial user data\n   *\n   * @default - Empty UserData for Linux machines\n   */\n  readonly userData?: UserData;\n\n  /**\n   * CPU Type\n   *\n   * @default X86_64\n   */\n  readonly cpuType?: AmazonLinuxCpuType;\n\n  /**\n   * Virtualization type\n   *\n   * @default HVM\n   */\n  readonly virtualization?: AmazonLinuxVirt;\n\n  /**\n   * Whether the AMI ID is cached to be stable between deployments\n   *\n   * By default, the newest image is used on each deployment. This will cause\n   * instances to be replaced whenever a new version is released, and may cause\n   * downtime if there aren't enough running instances in the AutoScalingGroup\n   * to reschedule the tasks on.\n   *\n   * If set to true, the AMI ID will be cached in `cdk.context.json` and the\n   * same value will be used on future runs. Your instances will not be replaced\n   * but your AMI version will grow old over time. To refresh the AMI lookup,\n   * you will have to evict the value from the cache using the `cdk context`\n   * command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for\n   * more information.\n   *\n   * Can not be set to `true` in environment-agnostic stacks.\n   *\n   * @default false\n   */\n  readonly cachedInContext?: boolean;\n}\n\n/**\n * Selects the latest version of Amazon Linux\n *\n * This Machine Image automatically updates to the latest version on every\n * deployment. Be aware this will cause your instances to be replaced when a\n * new version of the image becomes available. Do not store stateful information\n * on the instance if you are using this image.\n *\n * The AMI ID is selected using the values published to the SSM parameter store.\n */\nexport class AmazonLinuxImage extends GenericSSMParameterImage {\n  /**\n   * Return the SSM parameter name that will contain the Amazon Linux image with the given attributes\n   */\n  public static ssmParameterName(props: AmazonLinuxImageProps = {}) {\n    const generation =\n      (props && props.generation) || AmazonLinuxGeneration.AMAZON_LINUX;\n    const edition = (props && props.edition) || AmazonLinuxEdition.STANDARD;\n    const cpu = (props && props.cpuType) || AmazonLinuxCpuType.X86_64;\n    let kernel = (props && props.kernel) || undefined;\n    let virtualization: AmazonLinuxVirt | undefined;\n    let storage: AmazonLinuxStorage | undefined;\n\n    if (generation === AmazonLinuxGeneration.AMAZON_LINUX_2022) {\n      kernel = AmazonLinuxKernel.KERNEL5_X;\n      if (props && props.storage) {\n        throw new Error(\n          \"Storage parameter does not exist in SSM parameter name for Amazon Linux 2022.\",\n        );\n      }\n      if (props && props.virtualization) {\n        throw new Error(\n          \"Virtualization parameter does not exist in SSM parameter name for Amazon Linux 2022.\",\n        );\n      }\n    } else if (generation === AmazonLinuxGeneration.AMAZON_LINUX_2023) {\n      kernel = AmazonLinuxKernel.KERNEL6_1;\n      if (props && props.storage) {\n        throw new Error(\n          \"Storage parameter does not exist in SSM parameter name for Amazon Linux 2023.\",\n        );\n      }\n      if (props && props.virtualization) {\n        throw new Error(\n          \"Virtualization parameter does not exist in SSM parameter name for Amazon Linux 2023.\",\n        );\n      }\n    } else {\n      virtualization = (props && props.virtualization) || AmazonLinuxVirt.HVM;\n      storage = (props && props.storage) || AmazonLinuxStorage.GENERAL_PURPOSE;\n    }\n\n    const parts: Array<string | undefined> = [\n      generation,\n      \"ami\",\n      edition !== AmazonLinuxEdition.STANDARD ? edition : undefined,\n      kernel,\n      virtualization,\n      cpu,\n      storage,\n    ].filter((x) => x !== undefined); // Get rid of undefineds\n\n    return \"/aws/service/ami-amazon-linux-latest/\" + parts.join(\"-\");\n  }\n\n  private readonly cachedInContext: boolean;\n\n  constructor(private readonly props: AmazonLinuxImageProps = {}) {\n    super(\n      AmazonLinuxImage.ssmParameterName(props),\n      OperatingSystemType.LINUX,\n      props.userData,\n    );\n\n    this.cachedInContext = props.cachedInContext ?? false;\n  }\n\n  /**\n   * Return the image to use in the given context\n   */\n  public getImage(scope: Construct): MachineImageConfig {\n    const imageId = lookupImage(\n      scope,\n      this.cachedInContext,\n      this.parameterName,\n    );\n\n    const osType = OperatingSystemType.LINUX;\n    return {\n      imageId,\n      osType,\n      userData: this.props.userData ?? UserData.forLinux(),\n    };\n  }\n}\n\n/**\n * Amazon Linux Kernel\n */\nexport enum AmazonLinuxKernel {\n  /**\n   * Kernel version 5.10\n   */\n  KERNEL5_X = \"kernel-5.10\",\n\n  /**\n   * Kernel version 6.1\n   */\n  KERNEL6_1 = \"kernel-6.1\",\n}\n\n/**\n * Configuration options for GenericLinuxImage\n */\nexport interface GenericLinuxImageProps {\n  /**\n   * Initial user data\n   *\n   * @default - Empty UserData for Linux machines\n   */\n  readonly userData?: UserData;\n}\n\n/**\n * Configuration options for GenericWindowsImage\n */\nexport interface GenericWindowsImageProps {\n  /**\n   * Initial user data\n   *\n   * @default - Empty UserData for Windows machines\n   */\n  readonly userData?: UserData;\n}\n\n/**\n * Construct a Linux machine image from an AMI map\n *\n * Linux images IDs are not published to SSM parameter store yet, so you'll have to\n * manually specify an AMI map.\n */\nexport class GenericLinuxImage implements IMachineImage {\n  constructor(\n    private readonly amiMap: { [region: string]: string },\n    private readonly props: GenericLinuxImageProps = {},\n  ) {}\n\n  public getImage(scope: Construct): MachineImageConfig {\n    const userData = this.props.userData ?? UserData.forLinux();\n    const osType = OperatingSystemType.LINUX;\n    const region = AwsStack.ofAwsConstruct(scope).region;\n    // // Grid stacks are single region, region is always known\n    // if (Token.isUnresolved(region)) {\n    //   const mapping: { [k1: string]: { [k2: string]: any } } = {};\n    //   for (const [rgn, ami] of Object.entries(this.amiMap)) {\n    //     mapping[rgn] = { ami };\n    //   }\n    //   const amiMap = new TerraformLocal(scope, \"AmiMap\", { mapping });\n    //   return {\n    //     imageId: Fn.lookupNested(amiMap, Aws.REGION, \"ami\"),\n    //     userData,\n    //     osType,\n    //   };\n    // }\n    const imageId =\n      region !== \"test-region\" ? this.amiMap[region] : \"ami-12345\";\n    if (!imageId) {\n      throw new Error(\n        `Unable to find AMI in AMI map: no AMI specified for region '${region}'`,\n      );\n    }\n    return {\n      imageId,\n      userData,\n      osType,\n    };\n  }\n}\n\n/**\n * Construct a Windows machine image from an AMI map\n *\n * Allows you to create a generic Windows EC2 , manually specify an AMI map.\n */\nexport class GenericWindowsImage implements IMachineImage {\n  constructor(\n    private readonly amiMap: { [region: string]: string },\n    private readonly props: GenericWindowsImageProps = {},\n  ) {}\n\n  public getImage(scope: Construct): MachineImageConfig {\n    const userData = this.props.userData ?? UserData.forWindows();\n    const osType = OperatingSystemType.WINDOWS;\n    const region = AwsStack.ofAwsConstruct(scope).region;\n    // // Grid stacks are single region, region is always known\n    // if (Token.isUnresolved(region)) {\n    //   const mapping: { [k1: string]: { [k2: string]: any } } = {};\n    //   for (const [rgn, ami] of Object.entries(this.amiMap)) {\n    //     mapping[rgn] = { ami };\n    //   }\n    //   const amiMap = new TerraformLocal(scope, \"AmiMap\", { mapping });\n    //   return {\n    //     imageId: Fn.lookupNested(amiMap, Aws.REGION, \"ami\"),\n    //     userData,\n    //     osType,\n    //   };\n    // }\n    const imageId =\n      region !== \"test-region\" ? this.amiMap[region] : \"ami-12345\";\n    if (!imageId) {\n      throw new Error(\n        `Unable to find AMI in AMI map: no AMI specified for region '${region}'`,\n      );\n    }\n    return {\n      imageId,\n      userData,\n      osType,\n    };\n  }\n}\n\n/**\n * A machine image whose AMI ID will be searched using DescribeImages.\n *\n * The most recent, available, launchable image matching the given filter\n * criteria will be used. Looking up AMIs may take a long time; specify\n * as many filter criteria as possible to narrow down the search.\n *\n * The AMI selected will be cached in `grid.context.json` and the same value\n * will be used on future runs. To refresh the AMI lookup, you will have to\n * evict the value from the cache using the `grid context` command. See\n * https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.\n */\nexport class LookupMachineImage implements IMachineImage {\n  constructor(private readonly props: LookupMachineImageProps) {}\n\n  public getImage(scope: Construct): MachineImageConfig {\n    // Need to know 'windows' or not before doing the query to return the right\n    // osType for the dummy value, so might as well add it to the filter.\n    const filters: Record<string, string[] | undefined> = {\n      name: [this.props.name],\n      state: [\"available\"],\n      \"image-type\": [\"machine\"],\n      platform: this.props.windows ? [\"windows\"] : undefined,\n    };\n    Object.assign(filters, this.props.filters);\n\n    let uniqueId = \"Ami\";\n    let counter = 1;\n    while (scope.node.tryFindChild(uniqueId)) {\n      uniqueId = `Ami${counter++}`;\n    }\n\n    const dataSource = new dataAwsAmi.DataAwsAmi(scope, uniqueId, {\n      owners: this.props.owners,\n      filter: Object.entries(filters)\n        .filter(([_key, values]) => values !== undefined)\n        .map(([name, values]) => ({\n          name,\n          values: values as string[],\n        })),\n    });\n    const value = dataSource.id;\n\n    // // TODO: Use Grid as contextProvider\n    // const value = ContextProvider.getValue(scope, {\n    //   provider: cxschema.ContextProvider.AMI_PROVIDER,\n    //   props: {\n    //     owners: this.props.owners,\n    //     filters,\n    //   } as cxschema.AmiContextQuery,\n    //   dummyValue: \"ami-1234\",\n    // }).value as cxapi.AmiContextResponse;\n    //\n    // if (typeof value !== \"string\") {\n    //   throw new Error(`Response to AMI lookup invalid, got: ${value}`);\n    // }\n\n    const osType = this.props.windows\n      ? OperatingSystemType.WINDOWS\n      : OperatingSystemType.LINUX;\n\n    return {\n      imageId: value,\n      osType,\n      userData: this.props.userData ?? UserData.forOperatingSystem(osType),\n    };\n  }\n}\n\n/**\n * Properties for looking up an image\n */\nexport interface LookupMachineImageProps {\n  /**\n   * Name of the image (may contain wildcards)\n   */\n  readonly name: string;\n\n  /**\n   * Owner account IDs or aliases\n   *\n   * @default - All owners\n   */\n  readonly owners?: string[];\n\n  /**\n   * Additional filters on the AMI\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImages.html\n   * @default - No additional filters\n   */\n  readonly filters?: { [key: string]: string[] };\n\n  /**\n   * Look for Windows images\n   *\n   * @default false\n   */\n  readonly windows?: boolean;\n\n  /**\n   * Custom userdata for this image\n   *\n   * @default - Empty user data appropriate for the platform type\n   */\n  readonly userData?: UserData;\n}\n"]}