@aws-cdk/aws-imagebuilder-alpha 2.224.0-alpha.0

package/lib/infrastructure-configuration.js

@@ -0,0 +1,341 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfrastructureConfiguration = exports.Tenancy = exports.HttpTokens = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk = require("aws-cdk-lib");
+const iam = require("aws-cdk-lib/aws-iam");
+const aws_imagebuilder_1 = require("aws-cdk-lib/aws-imagebuilder");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+const prop_injectable_1 = require("aws-cdk-lib/core/lib/prop-injectable");
+const INFRASTRUCTURE_CONFIGURATION_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.InfrastructureConfiguration');
+/**
+ * Indicates whether a signed token header is required for instance metadata retrieval requests.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/APIReference/API_InstanceMetadataOptions.html#imagebuilder-Type-InstanceMetadataOptions-httpTokens
+ */
+var HttpTokens;
+(function (HttpTokens) {
+    /**
+     * Allows retrieval of instance metadata with or without a signed token header in the request
+     */
+    HttpTokens["OPTIONAL"] = "optional";
+    /**
+     * Requires a signed token header in instance metadata retrieval requests
+     */
+    HttpTokens["REQUIRED"] = "required";
+})(HttpTokens || (exports.HttpTokens = HttpTokens = {}));
+/**
+ * The tenancy to use for an instance.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/APIReference/API_Placement.html#imagebuilder-Type-Placement-tenancy
+ */
+var Tenancy;
+(function (Tenancy) {
+    /**
+     * Instances will be launched with default tenancy
+     */
+    Tenancy["DEFAULT"] = "default";
+    /**
+     * Instances will be launched with dedicated tenancy
+     */
+    Tenancy["DEDICATED"] = "dedicated";
+    /**
+     * Instances will be launched on a dedicated host
+     */
+    Tenancy["HOST"] = "host";
+})(Tenancy || (exports.Tenancy = Tenancy = {}));
+/**
+ * A new or imported Infrastructure Configuration
+ */
+class InfrastructureConfigurationBase extends cdk.Resource {
+    /**
+     * Grant custom actions to the given grantee for the infrastructure configuration
+     *
+     * @param grantee - The principal
+     * @param actions - The list of actions
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.infrastructureConfigurationArn],
+            scope: this,
+        });
+    }
+    /**
+     * Grant read permissions to the given grantee for the infrastructure configuration
+     *
+     * @param grantee - The principal
+     */
+    grantRead(grantee) {
+        return this.grant(grantee, 'imagebuilder:GetInfrastructureConfiguration');
+    }
+}
+/**
+ * Represents an EC2 Image Builder Infrastructure Configuration.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-infra-config.html
+ */
+let InfrastructureConfiguration = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = InfrastructureConfigurationBase;
+    var InfrastructureConfiguration = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            InfrastructureConfiguration = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.InfrastructureConfiguration", version: "2.224.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-imagebuilder-alpha.InfrastructureConfiguration';
+        /**
+         * Import an existing infrastructure configuration given its ARN.
+         */
+        static fromInfrastructureConfigurationArn(scope, id, infrastructureConfigurationArn) {
+            const infrastructureConfigurationName = cdk.Stack.of(scope).splitArn(infrastructureConfigurationArn, cdk.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+            class Import extends InfrastructureConfigurationBase {
+                infrastructureConfigurationArn = infrastructureConfigurationArn;
+                infrastructureConfigurationName = infrastructureConfigurationName;
+            }
+            return new Import(scope, id);
+        }
+        /**
+         * Import an existing infrastructure configuration given its name. The provided name must be normalized by converting
+         * all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens.
+         */
+        static fromInfrastructureConfigurationName(scope, id, infrastructureConfigurationName) {
+            return InfrastructureConfiguration.fromInfrastructureConfigurationArn(scope, id, cdk.Stack.of(scope).formatArn({
+                service: 'imagebuilder',
+                resource: 'infrastructure-configuration',
+                resourceName: infrastructureConfigurationName,
+            }));
+        }
+        /**
+         * Return whether the given object is an InfrastructureConfiguration.
+         */
+        static isInfrastructureConfiguration(x) {
+            return x !== null && typeof x === 'object' && INFRASTRUCTURE_CONFIGURATION_SYMBOL in x;
+        }
+        /**
+         * The ARN of the infrastructure configuration
+         */
+        infrastructureConfigurationArn;
+        /**
+         * The name of the infrastructure configuration
+         */
+        infrastructureConfigurationName;
+        /**
+         * The EC2 instance profile to use for the build
+         */
+        instanceProfile;
+        /**
+         * The role associated with the EC2 instance profile used for the build
+         */
+        role;
+        /**
+         * The bucket used to upload image build logs
+         */
+        logBucket;
+        autoGeneratedInstanceProfileRole;
+        constructor(scope, id, props = {}) {
+            super(scope, id, {
+                physicalName: props.infrastructureConfigurationName ??
+                    cdk.Lazy.string({
+                        produce: () => cdk.Names.uniqueResourceName(this, {
+                            maxLength: 128,
+                            separator: '-',
+                            allowedSpecialCharacters: '-',
+                        }).toLowerCase(), // Enforce lowercase for the auto-generated fallback
+                    }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_InfrastructureConfigurationProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, InfrastructureConfiguration);
+                }
+                throw error;
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            Object.defineProperty(this, INFRASTRUCTURE_CONFIGURATION_SYMBOL, { value: true });
+            this.validateInfrastructureConfigurationName();
+            if (props.subnetSelection && !props.vpc) {
+                throw new cdk.ValidationError('A vpc must be provided when using subnetSelection', this);
+            }
+            const selectedSubnets = props.vpc?.selectSubnets(props.subnetSelection);
+            if (props.vpc && selectedSubnets && selectedSubnets.subnetIds.length === 0) {
+                throw new cdk.ValidationError('No subnets matched the given subnetSelection for the provided VPC.', this);
+            }
+            if (props.instanceProfile && props.role) {
+                throw new cdk.ValidationError('Both an instance profile and a role cannot be provided', this);
+            }
+            if (!cdk.Token.isUnresolved(props.ec2InstanceTenancy)) {
+                if (props.ec2InstanceTenancy === Tenancy.HOST) {
+                    if (props.ec2InstanceHostId === undefined && props.ec2InstanceHostResourceGroupArn === undefined) {
+                        throw new cdk.ValidationError('ec2InstanceHostId or ec2InstanceHostResourceGroupArn must be specified when ec2InstanceTenancy is set to host', this);
+                    }
+                }
+                else {
+                    if (props.ec2InstanceHostId !== undefined) {
+                        throw new cdk.ValidationError('ec2InstanceHostId cannot be specified unless ec2InstanceTenancy is set to host', this);
+                    }
+                    if (props.ec2InstanceHostResourceGroupArn !== undefined) {
+                        throw new cdk.ValidationError('ec2InstanceHostResourceGroupArn cannot be specified unless ec2InstanceTenancy is set to host', this);
+                    }
+                }
+            }
+            if (props.ec2InstanceHostId !== undefined && props.ec2InstanceHostResourceGroupArn !== undefined) {
+                throw new cdk.ValidationError('ec2InstanceHostId and ec2InstanceHostResourceGroupArn cannot be used together', this);
+            }
+            if (props.httpPutResponseHopLimit !== undefined && props.httpPutResponseHopLimit < 1) {
+                throw new cdk.ValidationError('httpPutResponseHopLimit must be at least 1', this);
+            }
+            if (props.httpPutResponseHopLimit !== undefined && props.httpPutResponseHopLimit > 64) {
+                throw new cdk.ValidationError('httpPutResponseHopLimit must be at most 64', this);
+            }
+            if (!props.instanceProfile && !props.role) {
+                this.autoGeneratedInstanceProfileRole = new iam.Role(this, 'InstanceProfileRole', {
+                    assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
+                    managedPolicies: [
+                        iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+                        iam.ManagedPolicy.fromAwsManagedPolicyName('EC2InstanceProfileForImageBuilder'),
+                    ],
+                });
+                this.role = this.autoGeneratedInstanceProfileRole;
+            }
+            this.instanceProfile =
+                props.instanceProfile ||
+                    new iam.InstanceProfile(this, 'InstanceProfile', { role: props.role ?? this.autoGeneratedInstanceProfileRole });
+            this.role = this.instanceProfile.role;
+            this.logBucket = props.logging?.s3Bucket;
+            if (this.logBucket && this.role) {
+                this.logBucket.grantPut(this.role, props.logging?.s3KeyPrefix ? `${props.logging.s3KeyPrefix}/*` : '*');
+            }
+            const hasPlacementOptions = props.ec2InstanceAvailabilityZone !== undefined ||
+                props.ec2InstanceHostId !== undefined ||
+                props.ec2InstanceHostResourceGroupArn !== undefined ||
+                props.ec2InstanceTenancy !== undefined;
+            const placement = hasPlacementOptions
+                ? {
+                    ...(props.ec2InstanceAvailabilityZone !== undefined && {
+                        availabilityZone: props.ec2InstanceAvailabilityZone,
+                    }),
+                    ...(props.ec2InstanceHostId !== undefined && { hostId: props.ec2InstanceHostId }),
+                    ...(props.ec2InstanceHostResourceGroupArn !== undefined && {
+                        hostResourceGroupArn: props.ec2InstanceHostResourceGroupArn,
+                    }),
+                    ...(props.ec2InstanceTenancy !== undefined && { tenancy: props.ec2InstanceTenancy }),
+                }
+                : undefined;
+            const infrastructureConfiguration = new aws_imagebuilder_1.CfnInfrastructureConfiguration(this, 'Resource', {
+                name: this.physicalName,
+                instanceProfileName: this.instanceProfile.instanceProfileName,
+                description: props.description,
+                instanceMetadataOptions: {
+                    httpTokens: props.httpTokens ?? HttpTokens.REQUIRED,
+                    httpPutResponseHopLimit: props.httpPutResponseHopLimit ?? 2,
+                },
+                instanceTypes: props.instanceTypes?.length
+                    ? props.instanceTypes?.map((instanceType) => instanceType.toString())
+                    : undefined,
+                keyPair: props.keyPair?.keyPairName,
+                ...(props.logging && {
+                    logging: {
+                        s3Logs: {
+                            s3BucketName: props.logging?.s3Bucket.bucketName,
+                            s3KeyPrefix: props.logging?.s3KeyPrefix,
+                        },
+                    },
+                }),
+                ...(placement && { placement }),
+                resourceTags: props.resourceTags,
+                securityGroupIds: props.securityGroups?.length
+                    ? props.securityGroups?.map((securityGroup) => securityGroup.securityGroupId)
+                    : undefined,
+                subnetId: props.vpc?.selectSubnets(props.subnetSelection).subnetIds[0],
+                snsTopicArn: props.notificationTopic?.topicArn,
+                tags: props.tags,
+                terminateInstanceOnFailure: props.terminateInstanceOnFailure,
+            });
+            this.infrastructureConfigurationName = this.getResourceNameAttribute(infrastructureConfiguration.attrName);
+            this.infrastructureConfigurationArn = this.getResourceArnAttribute(infrastructureConfiguration.attrArn, {
+                service: 'imagebuilder',
+                resource: 'infrastructure-configuration',
+                resourceName: this.physicalName,
+            });
+        }
+        validateInfrastructureConfigurationName() {
+            if (cdk.Token.isUnresolved(this.physicalName)) {
+                return; // Cannot validate unresolved tokens, given their actual value is rendered at deployment time
+            }
+            if (this.physicalName.length > 128) {
+                throw new cdk.ValidationError('The infrastructureConfigurationName cannot be longer than 128 characters', this);
+            }
+            if (this.physicalName.includes(' ')) {
+                throw new cdk.ValidationError('The infrastructureConfigurationName cannot contain spaces', this);
+            }
+            if (this.physicalName.includes('_')) {
+                throw new cdk.ValidationError('The infrastructureConfigurationName cannot contain underscores', this);
+            }
+            if (this.physicalName !== this.physicalName.toLowerCase()) {
+                throw new cdk.ValidationError('The infrastructureConfigurationName must be lowercase', this);
+            }
+        }
+        /**
+         * @internal
+         */
+        _bind(options) {
+            if (options.isContainerBuild) {
+                this.autoGeneratedInstanceProfileRole?.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('EC2InstanceProfileForImageBuilderECRContainerBuilds'));
+            }
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return InfrastructureConfiguration = _classThis;
+})();
+exports.InfrastructureConfiguration = InfrastructureConfiguration;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infrastructure-configuration.js","sourceRoot":"","sources":["infrastructure-configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { CfnInfrastructureConfiguration } from 'aws-cdk-lib/aws-imagebuilder';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as sns from 'aws-cdk-lib/aws-sns';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport { Construct } from 'constructs';\n\nconst INFRASTRUCTURE_CONFIGURATION_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.InfrastructureConfiguration');\n\n/**\n * An EC2 Image Builder Infrastructure Configuration.\n */\nexport interface IInfrastructureConfiguration extends cdk.IResource {\n  /**\n   * The ARN of the infrastructure configuration\n   *\n   * @attribute\n   */\n  readonly infrastructureConfigurationArn: string;\n\n  /**\n   * The name of the infrastructure configuration\n   *\n   * @attribute\n   */\n  readonly infrastructureConfigurationName: string;\n\n  /**\n   * Grant custom actions to the given grantee for the infrastructure configuration\n   *\n   * @param grantee - The principal\n   * @param actions - The list of actions\n   */\n  grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;\n\n  /**\n   * Grant read permissions to the given grantee for the infrastructure configuration\n   *\n   * @param grantee - The principal\n   */\n  grantRead(grantee: iam.IGrantable): iam.Grant;\n}\n\n/**\n * Indicates whether a signed token header is required for instance metadata retrieval requests.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/APIReference/API_InstanceMetadataOptions.html#imagebuilder-Type-InstanceMetadataOptions-httpTokens\n */\nexport enum HttpTokens {\n  /**\n   * Allows retrieval of instance metadata with or without a signed token header in the request\n   */\n  OPTIONAL = 'optional',\n\n  /**\n   * Requires a signed token header in instance metadata retrieval requests\n   */\n  REQUIRED = 'required',\n}\n\n/**\n * The tenancy to use for an instance.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/APIReference/API_Placement.html#imagebuilder-Type-Placement-tenancy\n */\nexport enum Tenancy {\n  /**\n   * Instances will be launched with default tenancy\n   */\n  DEFAULT = 'default',\n\n  /**\n   * Instances will be launched with dedicated tenancy\n   */\n  DEDICATED = 'dedicated',\n\n  /**\n   * Instances will be launched on a dedicated host\n   */\n  HOST = 'host',\n}\n\n/**\n * The log settings for detailed build logging\n */\nexport interface InfrastructureConfigurationLogging {\n  /**\n   * The S3 logging bucket to use for detailed build logging\n   */\n  readonly s3Bucket: s3.IBucket;\n\n  /**\n   * The S3 logging prefix to use for detailed build logging\n   *\n   * @default No prefix\n   */\n  readonly s3KeyPrefix?: string;\n}\n\n/**\n * Properties for creating an Infrastructure Configuration resource\n */\nexport interface InfrastructureConfigurationProps {\n  /**\n   * The name of the infrastructure configuration. This name must be normalized by transforming all alphabetical\n   * characters to lowercase, and replacing all spaces and underscores with hyphens.\n   *\n   * @default A name is generated\n   */\n  readonly infrastructureConfigurationName?: string;\n\n  /**\n   * The description of the infrastructure configuration.\n   *\n   * @default None\n   */\n  readonly description?: string;\n\n  /**\n   * The instance types to launch build and test EC2 instances with.\n   *\n   * @default Image Builder will choose from a default set of instance types compatible with the AMI\n   */\n  readonly instanceTypes?: ec2.InstanceType[];\n\n  /**\n   * The instance profile to associate with the instance used to customize the AMI.\n   *\n   * By default, an instance profile and role will be created with minimal permissions needed to build the image,\n   * attached to the EC2 instance.\n   *\n   * If an S3 logging bucket and key prefix is provided, an IAM inline policy will be attached to the instance profile's\n   * role, allowing s3:PutObject permissions on the bucket.\n   *\n   * @default An instance profile will be generated\n   */\n  readonly instanceProfile?: iam.IInstanceProfile;\n  /**\n   * An IAM role to associate with the instance profile used by Image Builder\n   *\n   * The role must be assumable by the service principal `ec2.amazonaws.com`:\n   * Note: You can provide an instanceProfile or a role, but not both.\n   *\n   * @example\n   * const role = new iam.Role(this, 'MyRole', {\n   *   assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com')\n   * });\n   *\n   * @default A role will automatically be created, it can be accessed via the `role` property\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * The VPC to place the instance used to customize the AMI.\n   *\n   * @default The default VPC will be used\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Select which subnet to place the instance used to customize the AMI. The first subnet that is selected will be used.\n   * You must specify the VPC to customize the subnet selection.\n   *\n   * @default The first subnet selected from the provided VPC will be used\n   */\n  readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * The security groups to associate with the instance used to customize the AMI.\n   *\n   * @default The default security group for the VPC will be used\n   */\n  readonly securityGroups?: ec2.ISecurityGroup[];\n\n  /**\n   * The key pair used to connect to the build and test EC2 instances. The key pair can be used to log into the build\n   * or test instances for troubleshooting any failures.\n   *\n   * @default None\n   */\n  readonly keyPair?: ec2.IKeyPair;\n\n  /**\n   * Whether to terminate the EC2 instance when the build or test workflow fails.\n   *\n   * @default true\n   */\n  readonly terminateInstanceOnFailure?: boolean;\n\n  /**\n   * The maximum number of hops that an instance metadata request can traverse to reach its destination. By default,\n   * this is set to 2.\n   *\n   * @default 2\n   */\n  readonly httpPutResponseHopLimit?: number;\n\n  /**\n   * Indicates whether a signed token header is required for instance metadata retrieval requests. By default, this is\n   * set to `required` to require IMDSv2 on build and test EC2 instances.\n   *\n   * @default HttpTokens.REQUIRED\n   */\n  readonly httpTokens?: HttpTokens;\n\n  /**\n   * The SNS topic on which notifications are sent when an image build completes.\n   *\n   * @default No notifications are sent\n   */\n  readonly notificationTopic?: sns.ITopic;\n\n  /**\n   * The log settings for detailed build logging.\n   *\n   * @default None\n   */\n  readonly logging?: InfrastructureConfigurationLogging;\n\n  /**\n   * The availability zone to place Image Builder build and test EC2 instances.\n   *\n   * @default EC2 will select a random zone\n   */\n  readonly ec2InstanceAvailabilityZone?: string;\n\n  /**\n   * The ID of the Dedicated Host on which build and test instances run. This only applies if the instance tenancy is\n   * `host`. This cannot be used with the `ec2InstanceHostResourceGroupArn` parameter.\n   *\n   * @default None\n   */\n  readonly ec2InstanceHostId?: string;\n\n  /**\n   * The ARN of the host resource group on which build and test instances run. This only applies if the instance tenancy\n   * is `host`. This cannot be used with the `ec2InstanceHostId` parameter.\n   *\n   * @default None\n   */\n  readonly ec2InstanceHostResourceGroupArn?: string;\n\n  /**\n   * The tenancy of the instance. Dedicated tenancy runs instances on single-tenant hardware, while host tenancy runs\n   * instances on a dedicated host. Shared tenancy is used by default.\n   *\n   * @default Tenancy.DEFAULT\n   */\n  readonly ec2InstanceTenancy?: Tenancy;\n\n  /**\n   * The additional tags to assign to the Amazon EC2 instance that Image Builder launches during the build process.\n   *\n   * @default None\n   */\n  readonly resourceTags?: { [key: string]: string };\n\n  /**\n   * The tags to apply to the infrastructure configuration\n   *\n   * @default None\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * Context information passed when an Infrastructure Configuration is being consumed\n *\n * @internal\n */\nexport interface InfrastructureConfigurationBindOptions {\n  /**\n   * Indicates whether the infrastructure configuration is being consumed inside of a container build\n   */\n  readonly isContainerBuild?: boolean;\n}\n\n/**\n * A new or imported Infrastructure Configuration\n */\nabstract class InfrastructureConfigurationBase extends cdk.Resource implements IInfrastructureConfiguration {\n  /**\n   * The ARN of the infrastructure configuration\n   */\n  abstract readonly infrastructureConfigurationArn: string;\n  /**\n   * The name of the infrastructure configuration\n   */\n  abstract readonly infrastructureConfigurationName: string;\n\n  /**\n   * Grant custom actions to the given grantee for the infrastructure configuration\n   *\n   * @param grantee - The principal\n   * @param actions - The list of actions\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.infrastructureConfigurationArn],\n      scope: this,\n    });\n  }\n\n  /**\n   * Grant read permissions to the given grantee for the infrastructure configuration\n   *\n   * @param grantee - The principal\n   */\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, 'imagebuilder:GetInfrastructureConfiguration');\n  }\n}\n\n/**\n * Represents an EC2 Image Builder Infrastructure Configuration.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-infra-config.html\n */\n@propertyInjectable\nexport class InfrastructureConfiguration extends InfrastructureConfigurationBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-imagebuilder-alpha.InfrastructureConfiguration';\n\n  /**\n   * Import an existing infrastructure configuration given its ARN.\n   */\n  public static fromInfrastructureConfigurationArn(\n    scope: Construct,\n    id: string,\n    infrastructureConfigurationArn: string,\n  ): IInfrastructureConfiguration {\n    const infrastructureConfigurationName = cdk.Stack.of(scope).splitArn(\n      infrastructureConfigurationArn,\n      cdk.ArnFormat.SLASH_RESOURCE_NAME,\n    ).resourceName!;\n\n    class Import extends InfrastructureConfigurationBase {\n      public readonly infrastructureConfigurationArn = infrastructureConfigurationArn;\n      public readonly infrastructureConfigurationName = infrastructureConfigurationName;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Import an existing infrastructure configuration given its name. The provided name must be normalized by converting\n   * all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens.\n   */\n  public static fromInfrastructureConfigurationName(\n    scope: Construct,\n    id: string,\n    infrastructureConfigurationName: string,\n  ): IInfrastructureConfiguration {\n    return InfrastructureConfiguration.fromInfrastructureConfigurationArn(\n      scope,\n      id,\n      cdk.Stack.of(scope).formatArn({\n        service: 'imagebuilder',\n        resource: 'infrastructure-configuration',\n        resourceName: infrastructureConfigurationName,\n      }),\n    );\n  }\n\n  /**\n   * Return whether the given object is an InfrastructureConfiguration.\n   */\n  public static isInfrastructureConfiguration(x: any): x is InfrastructureConfiguration {\n    return x !== null && typeof x === 'object' && INFRASTRUCTURE_CONFIGURATION_SYMBOL in x;\n  }\n\n  /**\n   * The ARN of the infrastructure configuration\n   */\n  public readonly infrastructureConfigurationArn: string;\n\n  /**\n   * The name of the infrastructure configuration\n   */\n  public readonly infrastructureConfigurationName: string;\n\n  /**\n   * The EC2 instance profile to use for the build\n   */\n  public readonly instanceProfile: iam.IInstanceProfile;\n\n  /**\n   * The role associated with the EC2 instance profile used for the build\n   */\n  public readonly role?: iam.IRole;\n\n  /**\n   * The bucket used to upload image build logs\n   */\n  public readonly logBucket?: s3.IBucket;\n\n  private readonly autoGeneratedInstanceProfileRole?: iam.IRole;\n\n  public constructor(scope: Construct, id: string, props: InfrastructureConfigurationProps = {}) {\n    super(scope, id, {\n      physicalName:\n        props.infrastructureConfigurationName ??\n        cdk.Lazy.string({\n          produce: () =>\n            cdk.Names.uniqueResourceName(this, {\n              maxLength: 128,\n              separator: '-',\n              allowedSpecialCharacters: '-',\n            }).toLowerCase(), // Enforce lowercase for the auto-generated fallback\n        }),\n    });\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    Object.defineProperty(this, INFRASTRUCTURE_CONFIGURATION_SYMBOL, { value: true });\n\n    this.validateInfrastructureConfigurationName();\n\n    if (props.subnetSelection && !props.vpc) {\n      throw new cdk.ValidationError('A vpc must be provided when using subnetSelection', this);\n    }\n\n    const selectedSubnets = props.vpc?.selectSubnets(props.subnetSelection);\n    if (props.vpc && selectedSubnets && selectedSubnets.subnetIds.length === 0) {\n      throw new cdk.ValidationError('No subnets matched the given subnetSelection for the provided VPC.', this);\n    }\n\n    if (props.instanceProfile && props.role) {\n      throw new cdk.ValidationError('Both an instance profile and a role cannot be provided', this);\n    }\n\n    if (!cdk.Token.isUnresolved(props.ec2InstanceTenancy)) {\n      if (props.ec2InstanceTenancy === Tenancy.HOST) {\n        if (props.ec2InstanceHostId === undefined && props.ec2InstanceHostResourceGroupArn === undefined) {\n          throw new cdk.ValidationError(\n            'ec2InstanceHostId or ec2InstanceHostResourceGroupArn must be specified when ec2InstanceTenancy is set to host',\n            this,\n          );\n        }\n      } else {\n        if (props.ec2InstanceHostId !== undefined) {\n          throw new cdk.ValidationError(\n            'ec2InstanceHostId cannot be specified unless ec2InstanceTenancy is set to host',\n            this,\n          );\n        }\n\n        if (props.ec2InstanceHostResourceGroupArn !== undefined) {\n          throw new cdk.ValidationError(\n            'ec2InstanceHostResourceGroupArn cannot be specified unless ec2InstanceTenancy is set to host',\n            this,\n          );\n        }\n      }\n    }\n\n    if (props.ec2InstanceHostId !== undefined && props.ec2InstanceHostResourceGroupArn !== undefined) {\n      throw new cdk.ValidationError(\n        'ec2InstanceHostId and ec2InstanceHostResourceGroupArn cannot be used together',\n        this,\n      );\n    }\n\n    if (props.httpPutResponseHopLimit !== undefined && props.httpPutResponseHopLimit < 1) {\n      throw new cdk.ValidationError('httpPutResponseHopLimit must be at least 1', this);\n    }\n\n    if (props.httpPutResponseHopLimit !== undefined && props.httpPutResponseHopLimit > 64) {\n      throw new cdk.ValidationError('httpPutResponseHopLimit must be at most 64', this);\n    }\n\n    if (!props.instanceProfile && !props.role) {\n      this.autoGeneratedInstanceProfileRole = new iam.Role(this, 'InstanceProfileRole', {\n        assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),\n        managedPolicies: [\n          iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),\n          iam.ManagedPolicy.fromAwsManagedPolicyName('EC2InstanceProfileForImageBuilder'),\n        ],\n      });\n      this.role = this.autoGeneratedInstanceProfileRole;\n    }\n\n    this.instanceProfile =\n      props.instanceProfile ||\n      new iam.InstanceProfile(this, 'InstanceProfile', { role: props.role ?? this.autoGeneratedInstanceProfileRole });\n\n    this.role = this.instanceProfile.role;\n    this.logBucket = props.logging?.s3Bucket;\n\n    if (this.logBucket && this.role) {\n      this.logBucket.grantPut(this.role, props.logging?.s3KeyPrefix ? `${props.logging.s3KeyPrefix}/*` : '*');\n    }\n\n    const hasPlacementOptions =\n      props.ec2InstanceAvailabilityZone !== undefined ||\n      props.ec2InstanceHostId !== undefined ||\n      props.ec2InstanceHostResourceGroupArn !== undefined ||\n      props.ec2InstanceTenancy !== undefined;\n    const placement: CfnInfrastructureConfiguration.PlacementProperty | undefined = hasPlacementOptions\n      ? {\n        ...(props.ec2InstanceAvailabilityZone !== undefined && {\n          availabilityZone: props.ec2InstanceAvailabilityZone,\n        }),\n        ...(props.ec2InstanceHostId !== undefined && { hostId: props.ec2InstanceHostId }),\n        ...(props.ec2InstanceHostResourceGroupArn !== undefined && {\n          hostResourceGroupArn: props.ec2InstanceHostResourceGroupArn,\n        }),\n        ...(props.ec2InstanceTenancy !== undefined && { tenancy: props.ec2InstanceTenancy }),\n      }\n      : undefined;\n\n    const infrastructureConfiguration = new CfnInfrastructureConfiguration(this, 'Resource', {\n      name: this.physicalName,\n      instanceProfileName: this.instanceProfile.instanceProfileName,\n      description: props.description,\n      instanceMetadataOptions: {\n        httpTokens: props.httpTokens ?? HttpTokens.REQUIRED,\n        httpPutResponseHopLimit: props.httpPutResponseHopLimit ?? 2,\n      },\n      instanceTypes: props.instanceTypes?.length\n        ? props.instanceTypes?.map((instanceType) => instanceType.toString())\n        : undefined,\n      keyPair: props.keyPair?.keyPairName,\n      ...(props.logging && {\n        logging: {\n          s3Logs: {\n            s3BucketName: props.logging?.s3Bucket.bucketName,\n            s3KeyPrefix: props.logging?.s3KeyPrefix,\n          },\n        },\n      }),\n      ...(placement && { placement }),\n      resourceTags: props.resourceTags,\n      securityGroupIds: props.securityGroups?.length\n        ? props.securityGroups?.map((securityGroup) => securityGroup.securityGroupId)\n        : undefined,\n      subnetId: props.vpc?.selectSubnets(props.subnetSelection).subnetIds[0],\n      snsTopicArn: props.notificationTopic?.topicArn,\n      tags: props.tags,\n      terminateInstanceOnFailure: props.terminateInstanceOnFailure,\n    });\n\n    this.infrastructureConfigurationName = this.getResourceNameAttribute(infrastructureConfiguration.attrName);\n    this.infrastructureConfigurationArn = this.getResourceArnAttribute(infrastructureConfiguration.attrArn, {\n      service: 'imagebuilder',\n      resource: 'infrastructure-configuration',\n      resourceName: this.physicalName,\n    });\n  }\n\n  private validateInfrastructureConfigurationName() {\n    if (cdk.Token.isUnresolved(this.physicalName)) {\n      return; // Cannot validate unresolved tokens, given their actual value is rendered at deployment time\n    }\n\n    if (this.physicalName.length > 128) {\n      throw new cdk.ValidationError('The infrastructureConfigurationName cannot be longer than 128 characters', this);\n    }\n\n    if (this.physicalName.includes(' ')) {\n      throw new cdk.ValidationError('The infrastructureConfigurationName cannot contain spaces', this);\n    }\n\n    if (this.physicalName.includes('_')) {\n      throw new cdk.ValidationError('The infrastructureConfigurationName cannot contain underscores', this);\n    }\n\n    if (this.physicalName !== this.physicalName.toLowerCase()) {\n      throw new cdk.ValidationError('The infrastructureConfigurationName must be lowercase', this);\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public _bind(options: InfrastructureConfigurationBindOptions) {\n    if (options.isContainerBuild) {\n      this.autoGeneratedInstanceProfileRole?.addManagedPolicy(\n        iam.ManagedPolicy.fromAwsManagedPolicyName('EC2InstanceProfileForImageBuilderECRContainerBuilds'),\n      );\n    }\n  }\n}\n"]}

package/node_modules/yaml/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2018 Eemeli Aro <eemeli@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/node_modules/yaml/README.md

@@ -0,0 +1,127 @@
+# YAML <a href="https://www.npmjs.com/package/yaml"><img align="right" src="https://badge.fury.io/js/yaml.svg" title="npm package" /></a>
+
+`yaml` is a JavaScript parser and stringifier for [YAML](http://yaml.org/), a human friendly data serialization standard. It supports both parsing and stringifying data using all versions of YAML, along with all common data schemas. As a particularly distinguishing feature, `yaml` fully supports reading and writing comments and blank lines in YAML documents.
+
+The library is released under the ISC open source license, and the code is [available on GitHub](https://github.com/eemeli/yaml/). It has no external dependencies and runs on Node.js 6 and later, and in browsers from IE 11 upwards.
+
+For the purposes of versioning, any changes that break any of the endpoints or APIs documented here will be considered semver-major breaking changes. Undocumented library internals may change between minor versions, and previous APIs may be deprecated (but not removed).
+
+For more information, see the project's documentation site: [**eemeli.org/yaml/v1**](https://eemeli.org/yaml/v1/)
+
+To install:
+
+```sh
+npm install yaml
+```
+
+**Note:** This is `yaml@1`. You may also be interested in the next version, currently available as [`yaml@next`](https://www.npmjs.com/package/yaml/v/next).
+
+## API Overview
+
+The API provided by `yaml` has three layers, depending on how deep you need to go: [Parse & Stringify](https://eemeli.org/yaml/v1/#parse-amp-stringify), [Documents](https://eemeli.org/yaml/#documents), and the [CST Parser](https://eemeli.org/yaml/#cst-parser). The first has the simplest API and "just works", the second gets you all the bells and whistles supported by the library along with a decent [AST](https://eemeli.org/yaml/#content-nodes), and the third is the closest to YAML source, making it fast, raw, and crude.
+
+```js
+import YAML from 'yaml'
+// or
+const YAML = require('yaml')
+```
+
+### Parse & Stringify
+
+- [`YAML.parse(str, options): value`](https://eemeli.org/yaml/v1/#yaml-parse)
+- [`YAML.stringify(value, options): string`](https://eemeli.org/yaml/v1/#yaml-stringify)
+
+### YAML Documents
+
+- [`YAML.createNode(value, wrapScalars, tag): Node`](https://eemeli.org/yaml/v1/#creating-nodes)
+- [`YAML.defaultOptions`](https://eemeli.org/yaml/v1/#options)
+- [`YAML.Document`](https://eemeli.org/yaml/v1/#yaml-documents)
+  - [`constructor(options)`](https://eemeli.org/yaml/v1/#creating-documents)
+  - [`defaults`](https://eemeli.org/yaml/v1/#options)
+  - [`#anchors`](https://eemeli.org/yaml/v1/#working-with-anchors)
+  - [`#contents`](https://eemeli.org/yaml/v1/#content-nodes)
+  - [`#errors`](https://eemeli.org/yaml/v1/#errors)
+- [`YAML.parseAllDocuments(str, options): YAML.Document[]`](https://eemeli.org/yaml/v1/#parsing-documents)
+- [`YAML.parseDocument(str, options): YAML.Document`](https://eemeli.org/yaml/v1/#parsing-documents)
+
+```js
+import { Pair, YAMLMap, YAMLSeq } from 'yaml/types'
+```
+
+- [`new Pair(key, value)`](https://eemeli.org/yaml/v1/#creating-nodes)
+- [`new YAMLMap()`](https://eemeli.org/yaml/v1/#creating-nodes)
+- [`new YAMLSeq()`](https://eemeli.org/yaml/v1/#creating-nodes)
+
+### CST Parser
+
+```js
+import parseCST from 'yaml/parse-cst'
+```
+
+- [`parseCST(str): CSTDocument[]`](https://eemeli.org/yaml/v1/#parsecst)
+- [`YAML.parseCST(str): CSTDocument[]`](https://eemeli.org/yaml/v1/#parsecst)
+
+## YAML.parse
+
+```yaml
+# file.yml
+YAML:
+  - A human-readable data serialization language
+  - https://en.wikipedia.org/wiki/YAML
+yaml:
+  - A complete JavaScript implementation
+  - https://www.npmjs.com/package/yaml
+```
+
+```js
+import fs from 'fs'
+import YAML from 'yaml'
+
+YAML.parse('3.14159')
+// 3.14159
+
+YAML.parse('[ true, false, maybe, null ]\n')
+// [ true, false, 'maybe', null ]
+
+const file = fs.readFileSync('./file.yml', 'utf8')
+YAML.parse(file)
+// { YAML:
+//   [ 'A human-readable data serialization language',
+//     'https://en.wikipedia.org/wiki/YAML' ],
+//   yaml:
+//   [ 'A complete JavaScript implementation',
+//     'https://www.npmjs.com/package/yaml' ] }
+```
+
+## YAML.stringify
+
+```js
+import YAML from 'yaml'
+
+YAML.stringify(3.14159)
+// '3.14159\n'
+
+YAML.stringify([true, false, 'maybe', null])
+// `- true
+// - false
+// - maybe
+// - null
+// `
+
+YAML.stringify({ number: 3, plain: 'string', block: 'two\nlines\n' })
+// `number: 3
+// plain: string
+// block: >
+//   two
+//
+//   lines
+// `
+```
+
+---
+
+Browser testing provided by:
+
+<a href="https://www.browserstack.com/open-source">
+<img width=200 src="https://eemeli.org/yaml/images/browserstack.svg" />
+</a>