cdk-assets 0.0.0

package/lib/private/docker.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerFactory = exports.Docker = void 0;
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const docker_credentials_1 = require("./docker-credentials");
+const shell_1 = require("./shell");
+const util_1 = require("./util");
+const progress_1 = require("../progress");
+var InspectImageErrorCode;
+(function (InspectImageErrorCode) {
+    InspectImageErrorCode[InspectImageErrorCode["Docker"] = 1] = "Docker";
+    InspectImageErrorCode[InspectImageErrorCode["Podman"] = 125] = "Podman";
+})(InspectImageErrorCode || (InspectImageErrorCode = {}));
+class Docker {
+    constructor(eventEmitter, subprocessOutputDestination) {
+        this.eventEmitter = eventEmitter;
+        this.subprocessOutputDestination = subprocessOutputDestination;
+        this.configDir = undefined;
+    }
+    /**
+     * Whether an image with the given tag exists
+     */
+    async exists(tag) {
+        try {
+            await this.execute(['inspect', tag], {
+                subprocessOutputDestination: 'ignore',
+            });
+            return true;
+        }
+        catch (e) {
+            const error = e;
+            /**
+             * The only error we expect to be thrown will have this property and value.
+             * If it doesn't, it's unrecognized so re-throw it.
+             */
+            if (error.code !== 'PROCESS_FAILED') {
+                throw error;
+            }
+            /**
+             * If we know the shell command above returned an error, check to see
+             * if the exit code is one we know to actually mean that the image doesn't
+             * exist.
+             */
+            switch (error.exitCode) {
+                case InspectImageErrorCode.Docker:
+                case InspectImageErrorCode.Podman:
+                    // Docker and Podman will return this exit code when an image doesn't exist, return false
+                    // context: https://github.com/aws/aws-cdk/issues/16209
+                    return false;
+                default:
+                    // This is an error but it's not an exit code we recognize, throw.
+                    throw error;
+            }
+        }
+    }
+    async build(options) {
+        const buildCommand = [
+            'build',
+            ...flatten(Object.entries(options.buildArgs || {}).map(([k, v]) => ['--build-arg', `${k}=${v}`])),
+            ...flatten(Object.entries(options.buildSecrets || {}).map(([k, v]) => ['--secret', `id=${k},${v}`])),
+            ...(options.buildSsh ? ['--ssh', options.buildSsh] : []),
+            '--tag',
+            options.tag,
+            ...(options.target ? ['--target', options.target] : []),
+            ...(options.file ? ['--file', options.file] : []),
+            ...(options.networkMode ? ['--network', options.networkMode] : []),
+            ...(options.platform ? ['--platform', options.platform] : []),
+            ...(options.outputs ? options.outputs.map((output) => [`--output=${output}`]) : []),
+            ...(options.cacheFrom
+                ? [
+                    ...options.cacheFrom
+                        .map((cacheFrom) => ['--cache-from', this.cacheOptionToFlag(cacheFrom)])
+                        .flat(),
+                ]
+                : []),
+            ...(options.cacheTo ? ['--cache-to', this.cacheOptionToFlag(options.cacheTo)] : []),
+            ...(options.cacheDisabled ? ['--no-cache'] : []),
+            '.',
+        ];
+        await this.execute(buildCommand, {
+            cwd: options.directory,
+            subprocessOutputDestination: this.subprocessOutputDestination,
+        });
+    }
+    /**
+     * Get credentials from ECR and run docker login
+     */
+    async login(ecr) {
+        const credentials = await (0, docker_credentials_1.obtainEcrCredentials)(ecr, this.eventEmitter);
+        // Use --password-stdin otherwise docker will complain. Loudly.
+        await this.execute(['login', '--username', credentials.username, '--password-stdin', credentials.endpoint], {
+            input: credentials.password,
+            // Need to ignore otherwise Docker will complain
+            // 'WARNING! Your password will be stored unencrypted'
+            // doesn't really matter since it's a token.
+            subprocessOutputDestination: 'ignore',
+        });
+    }
+    async tag(sourceTag, targetTag) {
+        await this.execute(['tag', sourceTag, targetTag]);
+    }
+    async push(options) {
+        await this.execute(['push', options.tag], {
+            subprocessOutputDestination: this.subprocessOutputDestination,
+        });
+    }
+    /**
+     * If a CDK Docker Credentials file exists, creates a new Docker config directory.
+     * Sets up `docker-credential-cdk-assets` to be the credential helper for each domain in the CDK config.
+     * All future commands (e.g., `build`, `push`) will use this config.
+     *
+     * See https://docs.docker.com/engine/reference/commandline/login/#credential-helpers for more details on cred helpers.
+     *
+     * @returns true if CDK config was found and configured, false otherwise
+     */
+    configureCdkCredentials() {
+        const config = (0, docker_credentials_1.cdkCredentialsConfig)();
+        if (!config) {
+            return false;
+        }
+        this.configDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdkDockerConfig'));
+        const domains = Object.keys(config.domainCredentials);
+        const credHelpers = domains.reduce((map, domain) => {
+            map[domain] = 'cdk-assets'; // Use docker-credential-cdk-assets for this domain
+            return map;
+        }, {});
+        fs.writeFileSync(path.join(this.configDir, 'config.json'), JSON.stringify({ credHelpers }), {
+            encoding: 'utf-8',
+        });
+        return true;
+    }
+    /**
+     * Removes any configured Docker config directory.
+     * All future commands (e.g., `build`, `push`) will use the default config.
+     *
+     * This is useful after calling `configureCdkCredentials` to reset to default credentials.
+     */
+    resetAuthPlugins() {
+        this.configDir = undefined;
+    }
+    async execute(args, options = {}) {
+        const configArgs = this.configDir ? ['--config', this.configDir] : [];
+        const pathToCdkAssets = path.resolve(__dirname, '..', '..', 'bin');
+        const shellEventPublisher = (0, progress_1.shellEventPublisherFromEventEmitter)(this.eventEmitter);
+        try {
+            await (0, shell_1.shell)([getDockerCmd(), ...configArgs, ...args], {
+                ...options,
+                shellEventPublisher: shellEventPublisher,
+                env: {
+                    ...process.env,
+                    ...options.env,
+                    PATH: `${pathToCdkAssets}${path.delimiter}${options.env?.PATH ?? process.env.PATH}`,
+                },
+            });
+        }
+        catch (e) {
+            if (e.code === 'ENOENT') {
+                throw new Error("Unable to execute 'docker' in order to build a container asset. Please install 'docker' and try again.");
+            }
+            throw e;
+        }
+    }
+    cacheOptionToFlag(option) {
+        let flag = `type=${option.type}`;
+        if (option.params) {
+            flag +=
+                ',' +
+                    Object.entries(option.params)
+                        .map(([k, v]) => `${k}=${v}`)
+                        .join(',');
+        }
+        return flag;
+    }
+}
+exports.Docker = Docker;
+/**
+ * Helps get appropriately configured Docker instances during the container
+ * image publishing process.
+ */
+class DockerFactory {
+    constructor() {
+        this.enterLoggedInDestinationsCriticalSection = (0, util_1.createCriticalSection)();
+        this.loggedInDestinations = new Set();
+    }
+    /**
+     * Gets a Docker instance for building images.
+     */
+    async forBuild(options) {
+        const docker = new Docker(options.eventEmitter, options.subprocessOutputDestination);
+        // Default behavior is to login before build so that the Dockerfile can reference images in the ECR repo
+        // However, if we're in a pipelines environment (for example),
+        // we may have alternative credentials to the default ones to use for the build itself.
+        // If the special config file is present, delay the login to the default credentials until the push.
+        // If the config file is present, we will configure and use those credentials for the build.
+        let cdkDockerCredentialsConfigured = docker.configureCdkCredentials();
+        if (!cdkDockerCredentialsConfigured) {
+            await this.loginOncePerDestination(docker, options);
+        }
+        return docker;
+    }
+    /**
+     * Gets a Docker instance for pushing images to ECR.
+     */
+    async forEcrPush(options) {
+        const docker = new Docker(options.eventEmitter, options.subprocessOutputDestination);
+        await this.loginOncePerDestination(docker, options);
+        return docker;
+    }
+    async loginOncePerDestination(docker, options) {
+        // Changes: 012345678910.dkr.ecr.us-west-2.amazonaws.com/tagging-test
+        // To this: 012345678910.dkr.ecr.us-west-2.amazonaws.com
+        const repositoryDomain = options.repoUri.split('/')[0];
+        // Ensure one-at-a-time access to loggedInDestinations.
+        await this.enterLoggedInDestinationsCriticalSection(async () => {
+            if (this.loggedInDestinations.has(repositoryDomain)) {
+                return;
+            }
+            await docker.login(options.ecr);
+            this.loggedInDestinations.add(repositoryDomain);
+        });
+    }
+}
+exports.DockerFactory = DockerFactory;
+function getDockerCmd() {
+    return process.env.CDK_DOCKER ?? 'docker';
+}
+function flatten(x) {
+    return Array.prototype.concat([], ...x);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"docker.js","sourceRoot":"","sources":["docker.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { cdkCredentialsConfig, obtainEcrCredentials } from './docker-credentials';\nimport { shell, ShellOptions, ProcessFailedError } from './shell';\nimport { createCriticalSection } from './util';\nimport { IECRClient } from '../aws';\nimport { SubprocessOutputDestination } from './asset-handler';\nimport { EventEmitter, shellEventPublisherFromEventEmitter } from '../progress';\n\ninterface BuildOptions {\n  readonly directory: string;\n\n  /**\n   * Tag the image with a given repoName:tag combination\n   */\n  readonly tag: string;\n  readonly target?: string;\n  readonly file?: string;\n  readonly buildArgs?: Record<string, string>;\n  readonly buildSecrets?: Record<string, string>;\n  readonly buildSsh?: string;\n  readonly networkMode?: string;\n  readonly platform?: string;\n  readonly outputs?: string[];\n  readonly cacheFrom?: DockerCacheOption[];\n  readonly cacheTo?: DockerCacheOption;\n  readonly cacheDisabled?: boolean;\n}\n\ninterface PushOptions {\n  readonly tag: string;\n}\n\nexport interface DockerCredentialsConfig {\n  readonly version: string;\n  readonly domainCredentials: Record<string, DockerDomainCredentials>;\n}\n\nexport interface DockerDomainCredentials {\n  readonly secretsManagerSecretId?: string;\n  readonly ecrRepository?: string;\n}\n\nenum InspectImageErrorCode {\n  Docker = 1,\n  Podman = 125,\n}\n\nexport interface DockerCacheOption {\n  readonly type: string;\n  readonly params?: { [key: string]: string };\n}\n\nexport class Docker {\n  private configDir: string | undefined = undefined;\n\n  constructor(\n    private readonly eventEmitter: EventEmitter,\n    private readonly subprocessOutputDestination: SubprocessOutputDestination,\n  ) {}\n\n  /**\n   * Whether an image with the given tag exists\n   */\n  public async exists(tag: string) {\n    try {\n      await this.execute(['inspect', tag], {\n        subprocessOutputDestination: 'ignore',\n      });\n      return true;\n    } catch (e: any) {\n      const error: ProcessFailedError = e;\n\n      /**\n       * The only error we expect to be thrown will have this property and value.\n       * If it doesn't, it's unrecognized so re-throw it.\n       */\n      if (error.code !== 'PROCESS_FAILED') {\n        throw error;\n      }\n\n      /**\n       * If we know the shell command above returned an error, check to see\n       * if the exit code is one we know to actually mean that the image doesn't\n       * exist.\n       */\n      switch (error.exitCode) {\n        case InspectImageErrorCode.Docker:\n        case InspectImageErrorCode.Podman:\n          // Docker and Podman will return this exit code when an image doesn't exist, return false\n          // context: https://github.com/aws/aws-cdk/issues/16209\n          return false;\n        default:\n          // This is an error but it's not an exit code we recognize, throw.\n          throw error;\n      }\n    }\n  }\n\n  public async build(options: BuildOptions) {\n    const buildCommand = [\n      'build',\n      ...flatten(\n        Object.entries(options.buildArgs || {}).map(([k, v]) => ['--build-arg', `${k}=${v}`]),\n      ),\n      ...flatten(\n        Object.entries(options.buildSecrets || {}).map(([k, v]) => ['--secret', `id=${k},${v}`]),\n      ),\n      ...(options.buildSsh ? ['--ssh', options.buildSsh] : []),\n      '--tag',\n      options.tag,\n      ...(options.target ? ['--target', options.target] : []),\n      ...(options.file ? ['--file', options.file] : []),\n      ...(options.networkMode ? ['--network', options.networkMode] : []),\n      ...(options.platform ? ['--platform', options.platform] : []),\n      ...(options.outputs ? options.outputs.map((output) => [`--output=${output}`]) : []),\n      ...(options.cacheFrom\n        ? [\n          ...options.cacheFrom\n            .map((cacheFrom) => ['--cache-from', this.cacheOptionToFlag(cacheFrom)])\n            .flat(),\n        ]\n        : []),\n      ...(options.cacheTo ? ['--cache-to', this.cacheOptionToFlag(options.cacheTo)] : []),\n      ...(options.cacheDisabled ? ['--no-cache'] : []),\n      '.',\n    ];\n    await this.execute(buildCommand, {\n      cwd: options.directory,\n      subprocessOutputDestination: this.subprocessOutputDestination,\n    });\n  }\n\n  /**\n   * Get credentials from ECR and run docker login\n   */\n  public async login(ecr: IECRClient) {\n    const credentials = await obtainEcrCredentials(ecr, this.eventEmitter);\n\n    // Use --password-stdin otherwise docker will complain. Loudly.\n    await this.execute(\n      ['login', '--username', credentials.username, '--password-stdin', credentials.endpoint],\n      {\n        input: credentials.password,\n\n        // Need to ignore otherwise Docker will complain\n        // 'WARNING! Your password will be stored unencrypted'\n        // doesn't really matter since it's a token.\n        subprocessOutputDestination: 'ignore',\n      },\n    );\n  }\n\n  public async tag(sourceTag: string, targetTag: string) {\n    await this.execute(['tag', sourceTag, targetTag]);\n  }\n\n  public async push(options: PushOptions) {\n    await this.execute(['push', options.tag], {\n      subprocessOutputDestination: this.subprocessOutputDestination,\n    });\n  }\n\n  /**\n   * If a CDK Docker Credentials file exists, creates a new Docker config directory.\n   * Sets up `docker-credential-cdk-assets` to be the credential helper for each domain in the CDK config.\n   * All future commands (e.g., `build`, `push`) will use this config.\n   *\n   * See https://docs.docker.com/engine/reference/commandline/login/#credential-helpers for more details on cred helpers.\n   *\n   * @returns true if CDK config was found and configured, false otherwise\n   */\n  public configureCdkCredentials(): boolean {\n    const config = cdkCredentialsConfig();\n    if (!config) {\n      return false;\n    }\n\n    this.configDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdkDockerConfig'));\n\n    const domains = Object.keys(config.domainCredentials);\n    const credHelpers = domains.reduce((map: Record<string, string>, domain) => {\n      map[domain] = 'cdk-assets'; // Use docker-credential-cdk-assets for this domain\n      return map;\n    }, {});\n    fs.writeFileSync(path.join(this.configDir, 'config.json'), JSON.stringify({ credHelpers }), {\n      encoding: 'utf-8',\n    });\n\n    return true;\n  }\n\n  /**\n   * Removes any configured Docker config directory.\n   * All future commands (e.g., `build`, `push`) will use the default config.\n   *\n   * This is useful after calling `configureCdkCredentials` to reset to default credentials.\n   */\n  public resetAuthPlugins() {\n    this.configDir = undefined;\n  }\n\n  private async execute(args: string[], options: Omit<ShellOptions, 'shellEventPublisher'> = {}) {\n    const configArgs = this.configDir ? ['--config', this.configDir] : [];\n\n    const pathToCdkAssets = path.resolve(__dirname, '..', '..', 'bin');\n\n    const shellEventPublisher = shellEventPublisherFromEventEmitter(this.eventEmitter);\n    try {\n      await shell([getDockerCmd(), ...configArgs, ...args], {\n        ...options,\n        shellEventPublisher: shellEventPublisher,\n        env: {\n          ...process.env,\n          ...options.env,\n          PATH: `${pathToCdkAssets}${path.delimiter}${options.env?.PATH ?? process.env.PATH}`,\n        },\n      });\n    } catch (e: any) {\n      if (e.code === 'ENOENT') {\n        throw new Error(\n          \"Unable to execute 'docker' in order to build a container asset. Please install 'docker' and try again.\",\n        );\n      }\n      throw e;\n    }\n  }\n\n  private cacheOptionToFlag(option: DockerCacheOption): string {\n    let flag = `type=${option.type}`;\n    if (option.params) {\n      flag +=\n        ',' +\n        Object.entries(option.params)\n          .map(([k, v]) => `${k}=${v}`)\n          .join(',');\n    }\n    return flag;\n  }\n}\n\nexport interface DockerFactoryOptions {\n  readonly repoUri: string;\n  readonly ecr: IECRClient;\n  readonly eventEmitter: EventEmitter;\n  readonly subprocessOutputDestination: SubprocessOutputDestination;\n}\n\n/**\n * Helps get appropriately configured Docker instances during the container\n * image publishing process.\n */\nexport class DockerFactory {\n  private enterLoggedInDestinationsCriticalSection = createCriticalSection();\n  private loggedInDestinations = new Set<string>();\n\n  /**\n   * Gets a Docker instance for building images.\n   */\n  public async forBuild(options: DockerFactoryOptions): Promise<Docker> {\n    const docker = new Docker(options.eventEmitter, options.subprocessOutputDestination);\n\n    // Default behavior is to login before build so that the Dockerfile can reference images in the ECR repo\n    // However, if we're in a pipelines environment (for example),\n    // we may have alternative credentials to the default ones to use for the build itself.\n    // If the special config file is present, delay the login to the default credentials until the push.\n    // If the config file is present, we will configure and use those credentials for the build.\n    let cdkDockerCredentialsConfigured = docker.configureCdkCredentials();\n    if (!cdkDockerCredentialsConfigured) {\n      await this.loginOncePerDestination(docker, options);\n    }\n\n    return docker;\n  }\n\n  /**\n   * Gets a Docker instance for pushing images to ECR.\n   */\n  public async forEcrPush(options: DockerFactoryOptions) {\n    const docker = new Docker(options.eventEmitter, options.subprocessOutputDestination);\n    await this.loginOncePerDestination(docker, options);\n    return docker;\n  }\n\n  private async loginOncePerDestination(docker: Docker, options: DockerFactoryOptions) {\n    // Changes: 012345678910.dkr.ecr.us-west-2.amazonaws.com/tagging-test\n    // To this: 012345678910.dkr.ecr.us-west-2.amazonaws.com\n    const repositoryDomain = options.repoUri.split('/')[0];\n\n    // Ensure one-at-a-time access to loggedInDestinations.\n    await this.enterLoggedInDestinationsCriticalSection(async () => {\n      if (this.loggedInDestinations.has(repositoryDomain)) {\n        return;\n      }\n\n      await docker.login(options.ecr);\n      this.loggedInDestinations.add(repositoryDomain);\n    });\n  }\n}\n\nfunction getDockerCmd(): string {\n  return process.env.CDK_DOCKER ?? 'docker';\n}\n\nfunction flatten(x: string[][]) {\n  return Array.prototype.concat([], ...x);\n}\n"]}

package/lib/private/fs-extra.d.ts

@@ -0,0 +1,3 @@
+export declare function pathExists(pathName: string): Promise<boolean>;
+export declare function emptyDirSync(dir: string): void;
+export declare function rmRfSync(dir: string): void;

package/lib/private/fs-extra.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathExists = pathExists;
+exports.emptyDirSync = emptyDirSync;
+exports.rmRfSync = rmRfSync;
+const fs = require("fs");
+const path = require("path");
+const pfs = fs.promises;
+async function pathExists(pathName) {
+    try {
+        await pfs.stat(pathName);
+        return true;
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT') {
+            throw e;
+        }
+        return false;
+    }
+}
+function emptyDirSync(dir) {
+    fs.readdirSync(dir, { withFileTypes: true }).forEach((dirent) => {
+        const fullPath = path.join(dir, dirent.name);
+        if (dirent.isDirectory()) {
+            emptyDirSync(fullPath);
+            fs.rmdirSync(fullPath);
+        }
+        else {
+            fs.unlinkSync(fullPath);
+        }
+    });
+}
+function rmRfSync(dir) {
+    emptyDirSync(dir);
+    fs.rmdirSync(dir);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/handlers/client-options.d.ts

@@ -0,0 +1,3 @@
+import type { AwsDestination } from '@aws-cdk/cloud-assembly-schema';
+import type { ClientOptions } from '../../aws';
+export declare function destinationToClientOptions(destination: AwsDestination): ClientOptions;

package/lib/private/handlers/client-options.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destinationToClientOptions = destinationToClientOptions;
+function destinationToClientOptions(destination) {
+    return {
+        assumeRoleArn: destination.assumeRoleArn,
+        assumeRoleExternalId: destination.assumeRoleExternalId,
+        assumeRoleAdditionalOptions: destination.assumeRoleAdditionalOptions,
+        region: destination.region,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LW9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjbGllbnQtb3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUdBLGdFQU9DO0FBUEQsU0FBZ0IsMEJBQTBCLENBQUMsV0FBMkI7SUFDcEUsT0FBTztRQUNMLGFBQWEsRUFBRSxXQUFXLENBQUMsYUFBYTtRQUN4QyxvQkFBb0IsRUFBRSxXQUFXLENBQUMsb0JBQW9CO1FBQ3RELDJCQUEyQixFQUFFLFdBQVcsQ0FBQywyQkFBMkI7UUFDcEUsTUFBTSxFQUFFLFdBQVcsQ0FBQyxNQUFNO0tBQzNCLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBBd3NEZXN0aW5hdGlvbiB9IGZyb20gJ0Bhd3MtY2RrL2Nsb3VkLWFzc2VtYmx5LXNjaGVtYSc7XG5pbXBvcnQgdHlwZSB7IENsaWVudE9wdGlvbnMgfSBmcm9tICcuLi8uLi9hd3MnO1xuXG5leHBvcnQgZnVuY3Rpb24gZGVzdGluYXRpb25Ub0NsaWVudE9wdGlvbnMoZGVzdGluYXRpb246IEF3c0Rlc3RpbmF0aW9uKTogQ2xpZW50T3B0aW9ucyB7XG4gIHJldHVybiB7XG4gICAgYXNzdW1lUm9sZUFybjogZGVzdGluYXRpb24uYXNzdW1lUm9sZUFybixcbiAgICBhc3N1bWVSb2xlRXh0ZXJuYWxJZDogZGVzdGluYXRpb24uYXNzdW1lUm9sZUV4dGVybmFsSWQsXG4gICAgYXNzdW1lUm9sZUFkZGl0aW9uYWxPcHRpb25zOiBkZXN0aW5hdGlvbi5hc3N1bWVSb2xlQWRkaXRpb25hbE9wdGlvbnMsXG4gICAgcmVnaW9uOiBkZXN0aW5hdGlvbi5yZWdpb24sXG4gIH07XG59XG4iXX0=

package/lib/private/handlers/container-images.d.ts

@@ -0,0 +1,22 @@
+import { DockerImageManifestEntry } from '../../asset-manifest';
+import { IAssetHandler, IHandlerHost, IHandlerOptions } from '../asset-handler';
+export declare class ContainerImageAssetHandler implements IAssetHandler {
+    private readonly workDir;
+    private readonly asset;
+    private readonly host;
+    private readonly options;
+    private init?;
+    constructor(workDir: string, asset: DockerImageManifestEntry, host: IHandlerHost, options: IHandlerOptions);
+    build(): Promise<void>;
+    isPublished(): Promise<boolean>;
+    publish(): Promise<void>;
+    private initOnce;
+    /**
+     * Check whether the image already exists in the ECR repo
+     *
+     * Use the fields from the destination to do the actual check. The imageUri
+     * should correspond to that, but is only used to print Docker image location
+     * for user benefit (the format is slightly different).
+     */
+    private destinationAlreadyExists;
+}

package/lib/private/handlers/container-images.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerImageAssetHandler = void 0;
+const path = require("path");
+const client_options_1 = require("./client-options");
+const progress_1 = require("../../progress");
+const placeholders_1 = require("../placeholders");
+const shell_1 = require("../shell");
+class ContainerImageAssetHandler {
+    constructor(workDir, asset, host, options) {
+        this.workDir = workDir;
+        this.asset = asset;
+        this.host = host;
+        this.options = options;
+    }
+    async build() {
+        const initOnce = await this.initOnce();
+        if (initOnce.destinationAlreadyExists) {
+            return;
+        }
+        if (this.host.aborted) {
+            return;
+        }
+        const dockerForBuilding = await this.host.dockerFactory.forBuild({
+            repoUri: initOnce.repoUri,
+            eventEmitter: (m) => this.host.emitMessage(progress_1.EventType.DEBUG, m),
+            ecr: initOnce.ecr,
+            subprocessOutputDestination: this.options.subprocessOutputDestination,
+        });
+        const builder = new ContainerImageBuilder(dockerForBuilding, this.workDir, this.asset, this.host);
+        const localTagName = await builder.build();
+        if (localTagName === undefined || this.host.aborted) {
+            return;
+        }
+        if (this.host.aborted) {
+            return;
+        }
+        await dockerForBuilding.tag(localTagName, initOnce.imageUri);
+    }
+    async isPublished() {
+        try {
+            const initOnce = await this.initOnce({ quiet: true });
+            return initOnce.destinationAlreadyExists;
+        }
+        catch (e) {
+            this.host.emitMessage(progress_1.EventType.DEBUG, `${e.message}`);
+        }
+        return false;
+    }
+    async publish() {
+        const initOnce = await this.initOnce();
+        if (initOnce.destinationAlreadyExists) {
+            return;
+        }
+        if (this.host.aborted) {
+            return;
+        }
+        const dockerForPushing = await this.host.dockerFactory.forEcrPush({
+            repoUri: initOnce.repoUri,
+            eventEmitter: this.host.emitMessage,
+            ecr: initOnce.ecr,
+            subprocessOutputDestination: this.options.subprocessOutputDestination,
+        });
+        if (this.host.aborted) {
+            return;
+        }
+        this.host.emitMessage(progress_1.EventType.UPLOAD, `Push ${initOnce.imageUri}`);
+        await dockerForPushing.push({
+            tag: initOnce.imageUri,
+        });
+    }
+    async initOnce(options = {}) {
+        if (this.init) {
+            return this.init;
+        }
+        const destination = await (0, placeholders_1.replaceAwsPlaceholders)(this.asset.destination, this.host.aws);
+        const ecr = await this.host.aws.ecrClient({
+            ...(0, client_options_1.destinationToClientOptions)(destination),
+            quiet: options.quiet,
+        });
+        const account = async () => (await this.host.aws.discoverCurrentAccount())?.accountId;
+        const repoUri = await repositoryUri(ecr, destination.repositoryName);
+        if (!repoUri) {
+            throw new Error(`No ECR repository named '${destination.repositoryName}' in account ${await account()}. Is this account bootstrapped?`);
+        }
+        const imageUri = `${repoUri}:${destination.imageTag}`;
+        this.init = {
+            imageUri,
+            ecr,
+            repoUri,
+            destinationAlreadyExists: await this.destinationAlreadyExists(ecr, destination, imageUri),
+        };
+        return this.init;
+    }
+    /**
+     * Check whether the image already exists in the ECR repo
+     *
+     * Use the fields from the destination to do the actual check. The imageUri
+     * should correspond to that, but is only used to print Docker image location
+     * for user benefit (the format is slightly different).
+     */
+    async destinationAlreadyExists(ecr, destination, imageUri) {
+        this.host.emitMessage(progress_1.EventType.CHECK, `Check ${imageUri}`);
+        if (await imageExists(ecr, destination.repositoryName, destination.imageTag)) {
+            this.host.emitMessage(progress_1.EventType.FOUND, `Found ${imageUri}`);
+            return true;
+        }
+        return false;
+    }
+}
+exports.ContainerImageAssetHandler = ContainerImageAssetHandler;
+class ContainerImageBuilder {
+    constructor(docker, workDir, asset, host) {
+        this.docker = docker;
+        this.workDir = workDir;
+        this.asset = asset;
+        this.host = host;
+    }
+    async build() {
+        return this.asset.source.executable
+            ? this.buildExternalAsset(this.asset.source.executable)
+            : this.buildDirectoryAsset();
+    }
+    /**
+     * Build a (local) Docker asset from a directory with a Dockerfile
+     *
+     * Tags under a deterministic, unique, local identifier wich will skip
+     * the build if it already exists.
+     */
+    async buildDirectoryAsset() {
+        const localTagName = `cdkasset-${this.asset.id.assetId.toLowerCase()}`;
+        if (!(await this.isImageCached(localTagName))) {
+            if (this.host.aborted) {
+                return undefined;
+            }
+            await this.buildImage(localTagName);
+        }
+        return localTagName;
+    }
+    /**
+     * Build a (local) Docker asset by running an external command
+     *
+     * External command is responsible for deduplicating the build if possible,
+     * and is expected to return the generated image identifier on stdout.
+     */
+    async buildExternalAsset(executable, cwd) {
+        const assetPath = cwd ?? this.workDir;
+        this.host.emitMessage(progress_1.EventType.BUILD, `Building Docker image using command '${executable}'`);
+        if (this.host.aborted) {
+            return undefined;
+        }
+        const shellEventPublisher = (0, progress_1.shellEventPublisherFromEventEmitter)(this.host.emitMessage);
+        return (await (0, shell_1.shell)(executable, {
+            cwd: assetPath,
+            shellEventPublisher,
+            subprocessOutputDestination: 'ignore',
+        })).trim();
+    }
+    async buildImage(localTagName) {
+        const source = this.asset.source;
+        if (!source.directory) {
+            throw new Error(`'directory' is expected in the DockerImage asset source, got: ${JSON.stringify(source)}`);
+        }
+        const fullPath = path.resolve(this.workDir, source.directory);
+        this.host.emitMessage(progress_1.EventType.BUILD, `Building Docker image at ${fullPath}`);
+        await this.docker.build({
+            directory: fullPath,
+            tag: localTagName,
+            buildArgs: source.dockerBuildArgs,
+            buildSecrets: source.dockerBuildSecrets,
+            buildSsh: source.dockerBuildSsh,
+            target: source.dockerBuildTarget,
+            file: source.dockerFile,
+            networkMode: source.networkMode,
+            platform: source.platform,
+            outputs: source.dockerOutputs,
+            cacheFrom: source.cacheFrom,
+            cacheTo: source.cacheTo,
+            cacheDisabled: source.cacheDisabled,
+        });
+    }
+    async isImageCached(localTagName) {
+        if (await this.docker.exists(localTagName)) {
+            this.host.emitMessage(progress_1.EventType.CACHED, `Cached ${localTagName}`);
+            return true;
+        }
+        return false;
+    }
+}
+async function imageExists(ecr, repositoryName, imageTag) {
+    try {
+        await ecr.describeImages({
+            repositoryName,
+            imageIds: [{ imageTag }],
+        });
+        return true;
+    }
+    catch (e) {
+        if (e.name !== 'ImageNotFoundException') {
+            throw e;
+        }
+        return false;
+    }
+}
+/**
+ * Return the URI for the repository with the given name
+ *
+ * Returns undefined if the repository does not exist.
+ */
+async function repositoryUri(ecr, repositoryName) {
+    try {
+        const response = await ecr.describeRepositories({
+            repositoryNames: [repositoryName],
+        });
+        return (response.repositories || [])[0]?.repositoryUri;
+    }
+    catch (e) {
+        if (e.name !== 'RepositoryNotFoundException') {
+            throw e;
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container-images.js","sourceRoot":"","sources":["container-images.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { DockerImageDestination } from '@aws-cdk/cloud-assembly-schema';\nimport { destinationToClientOptions } from './client-options';\nimport { DockerImageManifestEntry } from '../../asset-manifest';\nimport type { IECRClient } from '../../aws';\nimport { EventType, shellEventPublisherFromEventEmitter } from '../../progress';\nimport { IAssetHandler, IHandlerHost, IHandlerOptions } from '../asset-handler';\nimport { Docker } from '../docker';\nimport { replaceAwsPlaceholders } from '../placeholders';\nimport { shell } from '../shell';\n\ninterface ContainerImageAssetHandlerInit {\n  readonly ecr: IECRClient;\n  readonly repoUri: string;\n  readonly imageUri: string;\n  readonly destinationAlreadyExists: boolean;\n}\n\nexport class ContainerImageAssetHandler implements IAssetHandler {\n  private init?: ContainerImageAssetHandlerInit;\n\n  constructor(\n    private readonly workDir: string,\n    private readonly asset: DockerImageManifestEntry,\n    private readonly host: IHandlerHost,\n    private readonly options: IHandlerOptions,\n  ) {}\n\n  public async build(): Promise<void> {\n    const initOnce = await this.initOnce();\n\n    if (initOnce.destinationAlreadyExists) {\n      return;\n    }\n    if (this.host.aborted) {\n      return;\n    }\n\n    const dockerForBuilding = await this.host.dockerFactory.forBuild({\n      repoUri: initOnce.repoUri,\n      eventEmitter: (m: string) => this.host.emitMessage(EventType.DEBUG, m),\n      ecr: initOnce.ecr,\n      subprocessOutputDestination: this.options.subprocessOutputDestination,\n    });\n\n    const builder = new ContainerImageBuilder(\n      dockerForBuilding,\n      this.workDir,\n      this.asset,\n      this.host,\n    );\n    const localTagName = await builder.build();\n\n    if (localTagName === undefined || this.host.aborted) {\n      return;\n    }\n    if (this.host.aborted) {\n      return;\n    }\n\n    await dockerForBuilding.tag(localTagName, initOnce.imageUri);\n  }\n\n  public async isPublished(): Promise<boolean> {\n    try {\n      const initOnce = await this.initOnce({ quiet: true });\n      return initOnce.destinationAlreadyExists;\n    } catch (e: any) {\n      this.host.emitMessage(EventType.DEBUG, `${e.message}`);\n    }\n    return false;\n  }\n\n  public async publish(): Promise<void> {\n    const initOnce = await this.initOnce();\n\n    if (initOnce.destinationAlreadyExists) {\n      return;\n    }\n    if (this.host.aborted) {\n      return;\n    }\n\n    const dockerForPushing = await this.host.dockerFactory.forEcrPush({\n      repoUri: initOnce.repoUri,\n      eventEmitter: this.host.emitMessage,\n      ecr: initOnce.ecr,\n      subprocessOutputDestination: this.options.subprocessOutputDestination,\n    });\n\n    if (this.host.aborted) {\n      return;\n    }\n\n    this.host.emitMessage(EventType.UPLOAD, `Push ${initOnce.imageUri}`);\n    await dockerForPushing.push({\n      tag: initOnce.imageUri,\n    });\n  }\n\n  private async initOnce(\n    options: { quiet?: boolean } = {},\n  ): Promise<ContainerImageAssetHandlerInit> {\n    if (this.init) {\n      return this.init;\n    }\n\n    const destination = await replaceAwsPlaceholders(this.asset.destination, this.host.aws);\n    const ecr = await this.host.aws.ecrClient({\n      ...destinationToClientOptions(destination),\n      quiet: options.quiet,\n    });\n    const account = async () => (await this.host.aws.discoverCurrentAccount())?.accountId;\n\n    const repoUri = await repositoryUri(ecr, destination.repositoryName);\n    if (!repoUri) {\n      throw new Error(\n        `No ECR repository named '${destination.repositoryName}' in account ${await account()}. Is this account bootstrapped?`,\n      );\n    }\n\n    const imageUri = `${repoUri}:${destination.imageTag}`;\n\n    this.init = {\n      imageUri,\n      ecr,\n      repoUri,\n      destinationAlreadyExists: await this.destinationAlreadyExists(ecr, destination, imageUri),\n    };\n\n    return this.init;\n  }\n\n  /**\n   * Check whether the image already exists in the ECR repo\n   *\n   * Use the fields from the destination to do the actual check. The imageUri\n   * should correspond to that, but is only used to print Docker image location\n   * for user benefit (the format is slightly different).\n   */\n  private async destinationAlreadyExists(\n    ecr: IECRClient,\n    destination: DockerImageDestination,\n    imageUri: string,\n  ): Promise<boolean> {\n    this.host.emitMessage(EventType.CHECK, `Check ${imageUri}`);\n    if (await imageExists(ecr, destination.repositoryName, destination.imageTag)) {\n      this.host.emitMessage(EventType.FOUND, `Found ${imageUri}`);\n      return true;\n    }\n\n    return false;\n  }\n}\n\nclass ContainerImageBuilder {\n  constructor(\n    private readonly docker: Docker,\n    private readonly workDir: string,\n    private readonly asset: DockerImageManifestEntry,\n    private readonly host: IHandlerHost,\n  ) {}\n\n  async build(): Promise<string | undefined> {\n    return this.asset.source.executable\n      ? this.buildExternalAsset(this.asset.source.executable)\n      : this.buildDirectoryAsset();\n  }\n\n  /**\n   * Build a (local) Docker asset from a directory with a Dockerfile\n   *\n   * Tags under a deterministic, unique, local identifier wich will skip\n   * the build if it already exists.\n   */\n  private async buildDirectoryAsset(): Promise<string | undefined> {\n    const localTagName = `cdkasset-${this.asset.id.assetId.toLowerCase()}`;\n\n    if (!(await this.isImageCached(localTagName))) {\n      if (this.host.aborted) {\n        return undefined;\n      }\n\n      await this.buildImage(localTagName);\n    }\n\n    return localTagName;\n  }\n\n  /**\n   * Build a (local) Docker asset by running an external command\n   *\n   * External command is responsible for deduplicating the build if possible,\n   * and is expected to return the generated image identifier on stdout.\n   */\n  private async buildExternalAsset(\n    executable: string[],\n    cwd?: string,\n  ): Promise<string | undefined> {\n    const assetPath = cwd ?? this.workDir;\n\n    this.host.emitMessage(EventType.BUILD, `Building Docker image using command '${executable}'`);\n    if (this.host.aborted) {\n      return undefined;\n    }\n\n    const shellEventPublisher = shellEventPublisherFromEventEmitter(this.host.emitMessage);\n\n    return (\n      await shell(executable, {\n        cwd: assetPath,\n        shellEventPublisher,\n        subprocessOutputDestination: 'ignore',\n      })\n    ).trim();\n  }\n\n  private async buildImage(localTagName: string): Promise<void> {\n    const source = this.asset.source;\n    if (!source.directory) {\n      throw new Error(\n        `'directory' is expected in the DockerImage asset source, got: ${JSON.stringify(source)}`,\n      );\n    }\n\n    const fullPath = path.resolve(this.workDir, source.directory);\n    this.host.emitMessage(EventType.BUILD, `Building Docker image at ${fullPath}`);\n\n    await this.docker.build({\n      directory: fullPath,\n      tag: localTagName,\n      buildArgs: source.dockerBuildArgs,\n      buildSecrets: source.dockerBuildSecrets,\n      buildSsh: source.dockerBuildSsh,\n      target: source.dockerBuildTarget,\n      file: source.dockerFile,\n      networkMode: source.networkMode,\n      platform: source.platform,\n      outputs: source.dockerOutputs,\n      cacheFrom: source.cacheFrom,\n      cacheTo: source.cacheTo,\n      cacheDisabled: source.cacheDisabled,\n    });\n  }\n\n  private async isImageCached(localTagName: string): Promise<boolean> {\n    if (await this.docker.exists(localTagName)) {\n      this.host.emitMessage(EventType.CACHED, `Cached ${localTagName}`);\n      return true;\n    }\n\n    return false;\n  }\n}\n\nasync function imageExists(ecr: IECRClient, repositoryName: string, imageTag: string) {\n  try {\n    await ecr.describeImages({\n      repositoryName,\n      imageIds: [{ imageTag }],\n    });\n    return true;\n  } catch (e: any) {\n    if (e.name !== 'ImageNotFoundException') {\n      throw e;\n    }\n    return false;\n  }\n}\n\n/**\n * Return the URI for the repository with the given name\n *\n * Returns undefined if the repository does not exist.\n */\nasync function repositoryUri(ecr: IECRClient, repositoryName: string): Promise<string | undefined> {\n  try {\n    const response = await ecr.describeRepositories({\n      repositoryNames: [repositoryName],\n    });\n    return (response.repositories || [])[0]?.repositoryUri;\n  } catch (e: any) {\n    if (e.name !== 'RepositoryNotFoundException') {\n      throw e;\n    }\n    return undefined;\n  }\n}\n"]}

package/lib/private/handlers/files.d.ts

@@ -0,0 +1,14 @@
+import { FileManifestEntry } from '../../asset-manifest';
+import { IAssetHandler, IHandlerHost, type PublishOptions } from '../asset-handler';
+export declare class FileAssetHandler implements IAssetHandler {
+    private readonly workDir;
+    private readonly asset;
+    private readonly host;
+    private readonly fileCacheRoot;
+    constructor(workDir: string, asset: FileManifestEntry, host: IHandlerHost);
+    build(): Promise<void>;
+    isPublished(): Promise<boolean>;
+    publish(options?: PublishOptions): Promise<void>;
+    private packageFile;
+    private externalPackageFile;
+}