cdk-assets 0.0.0

package/lib/publishing.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetPublishing = void 0;
+const docker_1 = require("./private/docker");
+const handlers_1 = require("./private/handlers");
+const p_limit_1 = require("./private/p-limit");
+const progress_1 = require("./progress");
+class AssetPublishing {
+    constructor(manifest, options) {
+        this.manifest = manifest;
+        this.options = options;
+        /**
+         * The message for the IPublishProgress interface
+         */
+        this.message = 'Starting';
+        this.failures = new Array();
+        this.completedOperations = 0;
+        this.aborted = false;
+        this.handlerCache = new Map();
+        this.assets = manifest.entries;
+        this.totalOperations = this.assets.length;
+        this.publishInParallel = options.publishInParallel ?? false;
+        this.buildAssets = options.buildAssets ?? true;
+        this.publishAssets = options.publishAssets ?? true;
+        const self = this;
+        this.handlerHost = {
+            aws: this.options.aws,
+            get aborted() {
+                return self.aborted;
+            },
+            emitMessage(t, m) {
+                self.progressEvent(t, m);
+            },
+            dockerFactory: new docker_1.DockerFactory(),
+        };
+    }
+    /**
+     * Publish all assets from the manifest
+     */
+    async publish(options = {}) {
+        if (this.publishInParallel) {
+            const limit = (0, p_limit_1.pLimit)(20);
+            // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+            await Promise.all(this.assets.map((asset) => limit(async () => this.publishAsset(asset, options))));
+        }
+        else {
+            for (const asset of this.assets) {
+                if (!(await this.publishAsset(asset, options))) {
+                    break;
+                }
+            }
+        }
+        if ((this.options.throwOnError ?? true) && this.failures.length > 0) {
+            throw new Error(`Error publishing: ${this.failures.map((e) => e.error.message)}`);
+        }
+    }
+    /**
+     * Build a single asset from the manifest
+     */
+    async buildEntry(asset) {
+        try {
+            if (this.progressEvent(progress_1.EventType.START, `Building ${asset.id}`)) {
+                return false;
+            }
+            const handler = this.assetHandler(asset);
+            await handler.build();
+            if (this.aborted) {
+                throw new Error('Aborted');
+            }
+            this.completedOperations++;
+            if (this.progressEvent(progress_1.EventType.SUCCESS, `Built ${asset.id}`)) {
+                return false;
+            }
+        }
+        catch (e) {
+            this.failures.push({ asset, error: e });
+            this.completedOperations++;
+            if (this.progressEvent(progress_1.EventType.FAIL, e.message)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Publish a single asset from the manifest
+     */
+    async publishEntry(asset, options = {}) {
+        try {
+            if (this.progressEvent(progress_1.EventType.START, `Publishing ${asset.id}`)) {
+                return false;
+            }
+            const handler = this.assetHandler(asset);
+            await handler.publish(options);
+            if (this.aborted) {
+                throw new Error('Aborted');
+            }
+            this.completedOperations++;
+            if (this.progressEvent(progress_1.EventType.SUCCESS, `Published ${asset.id}`)) {
+                return false;
+            }
+        }
+        catch (e) {
+            this.failures.push({ asset, error: e });
+            this.completedOperations++;
+            if (this.progressEvent(progress_1.EventType.FAIL, e.message)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Return whether a single asset is published
+     */
+    isEntryPublished(asset) {
+        const handler = this.assetHandler(asset);
+        return handler.isPublished();
+    }
+    /**
+     * publish an asset (used by 'publish()')
+     * @param asset The asset to publish
+     * @returns false when publishing should stop
+     */
+    async publishAsset(asset, options = {}) {
+        try {
+            if (this.progressEvent(progress_1.EventType.START, `Publishing ${asset.id}`)) {
+                return false;
+            }
+            const handler = this.assetHandler(asset);
+            if (this.buildAssets) {
+                await handler.build();
+            }
+            if (this.publishAssets) {
+                await handler.publish(options);
+            }
+            if (this.aborted) {
+                throw new Error('Aborted');
+            }
+            this.completedOperations++;
+            if (this.progressEvent(progress_1.EventType.SUCCESS, `Published ${asset.id}`)) {
+                return false;
+            }
+        }
+        catch (e) {
+            this.failures.push({ asset, error: e });
+            this.completedOperations++;
+            if (this.progressEvent(progress_1.EventType.FAIL, e.message)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    get percentComplete() {
+        if (this.totalOperations === 0) {
+            return 100;
+        }
+        return Math.floor((this.completedOperations / this.totalOperations) * 100);
+    }
+    abort() {
+        this.aborted = true;
+    }
+    get hasFailures() {
+        return this.failures.length > 0;
+    }
+    /**
+     * Publish a progress event to the listener, if present.
+     *
+     * Returns whether an abort is requested. Helper to get rid of repetitive code in publish().
+     */
+    progressEvent(event, message) {
+        this.message = message;
+        if (this.options.progressListener) {
+            this.options.progressListener.onPublishEvent(event, this);
+        }
+        return this.aborted;
+    }
+    assetHandler(asset) {
+        const existing = this.handlerCache.get(asset);
+        if (existing) {
+            return existing;
+        }
+        if (this.options.quiet !== undefined && this.options.subprocessOutputDestination) {
+            throw new Error('Cannot set both quiet and subprocessOutputDestination. Please use only subprocessOutputDestination');
+        }
+        const subprocessOutputDestination = this.options.subprocessOutputDestination ?? (this.options.quiet ? 'ignore' : 'stdio');
+        const ret = (0, handlers_1.makeAssetHandler)(this.manifest, asset, this.handlerHost, {
+            subprocessOutputDestination,
+        });
+        this.handlerCache.set(asset, ret);
+        return ret;
+    }
+}
+exports.AssetPublishing = AssetPublishing;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"publishing.js","sourceRoot":"","sources":["publishing.ts"],"names":[],"mappings":"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","sourcesContent":["import { AssetManifest, IManifestEntry } from './asset-manifest';\nimport { IAws } from './aws';\nimport {\n  IAssetHandler,\n  IHandlerHost,\n  type PublishOptions,\n  SubprocessOutputDestination,\n} from './private/asset-handler';\nimport { DockerFactory } from './private/docker';\nimport { makeAssetHandler } from './private/handlers';\nimport { pLimit } from './private/p-limit';\nimport { EventType, IPublishProgress, IPublishProgressListener } from './progress';\n\nexport interface AssetPublishingOptions {\n  /**\n   * Entry point for AWS client\n   */\n  readonly aws: IAws;\n\n  /**\n   * Listener for progress events\n   *\n   * @default No listener\n   */\n  readonly progressListener?: IPublishProgressListener;\n\n  /**\n   * Whether to throw at the end if there were errors\n   *\n   * @default true\n   */\n  readonly throwOnError?: boolean;\n\n  /**\n   * Whether to publish in parallel, when 'publish()' is called\n   *\n   * @default false\n   */\n  readonly publishInParallel?: boolean;\n\n  /**\n   * Whether to build assets, when 'publish()' is called\n   *\n   * @default true\n   */\n  readonly buildAssets?: boolean;\n\n  /**\n   * Whether to publish assets, when 'publish()' is called\n   *\n   * @default true\n   */\n  readonly publishAssets?: boolean;\n\n  /**\n   * @deprecated use {@link #subprocessOutputDestination} instead\n   */\n  readonly quiet?: boolean;\n\n  /**\n   * Where to send output of a subprocesses\n   *\n   * @default 'stdio'\n   */\n  subprocessOutputDestination?: SubprocessOutputDestination;\n}\n\n/**\n * A failure to publish an asset\n */\nexport interface FailedAsset {\n  /**\n   * The asset that failed to publish\n   */\n  readonly asset: IManifestEntry;\n\n  /**\n   * The failure that occurred\n   */\n  readonly error: Error;\n}\n\nexport class AssetPublishing implements IPublishProgress {\n  /**\n   * The message for the IPublishProgress interface\n   */\n  public message: string = 'Starting';\n\n  /**\n   * The current asset for the IPublishProgress interface\n   */\n  public currentAsset?: IManifestEntry;\n  public readonly failures = new Array<FailedAsset>();\n  private readonly assets: IManifestEntry[];\n\n  private readonly totalOperations: number;\n  private completedOperations: number = 0;\n  private aborted = false;\n  private readonly handlerHost: IHandlerHost;\n  private readonly publishInParallel: boolean;\n  private readonly buildAssets: boolean;\n  private readonly publishAssets: boolean;\n  private readonly handlerCache = new Map<IManifestEntry, IAssetHandler>();\n\n  constructor(\n    private readonly manifest: AssetManifest,\n    private readonly options: AssetPublishingOptions,\n  ) {\n    this.assets = manifest.entries;\n    this.totalOperations = this.assets.length;\n    this.publishInParallel = options.publishInParallel ?? false;\n    this.buildAssets = options.buildAssets ?? true;\n    this.publishAssets = options.publishAssets ?? true;\n\n    const self = this;\n    this.handlerHost = {\n      aws: this.options.aws,\n      get aborted() {\n        return self.aborted;\n      },\n      emitMessage(t, m) {\n        self.progressEvent(t, m);\n      },\n      dockerFactory: new DockerFactory(),\n    };\n  }\n\n  /**\n   * Publish all assets from the manifest\n   */\n  public async publish(options: PublishOptions = {}): Promise<void> {\n    if (this.publishInParallel) {\n      const limit = pLimit(20);\n      // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n      await Promise.all(\n        this.assets.map((asset) => limit(async () => this.publishAsset(asset, options))),\n      );\n    } else {\n      for (const asset of this.assets) {\n        if (!(await this.publishAsset(asset, options))) {\n          break;\n        }\n      }\n    }\n\n    if ((this.options.throwOnError ?? true) && this.failures.length > 0) {\n      throw new Error(`Error publishing: ${this.failures.map((e) => e.error.message)}`);\n    }\n  }\n\n  /**\n   * Build a single asset from the manifest\n   */\n  public async buildEntry(asset: IManifestEntry) {\n    try {\n      if (this.progressEvent(EventType.START, `Building ${asset.id}`)) {\n        return false;\n      }\n\n      const handler = this.assetHandler(asset);\n      await handler.build();\n\n      if (this.aborted) {\n        throw new Error('Aborted');\n      }\n\n      this.completedOperations++;\n      if (this.progressEvent(EventType.SUCCESS, `Built ${asset.id}`)) {\n        return false;\n      }\n    } catch (e: any) {\n      this.failures.push({ asset, error: e });\n      this.completedOperations++;\n      if (this.progressEvent(EventType.FAIL, e.message)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Publish a single asset from the manifest\n   */\n  public async publishEntry(asset: IManifestEntry, options: PublishOptions = {}) {\n    try {\n      if (this.progressEvent(EventType.START, `Publishing ${asset.id}`)) {\n        return false;\n      }\n\n      const handler = this.assetHandler(asset);\n      await handler.publish(options);\n\n      if (this.aborted) {\n        throw new Error('Aborted');\n      }\n\n      this.completedOperations++;\n      if (this.progressEvent(EventType.SUCCESS, `Published ${asset.id}`)) {\n        return false;\n      }\n    } catch (e: any) {\n      this.failures.push({ asset, error: e });\n      this.completedOperations++;\n      if (this.progressEvent(EventType.FAIL, e.message)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Return whether a single asset is published\n   */\n  public isEntryPublished(asset: IManifestEntry) {\n    const handler = this.assetHandler(asset);\n    return handler.isPublished();\n  }\n\n  /**\n   * publish an asset (used by 'publish()')\n   * @param asset The asset to publish\n   * @returns false when publishing should stop\n   */\n  private async publishAsset(asset: IManifestEntry, options: PublishOptions = {}) {\n    try {\n      if (this.progressEvent(EventType.START, `Publishing ${asset.id}`)) {\n        return false;\n      }\n\n      const handler = this.assetHandler(asset);\n\n      if (this.buildAssets) {\n        await handler.build();\n      }\n\n      if (this.publishAssets) {\n        await handler.publish(options);\n      }\n\n      if (this.aborted) {\n        throw new Error('Aborted');\n      }\n\n      this.completedOperations++;\n      if (this.progressEvent(EventType.SUCCESS, `Published ${asset.id}`)) {\n        return false;\n      }\n    } catch (e: any) {\n      this.failures.push({ asset, error: e });\n      this.completedOperations++;\n      if (this.progressEvent(EventType.FAIL, e.message)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  public get percentComplete() {\n    if (this.totalOperations === 0) {\n      return 100;\n    }\n    return Math.floor((this.completedOperations / this.totalOperations) * 100);\n  }\n\n  public abort(): void {\n    this.aborted = true;\n  }\n\n  public get hasFailures() {\n    return this.failures.length > 0;\n  }\n\n  /**\n   * Publish a progress event to the listener, if present.\n   *\n   * Returns whether an abort is requested. Helper to get rid of repetitive code in publish().\n   */\n  private progressEvent(event: EventType, message: string): boolean {\n    this.message = message;\n    if (this.options.progressListener) {\n      this.options.progressListener.onPublishEvent(event, this);\n    }\n    return this.aborted;\n  }\n\n  private assetHandler(asset: IManifestEntry) {\n    const existing = this.handlerCache.get(asset);\n    if (existing) {\n      return existing;\n    }\n    if (this.options.quiet !== undefined && this.options.subprocessOutputDestination) {\n      throw new Error(\n        'Cannot set both quiet and subprocessOutputDestination. Please use only subprocessOutputDestination',\n      );\n    }\n    const subprocessOutputDestination =\n      this.options.subprocessOutputDestination ?? (this.options.quiet ? 'ignore' : 'stdio');\n    const ret = makeAssetHandler(this.manifest, asset, this.handlerHost, {\n      subprocessOutputDestination,\n    });\n    this.handlerCache.set(asset, ret);\n    return ret;\n  }\n}\n"]}

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "cdk-assets",
+  "description": "CDK Asset Publishing Tool",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aws/aws-cdk-cli",
+    "directory": "packages/cdk-assets"
+  },
+  "bin": {
+    "cdk-assets": "bin/cdk-assets",
+    "docker-credential-cdk-assets": "bin/docker-credential-cdk-assets"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "check-for-updates": "npx projen check-for-updates",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "eslint": "npx projen eslint",
+    "gather-versions": "npx projen gather-versions",
+    "package": "npx projen package",
+    "post-compile": "npx projen post-compile",
+    "pre-compile": "npx projen pre-compile",
+    "shrinkwrap": "npx projen shrinkwrap",
+    "test": "npx projen test",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Amazon Web Services",
+    "url": "https://aws.amazon.com",
+    "organization": true
+  },
+  "devDependencies": {
+    "@cdklabs/eslint-plugin": "^1.3.2",
+    "@smithy/types": "^4.1.0",
+    "@smithy/util-stream": "^4.0.2",
+    "@stylistic/eslint-plugin": "^3.1.0",
+    "@types/archiver": "^6.0.3",
+    "@types/glob": "^8.1.0",
+    "@types/jest": "^29.5.14",
+    "@types/mime": "^2",
+    "@types/mock-fs": "^4",
+    "@types/node": "^16",
+    "@types/yargs": "^17.0.33",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "aws-sdk-client-mock": "^4.1.0",
+    "aws-sdk-client-mock-jest": "^4.1.0",
+    "commit-and-tag-version": "^12",
+    "constructs": "^10.0.0",
+    "eslint": "^9",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-import-resolver-typescript": "^3.7.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jest": "^28.11.0",
+    "eslint-plugin-prettier": "^5.2.3",
+    "fs-extra": "^11.3.0",
+    "graceful-fs": "^4.2.11",
+    "jest": "^29.7.0",
+    "jest-junit": "^15",
+    "jszip": "^3.10.1",
+    "mock-fs": "^5",
+    "prettier": "^2.8",
+    "projen": "^0.91.9",
+    "ts-jest": "^29.2.5",
+    "typescript": "5.6"
+  },
+  "dependencies": {
+    "@aws-cdk/cloud-assembly-schema": "^39.0.0",
+    "@aws-cdk/cx-api": "^2.178.2",
+    "@aws-sdk/client-ecr": "3.741",
+    "@aws-sdk/client-s3": "3.741",
+    "@aws-sdk/client-secrets-manager": "3.741",
+    "@aws-sdk/client-sts": "3.741",
+    "@aws-sdk/credential-providers": "^3.744.0",
+    "@aws-sdk/lib-storage": "^3.744.0",
+    "@smithy/config-resolver": "^4.0.1",
+    "@smithy/node-config-provider": "^4.0.1",
+    "archiver": "^7.0.1",
+    "glob": "^11.0.1",
+    "mime": "^2",
+    "yargs": "^17.7.2"
+  },
+  "keywords": [
+    "aws",
+    "cdk"
+  ],
+  "engines": {
+    "node": ">= 16.0.0"
+  },
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/aws/aws-cdk",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.0",
+  "types": "lib/index.d.ts",
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"npx projen\"."
+}

package/scripts/manual-test-manifest.json

@@ -0,0 +1,12 @@
+{
+  "version": "38.0.1",
+  "files": {
+    "asset1": {
+      "type": "file",
+      "source": { "path": "/Users/huijbers/Downloads/HEY-arm64.dmg" },
+      "destinations": {
+        "dest1": { "bucketName": "huijbers-test-objectlock", "objectKey": "hey.dmg" }
+      }
+    }
+  }
+}

package/scripts/manual-test.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+set -eu
+scriptdir=$(cd $(dirname $0) && pwd)
+
+path=$(realpath $1)
+
+cat <<EOF > $scriptdir/manual-test-manifest.json
+{
+  "version": "38.0.1",
+  "files": {
+    "asset1": {
+      "type": "file",
+      "source": { "path": "$path" },
+      "destinations": {
+        "dest1": { "bucketName": "$2", "objectKey": "$3" }
+      }
+    }
+  }
+}
+EOF
+
+npx ts-node $scriptdir/../bin/cdk-assets.ts -v -p $scriptdir/manual-test-manifest.json publish