aws-cdk 0.0.0

package/lib/api/util/rwlock.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RWLock = void 0;
+const fs_1 = require("fs");
+const path = require("path");
+const error_1 = require("../../toolkit/error");
+/**
+ * A single-writer/multi-reader lock on a directory
+ *
+ * It uses marker files with PIDs in them as a locking marker; the PIDs will be
+ * checked for liveness, so that if the process exits without cleaning up the
+ * files the lock is implicitly released.
+ *
+ * This class is not 100% race safe, but in practice it should be a lot
+ * better than the 0 protection we have today.
+ */
+/* istanbul ignore next: code paths are unpredictable */
+class RWLock {
+    constructor(directory) {
+        this.directory = directory;
+        this.readCounter = 0;
+        this.pidString = `${process.pid}`;
+        this.writerFile = path.join(this.directory, 'synth.lock');
+    }
+    /**
+     * Acquire a writer lock.
+     *
+     * No other readers or writers must exist for the given directory.
+     */
+    async acquireWrite() {
+        await this.assertNoOtherWriters();
+        const readers = await this.currentReaders();
+        if (readers.length > 0) {
+            throw new error_1.ToolkitError(`Other CLIs (PID=${readers}) are currently reading from ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
+        }
+        await writeFileAtomic(this.writerFile, this.pidString);
+        return {
+            release: async () => {
+                await deleteFile(this.writerFile);
+            },
+            convertToReaderLock: async () => {
+                // Acquire the read lock before releasing the write lock. Slightly less
+                // chance of racing!
+                const ret = await this.doAcquireRead();
+                await deleteFile(this.writerFile);
+                return ret;
+            },
+        };
+    }
+    /**
+     * Acquire a read lock
+     *
+     * Will fail if there are any writers.
+     */
+    async acquireRead() {
+        await this.assertNoOtherWriters();
+        return this.doAcquireRead();
+    }
+    /**
+     * Obtains the name fo a (new) `readerFile` to use. This includes a counter so
+     * that if multiple threads of the same PID attempt to concurrently acquire
+     * the same lock, they're guaranteed to use a different reader file name (only
+     * one thread will ever execute JS code at once, guaranteeing the readCounter
+     * is incremented "atomically" from the point of view of this PID.).
+     */
+    readerFile() {
+        return path.join(this.directory, `read.${this.pidString}.${++this.readCounter}.lock`);
+    }
+    /**
+     * Do the actual acquiring of a read lock.
+     */
+    async doAcquireRead() {
+        const readerFile = this.readerFile();
+        await writeFileAtomic(readerFile, this.pidString);
+        return {
+            release: async () => {
+                await deleteFile(readerFile);
+            },
+        };
+    }
+    async assertNoOtherWriters() {
+        const writer = await this.currentWriter();
+        if (writer) {
+            throw new error_1.ToolkitError(`Another CLI (PID=${writer}) is currently synthing to ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
+        }
+    }
+    /**
+     * Check the current writer (if any)
+     */
+    async currentWriter() {
+        const contents = await readFileIfExists(this.writerFile);
+        if (!contents) {
+            return undefined;
+        }
+        const pid = parseInt(contents, 10);
+        if (!processExists(pid)) {
+            // Do cleanup of a stray file now
+            await deleteFile(this.writerFile);
+            return undefined;
+        }
+        return pid;
+    }
+    /**
+     * Check the current readers (if any)
+     */
+    async currentReaders() {
+        const re = /^read\.([^.]+)\.[^.]+\.lock$/;
+        const ret = new Array();
+        let children;
+        try {
+            children = await fs_1.promises.readdir(this.directory, { encoding: 'utf-8' });
+        }
+        catch (e) {
+            // Can't be locked if the directory doesn't exist
+            if (e.code === 'ENOENT') {
+                return [];
+            }
+            throw e;
+        }
+        for (const fname of children) {
+            const m = fname.match(re);
+            if (m) {
+                const pid = parseInt(m[1], 10);
+                if (processExists(pid)) {
+                    ret.push(pid);
+                }
+                else {
+                    // Do cleanup of a stray file now
+                    await deleteFile(path.join(this.directory, fname));
+                }
+            }
+        }
+        return ret;
+    }
+}
+exports.RWLock = RWLock;
+/* istanbul ignore next: code paths are unpredictable */
+async function readFileIfExists(filename) {
+    try {
+        return await fs_1.promises.readFile(filename, { encoding: 'utf-8' });
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return undefined;
+        }
+        throw e;
+    }
+}
+let tmpCounter = 0;
+/* istanbul ignore next: code paths are unpredictable */
+async function writeFileAtomic(filename, contents) {
+    await fs_1.promises.mkdir(path.dirname(filename), { recursive: true });
+    const tmpFile = `${filename}.${process.pid}_${++tmpCounter}`;
+    await fs_1.promises.writeFile(tmpFile, contents, { encoding: 'utf-8' });
+    await fs_1.promises.rename(tmpFile, filename);
+}
+/* istanbul ignore next: code paths are unpredictable */
+async function deleteFile(filename) {
+    try {
+        await fs_1.promises.unlink(filename);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return;
+        }
+        throw e;
+    }
+}
+/* istanbul ignore next: code paths are unpredictable */
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rwlock.js","sourceRoot":"","sources":["rwlock.ts"],"names":[],"mappings":"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","sourcesContent":["import { promises as fs } from 'fs';\nimport * as path from 'path';\nimport { ToolkitError } from '../../toolkit/error';\n\n/**\n * A single-writer/multi-reader lock on a directory\n *\n * It uses marker files with PIDs in them as a locking marker; the PIDs will be\n * checked for liveness, so that if the process exits without cleaning up the\n * files the lock is implicitly released.\n *\n * This class is not 100% race safe, but in practice it should be a lot\n * better than the 0 protection we have today.\n */\n/* istanbul ignore next: code paths are unpredictable */\nexport class RWLock {\n  private readonly pidString: string;\n  private readonly writerFile: string;\n  private readCounter = 0;\n\n  constructor(public readonly directory: string) {\n    this.pidString = `${process.pid}`;\n\n    this.writerFile = path.join(this.directory, 'synth.lock');\n  }\n\n  /**\n   * Acquire a writer lock.\n   *\n   * No other readers or writers must exist for the given directory.\n   */\n  public async acquireWrite(): Promise<IWriterLock> {\n    await this.assertNoOtherWriters();\n\n    const readers = await this.currentReaders();\n    if (readers.length > 0) {\n      throw new ToolkitError(`Other CLIs (PID=${readers}) are currently reading from ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);\n    }\n\n    await writeFileAtomic(this.writerFile, this.pidString);\n\n    return {\n      release: async () => {\n        await deleteFile(this.writerFile);\n      },\n      convertToReaderLock: async () => {\n        // Acquire the read lock before releasing the write lock. Slightly less\n        // chance of racing!\n        const ret = await this.doAcquireRead();\n        await deleteFile(this.writerFile);\n        return ret;\n      },\n    };\n  }\n\n  /**\n   * Acquire a read lock\n   *\n   * Will fail if there are any writers.\n   */\n  public async acquireRead(): Promise<ILock> {\n    await this.assertNoOtherWriters();\n    return this.doAcquireRead();\n  }\n\n  /**\n   * Obtains the name fo a (new) `readerFile` to use. This includes a counter so\n   * that if multiple threads of the same PID attempt to concurrently acquire\n   * the same lock, they're guaranteed to use a different reader file name (only\n   * one thread will ever execute JS code at once, guaranteeing the readCounter\n   * is incremented \"atomically\" from the point of view of this PID.).\n   */\n  private readerFile(): string {\n    return path.join(this.directory, `read.${this.pidString}.${++this.readCounter}.lock`);\n  }\n\n  /**\n   * Do the actual acquiring of a read lock.\n   */\n  private async doAcquireRead(): Promise<ILock> {\n    const readerFile = this.readerFile();\n    await writeFileAtomic(readerFile, this.pidString);\n    return {\n      release: async () => {\n        await deleteFile(readerFile);\n      },\n    };\n  }\n\n  private async assertNoOtherWriters() {\n    const writer = await this.currentWriter();\n    if (writer) {\n      throw new ToolkitError(`Another CLI (PID=${writer}) is currently synthing to ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);\n    }\n  }\n\n  /**\n   * Check the current writer (if any)\n   */\n  private async currentWriter(): Promise<number | undefined> {\n    const contents = await readFileIfExists(this.writerFile);\n    if (!contents) { return undefined; }\n\n    const pid = parseInt(contents, 10);\n    if (!processExists(pid)) {\n      // Do cleanup of a stray file now\n      await deleteFile(this.writerFile);\n      return undefined;\n    }\n\n    return pid;\n  }\n\n  /**\n   * Check the current readers (if any)\n   */\n  private async currentReaders(): Promise<number[]> {\n    const re = /^read\\.([^.]+)\\.[^.]+\\.lock$/;\n    const ret = new Array<number>();\n\n    let children;\n    try {\n      children = await fs.readdir(this.directory, { encoding: 'utf-8' });\n    } catch (e: any) {\n      // Can't be locked if the directory doesn't exist\n      if (e.code === 'ENOENT') { return []; }\n      throw e;\n    }\n\n    for (const fname of children) {\n      const m = fname.match(re);\n      if (m) {\n        const pid = parseInt(m[1], 10);\n        if (processExists(pid)) {\n          ret.push(pid);\n        } else {\n          // Do cleanup of a stray file now\n          await deleteFile(path.join(this.directory, fname));\n        }\n      }\n    }\n    return ret;\n  }\n}\n\n/**\n * An acquired lock\n */\nexport interface ILock {\n  release(): Promise<void>;\n}\n\n/**\n * An acquired writer lock\n */\nexport interface IWriterLock extends ILock {\n  /**\n   * Convert the writer lock to a reader lock\n   */\n  convertToReaderLock(): Promise<ILock>;\n}\n\n/* istanbul ignore next: code paths are unpredictable */\nasync function readFileIfExists(filename: string): Promise<string | undefined> {\n  try {\n    return await fs.readFile(filename, { encoding: 'utf-8' });\n  } catch (e: any) {\n    if (e.code === 'ENOENT') { return undefined; }\n    throw e;\n  }\n}\n\nlet tmpCounter = 0;\n/* istanbul ignore next: code paths are unpredictable */\nasync function writeFileAtomic(filename: string, contents: string): Promise<void> {\n  await fs.mkdir(path.dirname(filename), { recursive: true });\n  const tmpFile = `${filename}.${process.pid}_${++tmpCounter}`;\n  await fs.writeFile(tmpFile, contents, { encoding: 'utf-8' });\n  await fs.rename(tmpFile, filename);\n}\n\n/* istanbul ignore next: code paths are unpredictable */\nasync function deleteFile(filename: string) {\n  try {\n    await fs.unlink(filename);\n  } catch (e: any) {\n    if (e.code === 'ENOENT') {\n      return;\n    }\n    throw e;\n  }\n}\n\n/* istanbul ignore next: code paths are unpredictable */\nfunction processExists(pid: number) {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n"]}

package/lib/api/util/string-manipulation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pad 's' on the left with 'char' until it is n characters wide
+ */
+export declare function leftPad(s: string, n: number, char: string): string;
+/**
+ * Formats time in milliseconds (which we get from 'Date.getTime()')
+ * to a human-readable time; returns time in seconds rounded to 2
+ * decimal places.
+ */
+export declare function formatTime(num: number): number;

package/lib/api/util/string-manipulation.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leftPad = leftPad;
+exports.formatTime = formatTime;
+/**
+ * Pad 's' on the left with 'char' until it is n characters wide
+ */
+function leftPad(s, n, char) {
+    const padding = Math.max(0, n - s.length);
+    return char.repeat(padding) + s;
+}
+/**
+ * Formats time in milliseconds (which we get from 'Date.getTime()')
+ * to a human-readable time; returns time in seconds rounded to 2
+ * decimal places.
+ */
+function formatTime(num) {
+    return roundPercentage(millisecondsToSeconds(num));
+}
+/**
+ * Rounds a decimal number to two decimal points.
+ * The function is useful for fractions that need to be outputted as percentages.
+ */
+function roundPercentage(num) {
+    return Math.round(100 * num) / 100;
+}
+/**
+ * Given a time in milliseconds, return an equivalent amount in seconds.
+ */
+function millisecondsToSeconds(num) {
+    return num / 1000;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/util/template-body-parameter.d.ts

@@ -0,0 +1,21 @@
+import { type CloudFormationStackArtifact, type Environment } from '@aws-cdk/cx-api';
+import { type AssetManifestBuilder } from '../deployments';
+import { EnvironmentResources } from '../environment-resources';
+export type TemplateBodyParameter = {
+    TemplateBody?: string;
+    TemplateURL?: string;
+};
+/**
+ * Prepares the body parameter for +CreateChangeSet+.
+ *
+ * If the template is small enough to be inlined into the API call, just return
+ * it immediately.
+ *
+ * Otherwise, add it to the asset manifest to get uploaded to the staging
+ * bucket and return its coordinates. If there is no staging bucket, an error
+ * is thrown.
+ *
+ * @param stack     the synthesized stack that provides the CloudFormation template
+ * @param toolkitInfo information about the toolkit stack
+ */
+export declare function makeBodyParameter(stack: CloudFormationStackArtifact, resolvedEnvironment: Environment, assetManifest: AssetManifestBuilder, resources: EnvironmentResources, overrideTemplate?: any): Promise<TemplateBodyParameter>;

package/lib/api/util/template-body-parameter.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBodyParameter = makeBodyParameter;
+const path = require("path");
+const cx_api_1 = require("@aws-cdk/cx-api");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const logging_1 = require("../../logging");
+const serialize_1 = require("../../serialize");
+const error_1 = require("../../toolkit/error");
+const content_hash_1 = require("../../util/content-hash");
+const LARGE_TEMPLATE_SIZE_KB = 50;
+/**
+ * Prepares the body parameter for +CreateChangeSet+.
+ *
+ * If the template is small enough to be inlined into the API call, just return
+ * it immediately.
+ *
+ * Otherwise, add it to the asset manifest to get uploaded to the staging
+ * bucket and return its coordinates. If there is no staging bucket, an error
+ * is thrown.
+ *
+ * @param stack     the synthesized stack that provides the CloudFormation template
+ * @param toolkitInfo information about the toolkit stack
+ */
+async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, resources, overrideTemplate) {
+    // If the template has already been uploaded to S3, just use it from there.
+    if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {
+        return {
+            TemplateURL: await restUrlFromManifest(stack.stackTemplateAssetObjectUrl, resolvedEnvironment),
+        };
+    }
+    // Otherwise, pass via API call (if small) or upload here (if large)
+    const templateJson = (0, serialize_1.toYAML)(overrideTemplate !== null && overrideTemplate !== void 0 ? overrideTemplate : stack.template);
+    if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {
+        return { TemplateBody: templateJson };
+    }
+    const toolkitInfo = await resources.lookupToolkit();
+    if (!toolkitInfo.found) {
+        (0, logging_1.error)(`The template for stack "${stack.displayName}" is ${Math.round(templateJson.length / 1024)}KiB. ` +
+            `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\n` +
+            'Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\n\n', chalk.blue(`\t$ cdk bootstrap ${resolvedEnvironment.name}\n`));
+        throw new error_1.ToolkitError('Template too large to deploy ("cdk bootstrap" is required)');
+    }
+    const templateHash = (0, content_hash_1.contentHash)(templateJson);
+    const key = `cdk/${stack.id}/${templateHash}.yml`;
+    let templateFile = stack.templateFile;
+    if (overrideTemplate) {
+        // Add a variant of this template
+        templateFile = `${stack.templateFile}-${templateHash}.yaml`;
+        const templateFilePath = path.join(stack.assembly.directory, templateFile);
+        await fs.writeFile(templateFilePath, templateJson, { encoding: 'utf-8' });
+    }
+    assetManifest.addFileAsset(templateHash, {
+        path: templateFile,
+    }, {
+        bucketName: toolkitInfo.bucketName,
+        objectKey: key,
+    });
+    const templateURL = `${toolkitInfo.bucketUrl}/${key}`;
+    (0, logging_1.debug)('Storing template in S3 at:', templateURL);
+    return { TemplateURL: templateURL };
+}
+/**
+ * Format an S3 URL in the manifest for use with CloudFormation
+ *
+ * Replaces environment placeholders (which this field may contain),
+ * and reformats s3://.../... urls into S3 REST URLs (which CloudFormation
+ * expects)
+ */
+async function restUrlFromManifest(url, environment) {
+    const doNotUseMarker = '**DONOTUSE**';
+    const region = environment.region;
+    // This URL may contain placeholders, so still substitute those.
+    url = cx_api_1.EnvironmentPlaceholders.replace(url, {
+        accountId: environment.account,
+        region,
+        partition: doNotUseMarker,
+    });
+    // Yes, this is extremely crude, but we don't actually need this so I'm not inclined to spend
+    // a lot of effort trying to thread the right value to this location.
+    if (url.indexOf(doNotUseMarker) > -1) {
+        throw new error_1.ToolkitError("Cannot use '${AWS::Partition}' in the 'stackTemplateAssetObjectUrl' field");
+    }
+    const s3Url = url.match(/s3:\/\/([^/]+)\/(.*)$/);
+    if (!s3Url) {
+        return url;
+    }
+    // We need to pass an 'https://s3.REGION.amazonaws.com[.cn]/bucket/object' URL to CloudFormation, but we
+    // got an 's3://bucket/object' URL instead. Construct the rest API URL here.
+    const bucketName = s3Url[1];
+    const objectKey = s3Url[2];
+    // SDK v3 no longer allows for getting endpoints from only region.
+    // A command and client config must now be provided.
+    const s3 = new client_s3_1.S3Client({ region });
+    const endpoint = await (0, middleware_endpoint_1.getEndpointFromInstructions)({}, client_s3_1.HeadObjectCommand, {
+        ...s3.config,
+    });
+    endpoint.url.hostname;
+    return `${endpoint.url.origin}/${bucketName}/${objectKey}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template-body-parameter.js","sourceRoot":"","sources":["template-body-parameter.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { type CloudFormationStackArtifact, type Environment, EnvironmentPlaceholders } from '@aws-cdk/cx-api';\nimport { HeadObjectCommand, S3Client } from '@aws-sdk/client-s3';\nimport { getEndpointFromInstructions } from '@smithy/middleware-endpoint';\nimport * as chalk from 'chalk';\nimport * as fs from 'fs-extra';\nimport { debug, error } from '../../logging';\nimport { toYAML } from '../../serialize';\nimport { ToolkitError } from '../../toolkit/error';\nimport { contentHash } from '../../util/content-hash';\nimport { type AssetManifestBuilder } from '../deployments';\nimport { EnvironmentResources } from '../environment-resources';\n\nexport type TemplateBodyParameter = {\n  TemplateBody?: string;\n  TemplateURL?: string;\n};\n\nconst LARGE_TEMPLATE_SIZE_KB = 50;\n\n/**\n * Prepares the body parameter for +CreateChangeSet+.\n *\n * If the template is small enough to be inlined into the API call, just return\n * it immediately.\n *\n * Otherwise, add it to the asset manifest to get uploaded to the staging\n * bucket and return its coordinates. If there is no staging bucket, an error\n * is thrown.\n *\n * @param stack     the synthesized stack that provides the CloudFormation template\n * @param toolkitInfo information about the toolkit stack\n */\nexport async function makeBodyParameter(\n  stack: CloudFormationStackArtifact,\n  resolvedEnvironment: Environment,\n  assetManifest: AssetManifestBuilder,\n  resources: EnvironmentResources,\n  overrideTemplate?: any,\n): Promise<TemplateBodyParameter> {\n  // If the template has already been uploaded to S3, just use it from there.\n  if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {\n    return {\n      TemplateURL: await restUrlFromManifest(stack.stackTemplateAssetObjectUrl, resolvedEnvironment),\n    };\n  }\n\n  // Otherwise, pass via API call (if small) or upload here (if large)\n  const templateJson = toYAML(overrideTemplate ?? stack.template);\n\n  if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {\n    return { TemplateBody: templateJson };\n  }\n\n  const toolkitInfo = await resources.lookupToolkit();\n  if (!toolkitInfo.found) {\n    error(\n      `The template for stack \"${stack.displayName}\" is ${Math.round(templateJson.length / 1024)}KiB. ` +\n        `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\\n` +\n        'Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\\n\\n',\n      chalk.blue(`\\t$ cdk bootstrap ${resolvedEnvironment.name}\\n`),\n    );\n\n    throw new ToolkitError('Template too large to deploy (\"cdk bootstrap\" is required)');\n  }\n\n  const templateHash = contentHash(templateJson);\n  const key = `cdk/${stack.id}/${templateHash}.yml`;\n\n  let templateFile = stack.templateFile;\n  if (overrideTemplate) {\n    // Add a variant of this template\n    templateFile = `${stack.templateFile}-${templateHash}.yaml`;\n    const templateFilePath = path.join(stack.assembly.directory, templateFile);\n    await fs.writeFile(templateFilePath, templateJson, { encoding: 'utf-8' });\n  }\n\n  assetManifest.addFileAsset(\n    templateHash,\n    {\n      path: templateFile,\n    },\n    {\n      bucketName: toolkitInfo.bucketName,\n      objectKey: key,\n    },\n  );\n\n  const templateURL = `${toolkitInfo.bucketUrl}/${key}`;\n  debug('Storing template in S3 at:', templateURL);\n  return { TemplateURL: templateURL };\n}\n\n/**\n * Format an S3 URL in the manifest for use with CloudFormation\n *\n * Replaces environment placeholders (which this field may contain),\n * and reformats s3://.../... urls into S3 REST URLs (which CloudFormation\n * expects)\n */\nasync function restUrlFromManifest(url: string, environment: Environment): Promise<string> {\n  const doNotUseMarker = '**DONOTUSE**';\n  const region = environment.region;\n  // This URL may contain placeholders, so still substitute those.\n  url = EnvironmentPlaceholders.replace(url, {\n    accountId: environment.account,\n    region,\n    partition: doNotUseMarker,\n  });\n\n  // Yes, this is extremely crude, but we don't actually need this so I'm not inclined to spend\n  // a lot of effort trying to thread the right value to this location.\n  if (url.indexOf(doNotUseMarker) > -1) {\n    throw new ToolkitError(\"Cannot use '${AWS::Partition}' in the 'stackTemplateAssetObjectUrl' field\");\n  }\n\n  const s3Url = url.match(/s3:\\/\\/([^/]+)\\/(.*)$/);\n  if (!s3Url) {\n    return url;\n  }\n\n  // We need to pass an 'https://s3.REGION.amazonaws.com[.cn]/bucket/object' URL to CloudFormation, but we\n  // got an 's3://bucket/object' URL instead. Construct the rest API URL here.\n  const bucketName = s3Url[1];\n  const objectKey = s3Url[2];\n\n  // SDK v3 no longer allows for getting endpoints from only region.\n  // A command and client config must now be provided.\n  const s3 = new S3Client({ region });\n  const endpoint = await getEndpointFromInstructions({}, HeadObjectCommand, {\n    ...s3.config,\n  });\n  endpoint.url.hostname;\n\n  return `${endpoint.url.origin}/${bucketName}/${objectKey}`;\n}\n"]}