terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/user-data.js

@@ -0,0 +1,487 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultipartUserData = exports.MultipartBody = exports.UserData = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/user-data.ts
+const provider_cloudinit_1 = require("@cdktf/provider-cloudinit");
+const cdktf_1 = require("cdktf");
+const common_1 = require("./machine-image/common");
+// TODO: Support Content Transfer Encoding
+// https://stackoverflow.com/questions/25710599/content-transfer-encoding-7bit-or-8-bit
+/**
+ * Instance User Data
+ *
+ * resource: data_cloudinit_config
+ *
+ * This is limited to 7bit encoding
+ * ref open issue: https://github.com/hashicorp/terraform-provider-cloudinit/pull/170
+ */
+class UserData {
+    /**
+     * Create a userdata object for Linux hosts
+     */
+    static forLinux(options = {}) {
+        return new LinuxUserData(options);
+    }
+    /**
+     * Create a userdata object for Windows hosts
+     */
+    static forWindows(options = {}) {
+        return new WindowsUserData(options);
+    }
+    /**
+     * Create a userdata object with custom content
+     */
+    static custom(content) {
+        const userData = new CustomUserData();
+        userData.addCommands(content);
+        return userData;
+    }
+    static forOperatingSystem(os) {
+        switch (os) {
+            case common_1.OperatingSystemType.LINUX:
+                return UserData.forLinux();
+            case common_1.OperatingSystemType.WINDOWS:
+                return UserData.forWindows();
+            case common_1.OperatingSystemType.UNKNOWN:
+                throw new Error("Cannot determine UserData for unknown operating system type");
+        }
+    }
+    constructor(userdataOptions = {}) {
+        if (userdataOptions.base64Encode === false &&
+            userdataOptions.gzip === true) {
+            throw new Error("Cannot disable base64 encoding if gzip is enabled");
+        }
+        this.base64Encode = userdataOptions.base64Encode ?? true;
+        this.gzip = userdataOptions.gzip ?? true;
+    }
+}
+exports.UserData = UserData;
+_a = JSII_RTTI_SYMBOL_1;
+UserData[_a] = { fqn: "terraconstructs.aws.compute.UserData", version: "0.0.12" };
+/**
+ * Linux Instance User Data
+ */
+class LinuxUserData extends UserData {
+    constructor(props = {}) {
+        super();
+        this.lines = [];
+        this.onExitLines = [];
+        this.shebang = props.shebang ?? "#!/bin/bash";
+        this.contentType = props.contentType;
+        this.filename = props.filename;
+    }
+    addCommands(...commands) {
+        this.lines.push(...commands);
+    }
+    addOnExitCommands(...commands) {
+        this.onExitLines.push(...commands);
+    }
+    get content() {
+        return [this.shebang, ...this.renderOnExitLines(), ...this.lines].join("\n");
+    }
+    render(scope) {
+        return new provider_cloudinit_1.dataCloudinitConfig.DataCloudinitConfig(scope, "UserData", {
+            base64Encode: this.base64Encode,
+            gzip: this.gzip,
+            // Pass our script as a single part with proper content type.
+            part: [
+                {
+                    content: cdktf_1.Lazy.stringValue({
+                        produce: () => this.content,
+                    }),
+                    contentType: this.contentType,
+                    filename: this.filename,
+                },
+            ],
+        }).rendered;
+    }
+    addS3DownloadCommand(params) {
+        const s3Path = `s3://${params.bucket.bucketName}/${params.bucketKey}`;
+        const localPath = params.localFile && params.localFile.length !== 0
+            ? params.localFile
+            : `/tmp/${params.bucketKey}`;
+        this.addCommands(`mkdir -p $(dirname '${localPath}')`, `aws s3 cp '${s3Path}' '${localPath}'` +
+            (params.region !== undefined ? ` --region ${params.region}` : ""));
+        return localPath;
+    }
+    addExecuteFileCommand(params) {
+        this.addCommands("set -e", `chmod +x '${params.filePath}'`, `'${params.filePath}' ${params.arguments ?? ""}`.trim());
+    }
+    // // TODO: Add Grid Signals - copy grid-signal binary in provisioner
+    // public addSignalOnExitCommand(resource: AwsConstructBase): void {
+    //   const stack = AwsStack.ofAwsConstruct(resource);
+    //   const resourceID = (resource.node.defaultChild as TerraformResource).fqn;
+    //   this.addOnExitCommands(
+    //     `/opt/aws/bin/grid-signal --stack ${stack.gridUUID} --resource ${resourceID} --region ${stack.region} -e $exitCode || echo 'Failed to send Cloudformation Signal'`,
+    //   );
+    // }
+    renderOnExitLines() {
+        if (this.onExitLines.length > 0) {
+            return [
+                "function exitTrap(){",
+                "exitCode=$?",
+                ...this.onExitLines,
+                "}",
+                "trap exitTrap EXIT",
+            ];
+        }
+        return [];
+    }
+}
+/**
+ * Windows Instance User Data
+ */
+class WindowsUserData extends UserData {
+    constructor(props = {}) {
+        super();
+        this.lines = [];
+        this.onExitLines = [];
+        this.persist = props.persist ?? false;
+        this.contentType = props.contentType;
+        this.filename = props.filename;
+    }
+    addCommands(...commands) {
+        this.lines.push(...commands);
+    }
+    addOnExitCommands(...commands) {
+        this.onExitLines.push(...commands);
+    }
+    get content() {
+        return `<powershell>${[
+            ...this.renderOnExitLines(),
+            ...this.lines,
+            ...(this.onExitLines.length > 0 ? ['throw "Success"'] : []),
+        ].join("\n")}</powershell>${(this.persist ?? false) ? "<persist>true</persist>" : ""}`;
+    }
+    render(scope) {
+        return new provider_cloudinit_1.dataCloudinitConfig.DataCloudinitConfig(scope, "UserData", {
+            base64Encode: this.base64Encode,
+            gzip: this.gzip,
+            // Pass our script as a single part with proper content type.
+            part: [
+                {
+                    content: cdktf_1.Lazy.stringValue({
+                        produce: () => this.content,
+                    }),
+                    contentType: this.contentType,
+                    filename: this.filename,
+                },
+            ],
+        }).rendered;
+    }
+    addS3DownloadCommand(params) {
+        const localPath = params.localFile && params.localFile.length !== 0
+            ? params.localFile
+            : `C:/temp/${params.bucketKey}`;
+        this.addCommands(`mkdir (Split-Path -Path '${localPath}' ) -ea 0`, `Read-S3Object -BucketName '${params.bucket.bucketName}' -key '${params.bucketKey}' -file '${localPath}' -ErrorAction Stop` +
+            (params.region !== undefined ? ` -Region ${params.region}` : ""));
+        return localPath;
+    }
+    addExecuteFileCommand(params) {
+        this.addCommands(`&'${params.filePath}' ${params.arguments ?? ""}`.trim(), `if (!$?) { Write-Error 'Failed to execute the file "${params.filePath}"' -ErrorAction Stop }`);
+    }
+    // // TODO: Add Grid Signals
+    // public addSignalOnExitCommand(resource: AwsConstructBase): void {
+    //   const stack = AwsStack.ofAwsConstruct(resource);
+    //   const resourceID = (resource.node.defaultChild as TerraformResource).fqn;
+    //   this.addOnExitCommands(
+    //     `grid-signal --stack ${stack.gridUUID} --resource ${resourceID} --region ${stack.region} --success ($success.ToString().ToLower())`,
+    //   );
+    // }
+    renderOnExitLines() {
+        if (this.onExitLines.length > 0) {
+            return [
+                "trap {",
+                '$success=($PSItem.Exception.Message -eq "Success")',
+                ...this.onExitLines,
+                "break",
+                "}",
+            ];
+        }
+        return [];
+    }
+}
+/**
+ * Custom Instance User Data
+ */
+class CustomUserData extends UserData {
+    constructor() {
+        super();
+        this.lines = [];
+    }
+    addCommands(...commands) {
+        this.lines.push(...commands);
+    }
+    addOnExitCommands() {
+        throw new Error("CustomUserData does not support addOnExitCommands, use UserData.forLinux() or UserData.forWindows() instead.");
+    }
+    get content() {
+        return this.lines.join("\n");
+    }
+    render(scope) {
+        return new provider_cloudinit_1.dataCloudinitConfig.DataCloudinitConfig(scope, "UserData", {
+            base64Encode: this.base64Encode,
+            gzip: this.gzip,
+            // Pass our script as a single part with proper content type.
+            part: [
+                {
+                    content: cdktf_1.Lazy.stringValue({
+                        produce: () => this.content,
+                    }),
+                    contentType: this.contentType,
+                    filename: this.filename,
+                },
+            ],
+        }).rendered;
+    }
+    addS3DownloadCommand() {
+        throw new Error("CustomUserData does not support addS3DownloadCommand, use UserData.forLinux() or UserData.forWindows() instead.");
+    }
+    addExecuteFileCommand() {
+        throw new Error("CustomUserData does not support addExecuteFileCommand, use UserData.forLinux() or UserData.forWindows() instead.");
+    }
+    addSignalOnExitCommand() {
+        throw new Error("CustomUserData does not support addSignalOnExitCommand, use UserData.forLinux() or UserData.forWindows() instead.");
+    }
+}
+// /**
+//  * Options when creating `MultipartBody`.
+//  */
+// export interface MultipartBodyOptions {
+//   /**
+//    * `Content-Type` header of this part.
+//    *
+//    * Some examples of content types:
+//    * * `text/x-shellscript; charset="utf-8"` (shell script)
+//    * * `text/cloud-boothook; charset="utf-8"` (shell script executed during boot phase)
+//    *
+//    * For Linux shell scripts use `text/x-shellscript`.
+//    */
+//   readonly contentType: string;
+//   // terraform provider has this hardcoded
+//   // https://github.com/hashicorp/terraform-provider-cloudinit/blob/v2.3.6/internal/provider/cloudinit_config.go#L180
+//   // /**
+//   //  * `Content-Transfer-Encoding` header specifying part encoding.
+//   //  *
+//   //  * @default undefined - body is not encoded
+//   //  */
+//   // readonly transferEncoding?: string;
+//   /**
+//    * The body of message.
+//    *
+//    * @default undefined - body will not be added to part
+//    */
+//   readonly body?: string;
+// }
+/**
+ * The base class for all classes which can be used as `MultipartUserData`.
+ */
+class MultipartBody {
+    /**
+     * Constructs the new `MultipartBody` wrapping existing `UserData`. Modification to `UserData` are reflected
+     * in subsequent renders of the part.
+     *
+     * For more information about content types see `MultipartBodyOptions.contentType`.
+     *
+     * @param userData user data to wrap into body part
+     * @param contentType optional content type, if default one should not be used
+     */
+    static fromUserData(userData, contentType) {
+        return new MultipartBodyUserDataWrapper(userData, contentType);
+    }
+    /**
+    * When transfer encoding is specified (typically as Base64), it's caller responsibility to convert body to
+    * Base64 either by wrapping with `Fn.base64` or by converting it by other converters.
+    *
+    * Note: https://github.com/hashicorp/terraform-provider-cloudinit/pull/170
+    * /
+  
+    /**
+     * Constructs the raw `MultipartBody` using specified body, content type, filename and merge type
+     */
+    static fromRawBody(opts) {
+        return new MultipartBodyRaw(opts);
+    }
+    constructor() { }
+}
+exports.MultipartBody = MultipartBody;
+_b = JSII_RTTI_SYMBOL_1;
+MultipartBody[_b] = { fqn: "terraconstructs.aws.compute.MultipartBody", version: "0.0.12" };
+/**
+ * Content type for shell scripts
+ */
+MultipartBody.SHELL_SCRIPT = 'text/x-shellscript; charset="utf-8"';
+/**
+ * Content type for boot hooks
+ */
+MultipartBody.CLOUD_BOOTHOOK = 'text/cloud-boothook; charset="utf-8"';
+/**
+ * The raw part of multi-part user data, which can be added to `MultipartUserData`.
+ */
+class MultipartBodyRaw extends MultipartBody {
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    /**
+     * Raw return part
+     */
+    renderBodyPart() {
+        return this.props;
+    }
+}
+/**
+ * Wrapper for `UserData`.
+ */
+class MultipartBodyUserDataWrapper extends MultipartBody {
+    constructor(userData, contentType) {
+        super();
+        this.userData = userData;
+        this.contentType = contentType || MultipartBody.SHELL_SCRIPT;
+    }
+    /**
+     * Render body parts
+     */
+    renderBodyPart() {
+        return {
+            content: this.userData.content,
+            contentType: this.contentType ?? this.userData.contentType,
+            filename: this.userData.filename,
+        };
+    }
+}
+/**
+ * Mime multipart user data.
+ *
+ * This class represents MIME multipart user data, as described in.
+ * [Specifying Multiple User Data Blocks Using a MIME Multi Part Archive](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#multi-part_user_data)
+ *
+ */
+class MultipartUserData extends UserData {
+    constructor(opts) {
+        super(opts);
+        this.parts = [];
+        this.contentType = opts?.contentType;
+        this.filename = opts?.filename;
+        let partsSeparator;
+        // Validate separator
+        if (opts?.partsSeparator != null) {
+            if (new RegExp(MultipartUserData.BOUNDRY_PATTERN).test(opts.partsSeparator)) {
+                throw new Error(`Invalid characters in separator. Separator has to match pattern ${MultipartUserData.BOUNDRY_PATTERN}`);
+            }
+            else {
+                partsSeparator = opts.partsSeparator;
+            }
+        }
+        else {
+            partsSeparator = "+AWS+CDK+User+Data+Separator==";
+        }
+        this.opts = {
+            partsSeparator: partsSeparator,
+        };
+    }
+    /**
+     * Adds a part to the list of parts.
+     */
+    addPart(part) {
+        this.parts.push(part);
+    }
+    /**
+     * Adds a multipart part based on a UserData object.
+     *
+     * If `makeDefault` is true, then the UserData added by this method
+     * will also be the target of calls to the `add*Command` methods on
+     * this MultipartUserData object.
+     *
+     * If `makeDefault` is false, then this is the same as calling:
+     *
+     * ```ts
+     * declare const multiPart: compute.MultipartUserData;
+     * declare const userData: compute.UserData;
+     * declare const contentType: string;
+     *
+     * multiPart.addPart(compute.MultipartBody.fromUserData(userData, contentType));
+     * ```
+     *
+     * An undefined `makeDefault` defaults to either:
+     * - `true` if no default UserData has been set yet; or
+     * - `false` if there is no default UserData set.
+     */
+    addUserDataPart(userData, contentType, makeDefault) {
+        this.addPart(MultipartBody.fromUserData(userData, contentType));
+        makeDefault =
+            makeDefault ?? (this.defaultUserData === undefined ? true : false);
+        if (makeDefault) {
+            this.defaultUserData = userData;
+        }
+    }
+    /**
+     * The content of the default UserData.
+     */
+    get content() {
+        if (this.defaultUserData) {
+            return this.defaultUserData.content;
+        }
+        else {
+            throw new Error(MultipartUserData.USE_PART_ERROR);
+        }
+    }
+    render(scope) {
+        return new provider_cloudinit_1.dataCloudinitConfig.DataCloudinitConfig(scope, "UserData", {
+            boundary: this.opts.partsSeparator,
+            base64Encode: this.base64Encode,
+            gzip: this.gzip,
+            part: cdktf_1.Lazy.anyValue({
+                produce: () => this.parts.map((p) => p.renderBodyPart()),
+            }),
+        }).rendered;
+    }
+    addS3DownloadCommand(params) {
+        if (this.defaultUserData) {
+            return this.defaultUserData.addS3DownloadCommand(params);
+        }
+        else {
+            throw new Error(MultipartUserData.USE_PART_ERROR);
+        }
+    }
+    addExecuteFileCommand(params) {
+        if (this.defaultUserData) {
+            this.defaultUserData.addExecuteFileCommand(params);
+        }
+        else {
+            throw new Error(MultipartUserData.USE_PART_ERROR);
+        }
+    }
+    // // TODO: Add Grid Signals
+    // public addSignalOnExitCommand(resource: AwsConstructBase): void {
+    //   if (this.defaultUserData) {
+    //     this.defaultUserData.addSignalOnExitCommand(resource);
+    //   } else {
+    //     throw new Error(MultipartUserData.USE_PART_ERROR);
+    //   }
+    // }
+    addCommands(...commands) {
+        if (this.defaultUserData) {
+            this.defaultUserData.addCommands(...commands);
+        }
+        else {
+            throw new Error(MultipartUserData.USE_PART_ERROR);
+        }
+    }
+    addOnExitCommands(...commands) {
+        if (this.defaultUserData) {
+            this.defaultUserData.addOnExitCommands(...commands);
+        }
+        else {
+            throw new Error(MultipartUserData.USE_PART_ERROR);
+        }
+    }
+}
+exports.MultipartUserData = MultipartUserData;
+_c = JSII_RTTI_SYMBOL_1;
+MultipartUserData[_c] = { fqn: "terraconstructs.aws.compute.MultipartUserData", version: "0.0.12" };
+MultipartUserData.USE_PART_ERROR = "MultipartUserData only supports this operation if it has a default UserData. Call addUserDataPart with makeDefault=true.";
+MultipartUserData.BOUNDRY_PATTERN = "[^a-zA-Z0-9()+,-./:=?]";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-data.js","sourceRoot":"","sources":["../../../src/aws/compute/user-data.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/user-data.ts\n\nimport { dataCloudinitConfig } from \"@cdktf/provider-cloudinit\";\nimport {\n  // TerraformResource\n  IResolvable,\n  Lazy,\n} from \"cdktf\";\n// import { AwsConstructBase } from \"../aws-construct\";\n// import { AwsStack } from \"../aws-stack\";\nimport { IConstruct } from \"constructs\";\n// import { Fn } from \"../../terra-func\";\nimport { IBucket } from \"../storage\";\nimport { OperatingSystemType } from \"./machine-image/common\";\n\n/**\n * Common UserData Options\n */\nexport interface UserDataCommon {\n  /**\n   * Specify whether or not to base64 encode the `rendered` output. Cannot be disabled if gzip is `true`.\n   *\n   * NOTE: Instance and LaunchTemplate expect base64 encoded user data\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/cloudinit/2.3.6/docs/data-sources/config#base64_encode DataCloudinitConfig#base64_encode}\n   * @default true\n   */\n  readonly base64Encode?: boolean | IResolvable;\n  /**\n   * Specify whether or not to gzip the `rendered` output.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/cloudinit/2.3.6/docs/data-sources/config#gzip DataCloudinitConfig#gzip}\n   * @default true\n   */\n  readonly gzip?: boolean | IResolvable;\n  /**\n   * `Content-Type` header of this part.\n   *\n   * Some examples of content types:\n   * * `text/x-shellscript; charset=\"utf-8\"` (shell script)\n   * * `text/cloud-boothook; charset=\"utf-8\"` (shell script executed during boot phase)\n   *\n   * For Linux shell scripts use `text/x-shellscript`.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/cloudinit/2.3.6/docs/data-sources/config#content_type DataCloudinitConfig#content_type}\n   *\n   * @defaults to `text/plain`\n   */\n  readonly contentType?: string;\n  /**\n   * A filename to report in the header for the part.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/cloudinit/2.3.6/docs/data-sources/config#filename DataCloudinitConfig#filename}\n   */\n  readonly filename?: string;\n}\n\n/**\n * Options when constructing UserData for Linux\n */\nexport interface LinuxUserDataOptions extends UserDataCommon {\n  /**\n   * Shebang for the UserData script\n   *\n   * @default \"#!/bin/bash\"\n   */\n  readonly shebang?: string;\n}\n\n/**\n * Options when constructing UserData for Windows\n */\nexport interface WindowsUserDataOptions extends UserDataCommon {\n  /**\n   * Set to true to set this userdata to persist through an instance reboot; allowing\n   * it to run on every instance start.\n   * By default, UserData is run only once during the first instance launch.\n   *\n   * For more information, see:\n   * https://aws.amazon.com/premiumsupport/knowledge-center/execute-user-data-ec2/\n   * https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2-windows-user-data.html#user-data-scripts\n   *\n   * @default false\n   */\n  readonly persist?: boolean;\n}\n\n/**\n * Options when downloading files from S3\n */\nexport interface S3DownloadOptions {\n  /**\n   * Name of the S3 bucket to download from\n   */\n  readonly bucket: IBucket;\n\n  /**\n   * The key of the file to download\n   */\n  readonly bucketKey: string;\n\n  /**\n   * The name of the local file.\n   *\n   * @default Linux   - /tmp/bucketKey\n   *          Windows - %TEMP%/bucketKey\n   */\n  readonly localFile?: string;\n\n  /**\n   * The region of the S3 Bucket (needed for access via VPC Gateway)\n   * @default none\n   */\n  readonly region?: string;\n}\n\n/**\n * Options when executing a file.\n */\nexport interface ExecuteFileOptions {\n  /**\n   * The path to the file.\n   */\n  readonly filePath: string;\n\n  /**\n   * The arguments to be passed to the file.\n   *\n   * @default No arguments are passed to the file.\n   */\n  readonly arguments?: string;\n}\n\n// TODO: Support Content Transfer Encoding\n// https://stackoverflow.com/questions/25710599/content-transfer-encoding-7bit-or-8-bit\n\n/**\n * Instance User Data\n *\n * resource: data_cloudinit_config\n *\n * This is limited to 7bit encoding\n * ref open issue: https://github.com/hashicorp/terraform-provider-cloudinit/pull/170\n */\nexport abstract class UserData {\n  /**\n   * Create a userdata object for Linux hosts\n   */\n  public static forLinux(options: LinuxUserDataOptions = {}): UserData {\n    return new LinuxUserData(options);\n  }\n\n  /**\n   * Create a userdata object for Windows hosts\n   */\n  public static forWindows(options: WindowsUserDataOptions = {}): UserData {\n    return new WindowsUserData(options);\n  }\n\n  /**\n   * Create a userdata object with custom content\n   */\n  public static custom(content: string): UserData {\n    const userData = new CustomUserData();\n    userData.addCommands(content);\n    return userData;\n  }\n\n  public static forOperatingSystem(os: OperatingSystemType): UserData {\n    switch (os) {\n      case OperatingSystemType.LINUX:\n        return UserData.forLinux();\n      case OperatingSystemType.WINDOWS:\n        return UserData.forWindows();\n      case OperatingSystemType.UNKNOWN:\n        throw new Error(\n          \"Cannot determine UserData for unknown operating system type\",\n        );\n    }\n  }\n\n  /** The UserData Content */\n  public abstract readonly content: string;\n  public abstract readonly contentType?: string;\n  public abstract readonly filename?: string;\n\n  protected readonly base64Encode: boolean | IResolvable;\n  protected readonly gzip: boolean | IResolvable;\n\n  constructor(userdataOptions: UserDataCommon = {}) {\n    if (\n      userdataOptions.base64Encode === false &&\n      userdataOptions.gzip === true\n    ) {\n      throw new Error(\"Cannot disable base64 encoding if gzip is enabled\");\n    }\n    this.base64Encode = userdataOptions.base64Encode ?? true;\n    this.gzip = userdataOptions.gzip ?? true;\n  }\n\n  /**\n   * Add one or more commands to the user data\n   */\n  public abstract addCommands(...commands: string[]): void;\n\n  /**\n   * Add one or more commands to the user data that will run when the script exits.\n   */\n  public abstract addOnExitCommands(...commands: string[]): void;\n\n  /**\n   * Render the UserData for use in a construct\n   */\n  public abstract render(scope: IConstruct): string;\n\n  /**\n   * Adds commands to download a file from S3\n   *\n   * @returns: The local path that the file will be downloaded to\n   */\n  public abstract addS3DownloadCommand(params: S3DownloadOptions): string;\n\n  /**\n   * Adds commands to execute a file\n   */\n  public abstract addExecuteFileCommand(params: ExecuteFileOptions): void;\n\n  // /**\n  //  * Adds a command which will send a cfn-signal when the user data script ends\n  //  */\n  // public abstract addSignalOnExitCommand(resource: AwsConstructBase): void;\n}\n\n/**\n * Linux Instance User Data\n */\nclass LinuxUserData extends UserData {\n  private readonly lines: string[] = [];\n  private readonly onExitLines: string[] = [];\n  private readonly shebang: string;\n  public readonly contentType?: string;\n  public readonly filename?: string;\n\n  constructor(props: LinuxUserDataOptions = {}) {\n    super();\n    this.shebang = props.shebang ?? \"#!/bin/bash\";\n    this.contentType = props.contentType;\n    this.filename = props.filename;\n  }\n\n  public addCommands(...commands: string[]) {\n    this.lines.push(...commands);\n  }\n\n  public addOnExitCommands(...commands: string[]) {\n    this.onExitLines.push(...commands);\n  }\n\n  public get content(): string {\n    return [this.shebang, ...this.renderOnExitLines(), ...this.lines].join(\n      \"\\n\",\n    );\n  }\n\n  public render(scope: IConstruct): string {\n    return new dataCloudinitConfig.DataCloudinitConfig(scope, \"UserData\", {\n      base64Encode: this.base64Encode,\n      gzip: this.gzip,\n      // Pass our script as a single part with proper content type.\n      part: [\n        {\n          content: Lazy.stringValue({\n            produce: () => this.content,\n          }),\n          contentType: this.contentType,\n          filename: this.filename,\n        },\n      ],\n    }).rendered;\n  }\n\n  public addS3DownloadCommand(params: S3DownloadOptions): string {\n    const s3Path = `s3://${params.bucket.bucketName}/${params.bucketKey}`;\n    const localPath =\n      params.localFile && params.localFile.length !== 0\n        ? params.localFile\n        : `/tmp/${params.bucketKey}`;\n    this.addCommands(\n      `mkdir -p $(dirname '${localPath}')`,\n      `aws s3 cp '${s3Path}' '${localPath}'` +\n        (params.region !== undefined ? ` --region ${params.region}` : \"\"),\n    );\n\n    return localPath;\n  }\n\n  public addExecuteFileCommand(params: ExecuteFileOptions): void {\n    this.addCommands(\n      \"set -e\",\n      `chmod +x '${params.filePath}'`,\n      `'${params.filePath}' ${params.arguments ?? \"\"}`.trim(),\n    );\n  }\n\n  // // TODO: Add Grid Signals - copy grid-signal binary in provisioner\n  // public addSignalOnExitCommand(resource: AwsConstructBase): void {\n  //   const stack = AwsStack.ofAwsConstruct(resource);\n  //   const resourceID = (resource.node.defaultChild as TerraformResource).fqn;\n  //   this.addOnExitCommands(\n  //     `/opt/aws/bin/grid-signal --stack ${stack.gridUUID} --resource ${resourceID} --region ${stack.region} -e $exitCode || echo 'Failed to send Cloudformation Signal'`,\n  //   );\n  // }\n\n  private renderOnExitLines(): string[] {\n    if (this.onExitLines.length > 0) {\n      return [\n        \"function exitTrap(){\",\n        \"exitCode=$?\",\n        ...this.onExitLines,\n        \"}\",\n        \"trap exitTrap EXIT\",\n      ];\n    }\n    return [];\n  }\n}\n\n/**\n * Windows Instance User Data\n */\nclass WindowsUserData extends UserData {\n  private readonly lines: string[] = [];\n  private readonly onExitLines: string[] = [];\n  public readonly contentType?: string;\n  public readonly filename?: string;\n  private readonly persist: boolean;\n\n  constructor(props: WindowsUserDataOptions = {}) {\n    super();\n    this.persist = props.persist ?? false;\n    this.contentType = props.contentType;\n    this.filename = props.filename;\n  }\n\n  public addCommands(...commands: string[]) {\n    this.lines.push(...commands);\n  }\n\n  public addOnExitCommands(...commands: string[]) {\n    this.onExitLines.push(...commands);\n  }\n\n  public get content(): string {\n    return `<powershell>${[\n      ...this.renderOnExitLines(),\n      ...this.lines,\n      ...(this.onExitLines.length > 0 ? ['throw \"Success\"'] : []),\n    ].join(\n      \"\\n\",\n    )}</powershell>${(this.persist ?? false) ? \"<persist>true</persist>\" : \"\"}`;\n  }\n\n  public render(scope: IConstruct): string {\n    return new dataCloudinitConfig.DataCloudinitConfig(scope, \"UserData\", {\n      base64Encode: this.base64Encode,\n      gzip: this.gzip,\n      // Pass our script as a single part with proper content type.\n      part: [\n        {\n          content: Lazy.stringValue({\n            produce: () => this.content,\n          }),\n          contentType: this.contentType,\n          filename: this.filename,\n        },\n      ],\n    }).rendered;\n  }\n\n  public addS3DownloadCommand(params: S3DownloadOptions): string {\n    const localPath =\n      params.localFile && params.localFile.length !== 0\n        ? params.localFile\n        : `C:/temp/${params.bucketKey}`;\n    this.addCommands(\n      `mkdir (Split-Path -Path '${localPath}' ) -ea 0`,\n      `Read-S3Object -BucketName '${params.bucket.bucketName}' -key '${params.bucketKey}' -file '${localPath}' -ErrorAction Stop` +\n        (params.region !== undefined ? ` -Region ${params.region}` : \"\"),\n    );\n    return localPath;\n  }\n\n  public addExecuteFileCommand(params: ExecuteFileOptions): void {\n    this.addCommands(\n      `&'${params.filePath}' ${params.arguments ?? \"\"}`.trim(),\n      `if (!$?) { Write-Error 'Failed to execute the file \"${params.filePath}\"' -ErrorAction Stop }`,\n    );\n  }\n\n  // // TODO: Add Grid Signals\n  // public addSignalOnExitCommand(resource: AwsConstructBase): void {\n  //   const stack = AwsStack.ofAwsConstruct(resource);\n  //   const resourceID = (resource.node.defaultChild as TerraformResource).fqn;\n\n  //   this.addOnExitCommands(\n  //     `grid-signal --stack ${stack.gridUUID} --resource ${resourceID} --region ${stack.region} --success ($success.ToString().ToLower())`,\n  //   );\n  // }\n\n  private renderOnExitLines(): string[] {\n    if (this.onExitLines.length > 0) {\n      return [\n        \"trap {\",\n        '$success=($PSItem.Exception.Message -eq \"Success\")',\n        ...this.onExitLines,\n        \"break\",\n        \"}\",\n      ];\n    }\n    return [];\n  }\n}\n\n/**\n * Custom Instance User Data\n */\nclass CustomUserData extends UserData {\n  private readonly lines: string[] = [];\n  public readonly contentType?: string;\n  public readonly filename?: string;\n\n  constructor() {\n    super();\n  }\n\n  public addCommands(...commands: string[]) {\n    this.lines.push(...commands);\n  }\n\n  public addOnExitCommands(): void {\n    throw new Error(\n      \"CustomUserData does not support addOnExitCommands, use UserData.forLinux() or UserData.forWindows() instead.\",\n    );\n  }\n\n  public get content(): string {\n    return this.lines.join(\"\\n\");\n  }\n\n  public render(scope: IConstruct): string {\n    return new dataCloudinitConfig.DataCloudinitConfig(scope, \"UserData\", {\n      base64Encode: this.base64Encode,\n      gzip: this.gzip,\n      // Pass our script as a single part with proper content type.\n      part: [\n        {\n          content: Lazy.stringValue({\n            produce: () => this.content,\n          }),\n          contentType: this.contentType,\n          filename: this.filename,\n        },\n      ],\n    }).rendered;\n  }\n\n  public addS3DownloadCommand(): string {\n    throw new Error(\n      \"CustomUserData does not support addS3DownloadCommand, use UserData.forLinux() or UserData.forWindows() instead.\",\n    );\n  }\n\n  public addExecuteFileCommand(): void {\n    throw new Error(\n      \"CustomUserData does not support addExecuteFileCommand, use UserData.forLinux() or UserData.forWindows() instead.\",\n    );\n  }\n\n  public addSignalOnExitCommand(): void {\n    throw new Error(\n      \"CustomUserData does not support addSignalOnExitCommand, use UserData.forLinux() or UserData.forWindows() instead.\",\n    );\n  }\n}\n\n// /**\n//  * Options when creating `MultipartBody`.\n//  */\n// export interface MultipartBodyOptions {\n//   /**\n//    * `Content-Type` header of this part.\n//    *\n//    * Some examples of content types:\n//    * * `text/x-shellscript; charset=\"utf-8\"` (shell script)\n//    * * `text/cloud-boothook; charset=\"utf-8\"` (shell script executed during boot phase)\n//    *\n//    * For Linux shell scripts use `text/x-shellscript`.\n//    */\n//   readonly contentType: string;\n\n//   // terraform provider has this hardcoded\n//   // https://github.com/hashicorp/terraform-provider-cloudinit/blob/v2.3.6/internal/provider/cloudinit_config.go#L180\n\n//   // /**\n//   //  * `Content-Transfer-Encoding` header specifying part encoding.\n//   //  *\n//   //  * @default undefined - body is not encoded\n//   //  */\n//   // readonly transferEncoding?: string;\n\n//   /**\n//    * The body of message.\n//    *\n//    * @default undefined - body will not be added to part\n//    */\n//   readonly body?: string;\n// }\n\n/**\n * The base class for all classes which can be used as `MultipartUserData`.\n */\nexport abstract class MultipartBody {\n  /**\n   * Content type for shell scripts\n   */\n  public static readonly SHELL_SCRIPT = 'text/x-shellscript; charset=\"utf-8\"';\n\n  /**\n   * Content type for boot hooks\n   */\n  public static readonly CLOUD_BOOTHOOK =\n    'text/cloud-boothook; charset=\"utf-8\"';\n\n  /**\n   * Constructs the new `MultipartBody` wrapping existing `UserData`. Modification to `UserData` are reflected\n   * in subsequent renders of the part.\n   *\n   * For more information about content types see `MultipartBodyOptions.contentType`.\n   *\n   * @param userData user data to wrap into body part\n   * @param contentType optional content type, if default one should not be used\n   */\n  public static fromUserData(\n    userData: UserData,\n    contentType?: string,\n  ): MultipartBody {\n    return new MultipartBodyUserDataWrapper(userData, contentType);\n  }\n\n  /**\n  * When transfer encoding is specified (typically as Base64), it's caller responsibility to convert body to\n  * Base64 either by wrapping with `Fn.base64` or by converting it by other converters.\n  *\n  * Note: https://github.com/hashicorp/terraform-provider-cloudinit/pull/170\n  * /\n\n  /**\n   * Constructs the raw `MultipartBody` using specified body, content type, filename and merge type\n   */\n  public static fromRawBody(\n    opts: dataCloudinitConfig.DataCloudinitConfigPart,\n  ): MultipartBody {\n    return new MultipartBodyRaw(opts);\n  }\n\n  public constructor() {}\n\n  /**\n   * Render body part\n   */\n  public abstract renderBodyPart(): dataCloudinitConfig.DataCloudinitConfigPart;\n}\n\n/**\n * The raw part of multi-part user data, which can be added to `MultipartUserData`.\n */\nclass MultipartBodyRaw extends MultipartBody {\n  public constructor(\n    private readonly props: dataCloudinitConfig.DataCloudinitConfigPart,\n  ) {\n    super();\n  }\n\n  /**\n   * Raw return part\n   */\n  public renderBodyPart(): dataCloudinitConfig.DataCloudinitConfigPart {\n    return this.props;\n  }\n}\n\n/**\n * Wrapper for `UserData`.\n */\nclass MultipartBodyUserDataWrapper extends MultipartBody {\n  private readonly contentType: string;\n\n  public constructor(\n    private readonly userData: UserData,\n    contentType?: string,\n  ) {\n    super();\n\n    this.contentType = contentType || MultipartBody.SHELL_SCRIPT;\n  }\n\n  /**\n   * Render body parts\n   */\n  public renderBodyPart(): dataCloudinitConfig.DataCloudinitConfigPart {\n    return {\n      content: this.userData.content,\n      contentType: this.contentType ?? this.userData.contentType,\n      filename: this.userData.filename,\n    };\n  }\n}\n\n/**\n * Options for creating `MultipartUserData`\n */\nexport interface MultipartUserDataOptions extends UserDataCommon {\n  /**\n   * The string used to separate parts in multipart user data archive (it's like MIME boundary).\n   *\n   * This string should contain [a-zA-Z0-9()+,-./:=?] characters only, and should not be present in any part, or in text content of archive.\n   *\n   * @default `+AWS+CDK+User+Data+Separator==`\n   */\n  readonly partsSeparator?: string;\n}\n\n/**\n * Mime multipart user data.\n *\n * This class represents MIME multipart user data, as described in.\n * [Specifying Multiple User Data Blocks Using a MIME Multi Part Archive](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#multi-part_user_data)\n *\n */\nexport class MultipartUserData extends UserData {\n  private static readonly USE_PART_ERROR =\n    \"MultipartUserData only supports this operation if it has a default UserData. Call addUserDataPart with makeDefault=true.\";\n  private static readonly BOUNDRY_PATTERN = \"[^a-zA-Z0-9()+,-./:=?]\";\n\n  private parts: MultipartBody[] = [];\n\n  private opts: MultipartUserDataOptions;\n\n  private defaultUserData?: UserData;\n\n  public readonly contentType?: string;\n\n  public readonly filename?: string;\n\n  constructor(opts?: MultipartUserDataOptions) {\n    super(opts);\n    this.contentType = opts?.contentType;\n    this.filename = opts?.filename;\n\n    let partsSeparator: string;\n\n    // Validate separator\n    if (opts?.partsSeparator != null) {\n      if (\n        new RegExp(MultipartUserData.BOUNDRY_PATTERN).test(opts!.partsSeparator)\n      ) {\n        throw new Error(\n          `Invalid characters in separator. Separator has to match pattern ${MultipartUserData.BOUNDRY_PATTERN}`,\n        );\n      } else {\n        partsSeparator = opts!.partsSeparator;\n      }\n    } else {\n      partsSeparator = \"+AWS+CDK+User+Data+Separator==\";\n    }\n\n    this.opts = {\n      partsSeparator: partsSeparator,\n    };\n  }\n\n  /**\n   * Adds a part to the list of parts.\n   */\n  public addPart(part: MultipartBody) {\n    this.parts.push(part);\n  }\n\n  /**\n   * Adds a multipart part based on a UserData object.\n   *\n   * If `makeDefault` is true, then the UserData added by this method\n   * will also be the target of calls to the `add*Command` methods on\n   * this MultipartUserData object.\n   *\n   * If `makeDefault` is false, then this is the same as calling:\n   *\n   * ```ts\n   * declare const multiPart: compute.MultipartUserData;\n   * declare const userData: compute.UserData;\n   * declare const contentType: string;\n   *\n   * multiPart.addPart(compute.MultipartBody.fromUserData(userData, contentType));\n   * ```\n   *\n   * An undefined `makeDefault` defaults to either:\n   * - `true` if no default UserData has been set yet; or\n   * - `false` if there is no default UserData set.\n   */\n  public addUserDataPart(\n    userData: UserData,\n    contentType?: string,\n    makeDefault?: boolean,\n  ) {\n    this.addPart(MultipartBody.fromUserData(userData, contentType));\n    makeDefault =\n      makeDefault ?? (this.defaultUserData === undefined ? true : false);\n    if (makeDefault) {\n      this.defaultUserData = userData;\n    }\n  }\n\n  /**\n   * The content of the default UserData.\n   */\n  public get content(): string {\n    if (this.defaultUserData) {\n      return this.defaultUserData.content;\n    } else {\n      throw new Error(MultipartUserData.USE_PART_ERROR);\n    }\n  }\n\n  public render(scope: IConstruct): string {\n    return new dataCloudinitConfig.DataCloudinitConfig(scope, \"UserData\", {\n      boundary: this.opts.partsSeparator,\n      base64Encode: this.base64Encode,\n      gzip: this.gzip,\n      part: Lazy.anyValue({\n        produce: () => this.parts.map((p) => p.renderBodyPart()),\n      }),\n    }).rendered;\n  }\n\n  public addS3DownloadCommand(params: S3DownloadOptions): string {\n    if (this.defaultUserData) {\n      return this.defaultUserData.addS3DownloadCommand(params);\n    } else {\n      throw new Error(MultipartUserData.USE_PART_ERROR);\n    }\n  }\n\n  public addExecuteFileCommand(params: ExecuteFileOptions): void {\n    if (this.defaultUserData) {\n      this.defaultUserData.addExecuteFileCommand(params);\n    } else {\n      throw new Error(MultipartUserData.USE_PART_ERROR);\n    }\n  }\n\n  // // TODO: Add Grid Signals\n  // public addSignalOnExitCommand(resource: AwsConstructBase): void {\n  //   if (this.defaultUserData) {\n  //     this.defaultUserData.addSignalOnExitCommand(resource);\n  //   } else {\n  //     throw new Error(MultipartUserData.USE_PART_ERROR);\n  //   }\n  // }\n\n  public addCommands(...commands: string[]): void {\n    if (this.defaultUserData) {\n      this.defaultUserData.addCommands(...commands);\n    } else {\n      throw new Error(MultipartUserData.USE_PART_ERROR);\n    }\n  }\n\n  public addOnExitCommands(...commands: string[]): void {\n    if (this.defaultUserData) {\n      this.defaultUserData.addOnExitCommands(...commands);\n    } else {\n      throw new Error(MultipartUserData.USE_PART_ERROR);\n    }\n  }\n}\n"]}

package/lib/aws/compute/util.d.ts

@@ -9,4 +9,4 @@ export declare function flatMap<T, U>(xs: T[], fn: (x: T, i: number) => U[]): U[
 /**
  * Flatten a list of lists into a list of elements
  */
-export declare function flatten<T>(xs: T[][]): T[];
+export declare function flatten<A>(xs: A[][]): A[];

package/lib/aws/compute/util.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flatten = exports.flatMap = exports.addAlias = void 0;
+exports.addAlias = addAlias;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
 const function_alias_1 = require("./function-alias");
 // import { IVersion } from "./function-version";
 function addAlias(scope, lambda, version, aliasName, options = {}) {
@@ -11,19 +13,16 @@ function addAlias(scope, lambda, version, aliasName, options = {}) {
         ...options,
     });
 }
-exports.addAlias = addAlias;
 /**
  * Map a function over an array and concatenate the results
  */
 function flatMap(xs, fn) {
     return flatten(xs.map(fn));
 }
-exports.flatMap = flatMap;
 /**
  * Flatten a list of lists into a list of elements
  */
 function flatten(xs) {
     return Array.prototype.concat.apply([], xs);
 }
-exports.flatten = flatten;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hd3MvY29tcHV0ZS91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLHFEQUF1RDtBQUV2RCxpREFBaUQ7QUFFakQsU0FBZ0IsUUFBUSxDQUN0QixLQUFnQixFQUNoQixNQUFpQixFQUNqQixPQUFlLEVBQ2YsU0FBaUIsRUFDakIsVUFBd0IsRUFBRTtJQUUxQixPQUFPLElBQUksc0JBQUssQ0FBQyxLQUFLLEVBQUUsUUFBUSxTQUFTLEVBQUUsRUFBRTtRQUMzQyxTQUFTO1FBQ1QsT0FBTztRQUNQLFFBQVEsRUFBRSxNQUFNO1FBQ2hCLEdBQUcsT0FBTztLQUNYLENBQUMsQ0FBQztBQUNMLENBQUM7QUFiRCw0QkFhQztBQUVEOztHQUVHO0FBQ0gsU0FBZ0IsT0FBTyxDQUFPLEVBQU8sRUFBRSxFQUE0QjtJQUNqRSxPQUFPLE9BQU8sQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFDN0IsQ0FBQztBQUZELDBCQUVDO0FBRUQ7O0dBRUc7QUFDSCxTQUFnQixPQUFPLENBQUksRUFBUztJQUNsQyxPQUFPLEtBQUssQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDOUMsQ0FBQztBQUZELDBCQUVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29uc3RydWN0IH0gZnJvbSBcImNvbnN0cnVjdHNcIjtcbmltcG9ydCB7IEFsaWFzLCBBbGlhc09wdGlvbnMgfSBmcm9tIFwiLi9mdW5jdGlvbi1hbGlhc1wiO1xuaW1wb3J0IHsgSUZ1bmN0aW9uIH0gZnJvbSBcIi4vZnVuY3Rpb24tYmFzZVwiO1xuLy8gaW1wb3J0IHsgSVZlcnNpb24gfSBmcm9tIFwiLi9mdW5jdGlvbi12ZXJzaW9uXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBhZGRBbGlhcyhcbiAgc2NvcGU6IENvbnN0cnVjdCxcbiAgbGFtYmRhOiBJRnVuY3Rpb24sXG4gIHZlcnNpb246IHN0cmluZyxcbiAgYWxpYXNOYW1lOiBzdHJpbmcsXG4gIG9wdGlvbnM6IEFsaWFzT3B0aW9ucyA9IHt9LFxuKSB7XG4gIHJldHVybiBuZXcgQWxpYXMoc2NvcGUsIGBBbGlhcyR7YWxpYXNOYW1lfWAsIHtcbiAgICBhbGlhc05hbWUsXG4gICAgdmVyc2lvbixcbiAgICBmdW5jdGlvbjogbGFtYmRhLFxuICAgIC4uLm9wdGlvbnMsXG4gIH0pO1xufVxuXG4vKipcbiAqIE1hcCBhIGZ1bmN0aW9uIG92ZXIgYW4gYXJyYXkgYW5kIGNvbmNhdGVuYXRlIHRoZSByZXN1bHRzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBmbGF0TWFwPFQsIFU+KHhzOiBUW10sIGZuOiAoeDogVCwgaTogbnVtYmVyKSA9PiBVW10pOiBVW10ge1xuICByZXR1cm4gZmxhdHRlbih4cy5tYXAoZm4pKTtcbn1cblxuLyoqXG4gKiBGbGF0dGVuIGEgbGlzdCBvZiBsaXN0cyBpbnRvIGEgbGlzdCBvZiBlbGVtZW50c1xuICovXG5leHBvcnQgZnVuY3Rpb24gZmxhdHRlbjxUPih4czogVFtdW10pOiBUW10ge1xuICByZXR1cm4gQXJyYXkucHJvdG90eXBlLmNvbmNhdC5hcHBseShbXSwgeHMpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hd3MvY29tcHV0ZS91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBS0EsNEJBYUM7QUFLRCwwQkFFQztBQUtELDBCQUVDO0FBL0JELHFEQUF1RDtBQUV2RCxpREFBaUQ7QUFFakQsU0FBZ0IsUUFBUSxDQUN0QixLQUFnQixFQUNoQixNQUFpQixFQUNqQixPQUFlLEVBQ2YsU0FBaUIsRUFDakIsVUFBd0IsRUFBRTtJQUUxQixPQUFPLElBQUksc0JBQUssQ0FBQyxLQUFLLEVBQUUsUUFBUSxTQUFTLEVBQUUsRUFBRTtRQUMzQyxTQUFTO1FBQ1QsT0FBTztRQUNQLFFBQVEsRUFBRSxNQUFNO1FBQ2hCLEdBQUcsT0FBTztLQUNYLENBQUMsQ0FBQztBQUNMLENBQUM7QUFFRDs7R0FFRztBQUNILFNBQWdCLE9BQU8sQ0FBTyxFQUFPLEVBQUUsRUFBNEI7SUFDakUsT0FBTyxPQUFPLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQzdCLENBQUM7QUFFRDs7R0FFRztBQUNILFNBQWdCLE9BQU8sQ0FBSSxFQUFTO0lBQ2xDLE9BQU8sS0FBSyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQztBQUM5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29uc3RydWN0IH0gZnJvbSBcImNvbnN0cnVjdHNcIjtcbmltcG9ydCB7IEFsaWFzLCBBbGlhc09wdGlvbnMgfSBmcm9tIFwiLi9mdW5jdGlvbi1hbGlhc1wiO1xuaW1wb3J0IHsgSUZ1bmN0aW9uIH0gZnJvbSBcIi4vZnVuY3Rpb24tYmFzZVwiO1xuLy8gaW1wb3J0IHsgSVZlcnNpb24gfSBmcm9tIFwiLi9mdW5jdGlvbi12ZXJzaW9uXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBhZGRBbGlhcyhcbiAgc2NvcGU6IENvbnN0cnVjdCxcbiAgbGFtYmRhOiBJRnVuY3Rpb24sXG4gIHZlcnNpb246IHN0cmluZyxcbiAgYWxpYXNOYW1lOiBzdHJpbmcsXG4gIG9wdGlvbnM6IEFsaWFzT3B0aW9ucyA9IHt9LFxuKSB7XG4gIHJldHVybiBuZXcgQWxpYXMoc2NvcGUsIGBBbGlhcyR7YWxpYXNOYW1lfWAsIHtcbiAgICBhbGlhc05hbWUsXG4gICAgdmVyc2lvbixcbiAgICBmdW5jdGlvbjogbGFtYmRhLFxuICAgIC4uLm9wdGlvbnMsXG4gIH0pO1xufVxuXG4vKipcbiAqIE1hcCBhIGZ1bmN0aW9uIG92ZXIgYW4gYXJyYXkgYW5kIGNvbmNhdGVuYXRlIHRoZSByZXN1bHRzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBmbGF0TWFwPFQsIFU+KHhzOiBUW10sIGZuOiAoeDogVCwgaTogbnVtYmVyKSA9PiBVW10pOiBVW10ge1xuICByZXR1cm4gZmxhdHRlbih4cy5tYXAoZm4pKTtcbn1cblxuLyoqXG4gKiBGbGF0dGVuIGEgbGlzdCBvZiBsaXN0cyBpbnRvIGEgbGlzdCBvZiBlbGVtZW50c1xuICovXG5leHBvcnQgZnVuY3Rpb24gZmxhdHRlbjxBPih4czogQVtdW10pOiBBW10ge1xuICByZXR1cm4gQXJyYXkucHJvdG90eXBlLmNvbmNhdC5hcHBseShbXSwgeHMpO1xufVxuIl19