aws-cdk 0.0.0

package/lib/util/work-graph-builder.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkGraphBuilder = void 0;
+const cxapi = require("@aws-cdk/cx-api");
+const cdk_assets_1 = require("cdk-assets");
+const content_hash_1 = require("./content-hash");
+const work_graph_1 = require("./work-graph");
+const work_graph_types_1 = require("./work-graph-types");
+const error_1 = require("../toolkit/error");
+class WorkGraphBuilder {
+    constructor(prebuildAssets, idPrefix = '') {
+        this.prebuildAssets = prebuildAssets;
+        this.idPrefix = idPrefix;
+        this.graph = new work_graph_1.WorkGraph();
+    }
+    addStack(artifact) {
+        this.graph.addNodes({
+            type: 'stack',
+            id: `${this.idPrefix}${artifact.id}`,
+            dependencies: new Set(this.stackArtifactIds(onlyStacks(artifact.dependencies))),
+            stack: artifact,
+            deploymentState: work_graph_types_1.DeploymentState.PENDING,
+            priority: WorkGraphBuilder.PRIORITIES.stack,
+        });
+    }
+    /**
+     * Oof, see this parameter list
+     */
+    // eslint-disable-next-line max-len
+    addAsset(parentStack, assetManifestArtifact, assetManifest, asset) {
+        // Just the artifact identifier
+        const assetId = asset.id.assetId;
+        const buildId = `build-${assetId}-${(0, content_hash_1.contentHashAny)([assetId, asset.genericSource]).substring(0, 10)}`;
+        const publishId = `publish-${assetId}-${(0, content_hash_1.contentHashAny)([assetId, asset.genericDestination]).substring(0, 10)}`;
+        // Build node only gets added once because they are all the same
+        if (!this.graph.tryGetNode(buildId)) {
+            const node = {
+                type: 'asset-build',
+                id: buildId,
+                note: assetId,
+                dependencies: new Set([
+                    ...this.stackArtifactIds(assetManifestArtifact.dependencies),
+                    // If we disable prebuild, then assets inherit (stack) dependencies from their parent stack
+                    ...!this.prebuildAssets ? this.stackArtifactIds(onlyStacks(parentStack.dependencies)) : [],
+                ]),
+                parentStack: parentStack,
+                assetManifestArtifact,
+                assetManifest,
+                asset,
+                deploymentState: work_graph_types_1.DeploymentState.PENDING,
+                priority: WorkGraphBuilder.PRIORITIES['asset-build'],
+            };
+            this.graph.addNodes(node);
+        }
+        const publishNode = this.graph.tryGetNode(publishId);
+        if (!publishNode) {
+            this.graph.addNodes({
+                type: 'asset-publish',
+                id: publishId,
+                note: `${asset.id}`,
+                dependencies: new Set([
+                    buildId,
+                ]),
+                parentStack,
+                assetManifestArtifact,
+                assetManifest,
+                asset,
+                deploymentState: work_graph_types_1.DeploymentState.PENDING,
+                priority: WorkGraphBuilder.PRIORITIES['asset-publish'],
+            });
+        }
+        for (const inheritedDep of this.stackArtifactIds(onlyStacks(parentStack.dependencies))) {
+            // The asset publish step also depends on the stacks that the parent depends on.
+            // This is purely cosmetic: if we don't do this, the progress printing of asset publishing
+            // is going to interfere with the progress bar of the stack deployment. We could remove this
+            // for overall faster deployments if we ever have a better method of progress displaying.
+            // Note: this may introduce a cycle if one of the parent's dependencies is another stack that
+            // depends on this asset. To workaround this we remove these cycles once all nodes have
+            // been added to the graph.
+            this.graph.addDependency(publishId, inheritedDep);
+        }
+        // This will work whether the stack node has been added yet or not
+        this.graph.addDependency(`${this.idPrefix}${parentStack.id}`, publishId);
+    }
+    build(artifacts) {
+        const parentStacks = stacksFromAssets(artifacts);
+        for (const artifact of artifacts) {
+            if (cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {
+                this.addStack(artifact);
+            }
+            else if (cxapi.AssetManifestArtifact.isAssetManifestArtifact(artifact)) {
+                const manifest = cdk_assets_1.AssetManifest.fromFile(artifact.file);
+                for (const entry of manifest.entries) {
+                    const parentStack = parentStacks.get(artifact);
+                    if (parentStack === undefined) {
+                        throw new error_1.ToolkitError('Found an asset manifest that is not associated with a stack');
+                    }
+                    this.addAsset(parentStack, artifact, manifest, entry);
+                }
+            }
+            else if (cxapi.NestedCloudAssemblyArtifact.isNestedCloudAssemblyArtifact(artifact)) {
+                const assembly = new cxapi.CloudAssembly(artifact.fullPath, { topoSort: false });
+                const nestedGraph = new WorkGraphBuilder(this.prebuildAssets, `${this.idPrefix}${artifact.id}.`).build(assembly.artifacts);
+                this.graph.absorb(nestedGraph);
+            }
+            else {
+                // Ignore whatever else
+            }
+        }
+        this.graph.removeUnavailableDependencies();
+        // Remove any potentially introduced cycles between asset publishing and the stacks that depend on them.
+        this.removeStackPublishCycles();
+        return this.graph;
+    }
+    stackArtifactIds(deps) {
+        return deps.flatMap((d) => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(d) ? [this.stackArtifactId(d)] : []);
+    }
+    stackArtifactId(artifact) {
+        if (!cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {
+            throw new error_1.ToolkitError(`Can only call this on CloudFormationStackArtifact, got: ${artifact.constructor.name}`);
+        }
+        return `${this.idPrefix}${artifact.id}`;
+    }
+    /**
+     * We may have accidentally introduced cycles in an attempt to make the messages printed to the
+     * console not interfere with each other too much. Remove them again.
+     */
+    removeStackPublishCycles() {
+        const publishSteps = this.graph.nodesOfType('asset-publish');
+        for (const publishStep of publishSteps) {
+            for (const dep of publishStep.dependencies) {
+                if (this.graph.reachable(dep, publishStep.id)) {
+                    publishStep.dependencies.delete(dep);
+                }
+            }
+        }
+    }
+}
+exports.WorkGraphBuilder = WorkGraphBuilder;
+/**
+ * Default priorities for nodes
+ *
+ * Assets builds have higher priority than the other two operations, to make good on our promise that
+ * '--prebuild-assets' will actually do assets before stacks (if it can). Unfortunately it is the
+ * default :(
+ *
+ * But between stack dependencies and publish dependencies, stack dependencies go first
+ */
+WorkGraphBuilder.PRIORITIES = {
+    'asset-build': 10,
+    'asset-publish': 0,
+    'stack': 5,
+};
+function stacksFromAssets(artifacts) {
+    const ret = new Map();
+    for (const stack of artifacts.filter(cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact)) {
+        const assetArtifacts = stack.dependencies.filter(cxapi.AssetManifestArtifact.isAssetManifestArtifact);
+        for (const art of assetArtifacts) {
+            ret.set(art, stack);
+        }
+    }
+    return ret;
+}
+function onlyStacks(artifacts) {
+    return artifacts.filter(cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"work-graph-builder.js","sourceRoot":"","sources":["work-graph-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport { AssetManifest, type IManifestEntry } from 'cdk-assets';\nimport { contentHashAny } from './content-hash';\nimport { WorkGraph } from './work-graph';\nimport { DeploymentState, AssetBuildNode, WorkNode } from './work-graph-types';\nimport { ToolkitError } from '../toolkit/error';\n\nexport class WorkGraphBuilder {\n  /**\n   * Default priorities for nodes\n   *\n   * Assets builds have higher priority than the other two operations, to make good on our promise that\n   * '--prebuild-assets' will actually do assets before stacks (if it can). Unfortunately it is the\n   * default :(\n   *\n   * But between stack dependencies and publish dependencies, stack dependencies go first\n   */\n  public static PRIORITIES: Record<WorkNode['type'], number> = {\n    'asset-build': 10,\n    'asset-publish': 0,\n    'stack': 5,\n  };\n  private readonly graph = new WorkGraph();\n\n  constructor(private readonly prebuildAssets: boolean, private readonly idPrefix = '') { }\n\n  private addStack(artifact: cxapi.CloudFormationStackArtifact) {\n    this.graph.addNodes({\n      type: 'stack',\n      id: `${this.idPrefix}${artifact.id}`,\n      dependencies: new Set(this.stackArtifactIds(onlyStacks(artifact.dependencies))),\n      stack: artifact,\n      deploymentState: DeploymentState.PENDING,\n      priority: WorkGraphBuilder.PRIORITIES.stack,\n    });\n  }\n\n  /**\n   * Oof, see this parameter list\n   */\n  // eslint-disable-next-line max-len\n  private addAsset(parentStack: cxapi.CloudFormationStackArtifact, assetManifestArtifact: cxapi.AssetManifestArtifact, assetManifest: AssetManifest, asset: IManifestEntry) {\n    // Just the artifact identifier\n    const assetId = asset.id.assetId;\n\n    const buildId = `build-${assetId}-${contentHashAny([assetId, asset.genericSource]).substring(0, 10)}`;\n    const publishId = `publish-${assetId}-${contentHashAny([assetId, asset.genericDestination]).substring(0, 10)}`;\n\n    // Build node only gets added once because they are all the same\n    if (!this.graph.tryGetNode(buildId)) {\n      const node: AssetBuildNode = {\n        type: 'asset-build',\n        id: buildId,\n        note: assetId,\n        dependencies: new Set([\n          ...this.stackArtifactIds(assetManifestArtifact.dependencies),\n          // If we disable prebuild, then assets inherit (stack) dependencies from their parent stack\n          ...!this.prebuildAssets ? this.stackArtifactIds(onlyStacks(parentStack.dependencies)) : [],\n        ]),\n        parentStack: parentStack,\n        assetManifestArtifact,\n        assetManifest,\n        asset,\n        deploymentState: DeploymentState.PENDING,\n        priority: WorkGraphBuilder.PRIORITIES['asset-build'],\n      };\n      this.graph.addNodes(node);\n    }\n\n    const publishNode = this.graph.tryGetNode(publishId);\n    if (!publishNode) {\n      this.graph.addNodes({\n        type: 'asset-publish',\n        id: publishId,\n        note: `${asset.id}`,\n        dependencies: new Set([\n          buildId,\n        ]),\n        parentStack,\n        assetManifestArtifact,\n        assetManifest,\n        asset,\n        deploymentState: DeploymentState.PENDING,\n        priority: WorkGraphBuilder.PRIORITIES['asset-publish'],\n      });\n    }\n\n    for (const inheritedDep of this.stackArtifactIds(onlyStacks(parentStack.dependencies))) {\n      // The asset publish step also depends on the stacks that the parent depends on.\n      // This is purely cosmetic: if we don't do this, the progress printing of asset publishing\n      // is going to interfere with the progress bar of the stack deployment. We could remove this\n      // for overall faster deployments if we ever have a better method of progress displaying.\n      // Note: this may introduce a cycle if one of the parent's dependencies is another stack that\n      // depends on this asset. To workaround this we remove these cycles once all nodes have\n      // been added to the graph.\n      this.graph.addDependency(publishId, inheritedDep);\n    }\n\n    // This will work whether the stack node has been added yet or not\n    this.graph.addDependency(`${this.idPrefix}${parentStack.id}`, publishId);\n  }\n\n  public build(artifacts: cxapi.CloudArtifact[]): WorkGraph {\n    const parentStacks = stacksFromAssets(artifacts);\n\n    for (const artifact of artifacts) {\n      if (cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {\n        this.addStack(artifact);\n      } else if (cxapi.AssetManifestArtifact.isAssetManifestArtifact(artifact)) {\n        const manifest = AssetManifest.fromFile(artifact.file);\n\n        for (const entry of manifest.entries) {\n          const parentStack = parentStacks.get(artifact);\n          if (parentStack === undefined) {\n            throw new ToolkitError('Found an asset manifest that is not associated with a stack');\n          }\n          this.addAsset(parentStack, artifact, manifest, entry);\n        }\n      } else if (cxapi.NestedCloudAssemblyArtifact.isNestedCloudAssemblyArtifact(artifact)) {\n        const assembly = new cxapi.CloudAssembly(artifact.fullPath, { topoSort: false });\n        const nestedGraph = new WorkGraphBuilder(this.prebuildAssets, `${this.idPrefix}${artifact.id}.`).build(assembly.artifacts);\n        this.graph.absorb(nestedGraph);\n      } else {\n        // Ignore whatever else\n      }\n    }\n\n    this.graph.removeUnavailableDependencies();\n\n    // Remove any potentially introduced cycles between asset publishing and the stacks that depend on them.\n    this.removeStackPublishCycles();\n\n    return this.graph;\n  }\n\n  private stackArtifactIds(deps: cxapi.CloudArtifact[]): string[] {\n    return deps.flatMap((d) => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(d) ? [this.stackArtifactId(d)] : []);\n  }\n\n  private stackArtifactId(artifact: cxapi.CloudArtifact): string {\n    if (!cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {\n      throw new ToolkitError(`Can only call this on CloudFormationStackArtifact, got: ${artifact.constructor.name}`);\n    }\n    return `${this.idPrefix}${artifact.id}`;\n  }\n\n  /**\n   * We may have accidentally introduced cycles in an attempt to make the messages printed to the\n   * console not interfere with each other too much. Remove them again.\n   */\n  private removeStackPublishCycles() {\n    const publishSteps = this.graph.nodesOfType('asset-publish');\n    for (const publishStep of publishSteps) {\n      for (const dep of publishStep.dependencies) {\n        if (this.graph.reachable(dep, publishStep.id)) {\n          publishStep.dependencies.delete(dep);\n        }\n      }\n    }\n  }\n}\n\nfunction stacksFromAssets(artifacts: cxapi.CloudArtifact[]) {\n  const ret = new Map<cxapi.AssetManifestArtifact, cxapi.CloudFormationStackArtifact>();\n  for (const stack of artifacts.filter(cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact)) {\n    const assetArtifacts = stack.dependencies.filter(cxapi.AssetManifestArtifact.isAssetManifestArtifact);\n    for (const art of assetArtifacts) {\n      ret.set(art, stack);\n    }\n  }\n\n  return ret;\n}\n\nfunction onlyStacks(artifacts: cxapi.CloudArtifact[]) {\n  return artifacts.filter(cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact);\n}\n"]}

package/lib/util/work-graph-types.d.ts

@@ -0,0 +1,50 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import { AssetManifest, type IManifestEntry } from 'cdk-assets';
+export declare enum DeploymentState {
+    PENDING = "pending",
+    QUEUED = "queued",
+    DEPLOYING = "deploying",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    SKIPPED = "skipped"
+}
+export type WorkNode = StackNode | AssetBuildNode | AssetPublishNode;
+export interface WorkNodeCommon {
+    readonly id: string;
+    readonly dependencies: Set<string>;
+    deploymentState: DeploymentState;
+    /** Some readable information to attach to the id, which may be unreadable */
+    readonly note?: string;
+}
+export interface StackNode extends WorkNodeCommon {
+    readonly type: 'stack';
+    readonly stack: cxapi.CloudFormationStackArtifact;
+    /** Sort by priority when picking up work, higher is earlier */
+    readonly priority?: number;
+}
+export interface AssetBuildNode extends WorkNodeCommon {
+    readonly type: 'asset-build';
+    /** The asset manifest this asset resides in (artifact) */
+    readonly assetManifestArtifact: cxapi.AssetManifestArtifact;
+    /** The asset manifest this asset resides in */
+    readonly assetManifest: AssetManifest;
+    /** The stack this asset was defined in (used for environment settings) */
+    readonly parentStack: cxapi.CloudFormationStackArtifact;
+    /** The asset that needs to be built */
+    readonly asset: IManifestEntry;
+    /** Sort by priority when picking up work, higher is earlier */
+    readonly priority?: number;
+}
+export interface AssetPublishNode extends WorkNodeCommon {
+    readonly type: 'asset-publish';
+    /** The asset manifest this asset resides in (artifact) */
+    readonly assetManifestArtifact: cxapi.AssetManifestArtifact;
+    /** The asset manifest this asset resides in */
+    readonly assetManifest: AssetManifest;
+    /** The stack this asset was defined in (used for environment settings) */
+    readonly parentStack: cxapi.CloudFormationStackArtifact;
+    /** The asset that needs to be published */
+    readonly asset: IManifestEntry;
+    /** Sort by priority when picking up work, higher is earlier */
+    readonly priority?: number;
+}

package/lib/util/work-graph-types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentState = void 0;
+var DeploymentState;
+(function (DeploymentState) {
+    DeploymentState["PENDING"] = "pending";
+    DeploymentState["QUEUED"] = "queued";
+    DeploymentState["DEPLOYING"] = "deploying";
+    DeploymentState["COMPLETED"] = "completed";
+    DeploymentState["FAILED"] = "failed";
+    DeploymentState["SKIPPED"] = "skipped";
+})(DeploymentState || (exports.DeploymentState = DeploymentState = {}));
+;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util/work-graph.d.ts

@@ -0,0 +1,70 @@
+import { WorkNode, StackNode, AssetBuildNode, AssetPublishNode } from './work-graph-types';
+export type Concurrency = number | Record<WorkNode['type'], number>;
+export declare class WorkGraph {
+    readonly nodes: Record<string, WorkNode>;
+    private readonly readyPool;
+    private readonly lazyDependencies;
+    error?: Error;
+    constructor(nodes?: Record<string, WorkNode>);
+    addNodes(...nodes: WorkNode[]): void;
+    removeNode(nodeId: string | WorkNode): void;
+    /**
+     * Return all nodes of a given type
+     */
+    nodesOfType<T extends WorkNode['type']>(type: T): Extract<WorkNode, {
+        type: T;
+    }>[];
+    /**
+     * Return all nodes that depend on a given node
+     */
+    dependees(nodeId: string | WorkNode): WorkNode[];
+    /**
+     * Add a dependency, that may come before or after the nodes involved
+     */
+    addDependency(fromId: string, toId: string): void;
+    tryGetNode(id: string): WorkNode | undefined;
+    node(id: string): WorkNode;
+    absorb(graph: WorkGraph): void;
+    private hasFailed;
+    doParallel(concurrency: Concurrency, actions: WorkGraphActions): Promise<void>;
+    /**
+     * Return the set of unblocked nodes
+     */
+    ready(): ReadonlyArray<WorkNode>;
+    private forAllArtifacts;
+    private done;
+    private deployed;
+    private failed;
+    toString(): string;
+    /**
+     * Ensure all dependencies actually exist. This protects against scenarios such as the following:
+     * StackA depends on StackB, but StackB is not selected to deploy. The dependency is redundant
+     * and will be dropped.
+     * This assumes the manifest comes uncorrupted so we will not fail if a dependency is not found.
+     */
+    removeUnavailableDependencies(): void;
+    /**
+     * Remove all asset publishing steps for assets that are already published, and then build
+     * that aren't used anymore.
+     *
+     * Do this in parallel, because there may be a lot of assets in an application (seen in practice: >100 assets)
+     */
+    removeUnnecessaryAssets(isUnnecessary: (x: AssetPublishNode) => Promise<boolean>): Promise<void>;
+    private updateReadyPool;
+    private skipRest;
+    /**
+     * Find cycles in a graph
+     *
+     * Not the fastest, but effective and should be rare
+     */
+    findCycle(): string[] | undefined;
+    /**
+     * Whether the `end` node is reachable from the `start` node, following the dependency arrows
+     */
+    reachable(start: string, end: string): boolean;
+}
+export interface WorkGraphActions {
+    deployStack: (stackNode: StackNode) => Promise<void>;
+    buildAsset: (assetNode: AssetBuildNode) => Promise<void>;
+    publishAsset: (assetNode: AssetPublishNode) => Promise<void>;
+}