@aws-cdk/toolkit-lib 0.3.2 → 0.3.3

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

@@ -0,0 +1,72 @@
+import type { WorkNode, StackNode, AssetBuildNode, AssetPublishNode } from './work-graph-types';
+import { type IoHelper } from '../io/private';
+export type Concurrency = number | Record<WorkNode['type'], number>;
+export declare class WorkGraph {
+    readonly nodes: Record<string, WorkNode>;
+    private readonly readyPool;
+    private readonly lazyDependencies;
+    private readonly ioHelper;
+    error?: Error;
+    constructor(nodes: Record<string, WorkNode>, ioHelper: IoHelper);
+    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(): Promise<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>;
+}

package/lib/api/work-graph/work-graph.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkGraph = void 0;
+const work_graph_types_1 = require("./work-graph-types");
+const util_1 = require("../../util");
+const private_1 = require("../io/private");
+const toolkit_error_1 = require("../toolkit-error");
+class WorkGraph {
+    nodes;
+    readyPool = [];
+    lazyDependencies = new Map();
+    ioHelper;
+    error;
+    constructor(nodes, ioHelper) {
+        this.nodes = { ...nodes };
+        this.ioHelper = ioHelper;
+    }
+    addNodes(...nodes) {
+        for (const node of nodes) {
+            if (this.nodes[node.id]) {
+                throw new toolkit_error_1.ToolkitError(`Duplicate use of node id: ${node.id}`);
+            }
+            const ld = this.lazyDependencies.get(node.id);
+            if (ld) {
+                for (const x of ld) {
+                    node.dependencies.add(x);
+                }
+                this.lazyDependencies.delete(node.id);
+            }
+            this.nodes[node.id] = node;
+        }
+    }
+    removeNode(nodeId) {
+        const id = typeof nodeId === 'string' ? nodeId : nodeId.id;
+        const removedNode = this.nodes[id];
+        this.lazyDependencies.delete(id);
+        delete this.nodes[id];
+        if (removedNode) {
+            for (const node of Object.values(this.nodes)) {
+                node.dependencies.delete(removedNode.id);
+            }
+        }
+    }
+    /**
+     * Return all nodes of a given type
+     */
+    nodesOfType(type) {
+        return Object.values(this.nodes).filter(n => n.type === type);
+    }
+    /**
+     * Return all nodes that depend on a given node
+     */
+    dependees(nodeId) {
+        const id = typeof nodeId === 'string' ? nodeId : nodeId.id;
+        return Object.values(this.nodes).filter(n => n.dependencies.has(id));
+    }
+    /**
+     * Add a dependency, that may come before or after the nodes involved
+     */
+    addDependency(fromId, toId) {
+        const node = this.nodes[fromId];
+        if (node) {
+            node.dependencies.add(toId);
+            return;
+        }
+        let lazyDeps = this.lazyDependencies.get(fromId);
+        if (!lazyDeps) {
+            lazyDeps = [];
+            this.lazyDependencies.set(fromId, lazyDeps);
+        }
+        lazyDeps.push(toId);
+    }
+    tryGetNode(id) {
+        return this.nodes[id];
+    }
+    node(id) {
+        const ret = this.nodes[id];
+        if (!ret) {
+            throw new toolkit_error_1.ToolkitError(`No node with id ${id} among ${Object.keys(this.nodes)}`);
+        }
+        return ret;
+    }
+    absorb(graph) {
+        this.addNodes(...Object.values(graph.nodes));
+    }
+    hasFailed() {
+        return Object.values(this.nodes).some((n) => n.deploymentState === work_graph_types_1.DeploymentState.FAILED);
+    }
+    doParallel(concurrency, actions) {
+        return this.forAllArtifacts(concurrency, async (x) => {
+            switch (x.type) {
+                case 'stack':
+                    await actions.deployStack(x);
+                    break;
+                case 'asset-build':
+                    await actions.buildAsset(x);
+                    break;
+                case 'asset-publish':
+                    await actions.publishAsset(x);
+                    break;
+            }
+        });
+    }
+    /**
+     * Return the set of unblocked nodes
+     */
+    async ready() {
+        await this.updateReadyPool();
+        return this.readyPool;
+    }
+    forAllArtifacts(n, fn) {
+        const graph = this;
+        // If 'n' is a number, we limit all concurrency equally (effectively we will be using totalMax)
+        // If 'n' is a record, we limit each job independently (effectively we will be using max)
+        const max = typeof n === 'number' ?
+            {
+                'asset-build': n,
+                'asset-publish': n,
+                'stack': n,
+            } : n;
+        const totalMax = typeof n === 'number' ? n : sum(Object.values(n));
+        return new Promise((ok, fail) => {
+            let active = {
+                'asset-build': 0,
+                'asset-publish': 0,
+                'stack': 0,
+            };
+            function totalActive() {
+                return sum(Object.values(active));
+            }
+            start();
+            function start() {
+                graph.updateReadyPool().then(() => {
+                    for (let i = 0; i < graph.readyPool.length;) {
+                        const node = graph.readyPool[i];
+                        if (active[node.type] < max[node.type] && totalActive() < totalMax) {
+                            graph.readyPool.splice(i, 1);
+                            startOne(node);
+                        }
+                        else {
+                            i += 1;
+                        }
+                    }
+                    if (totalActive() === 0) {
+                        if (graph.done()) {
+                            ok();
+                        }
+                        // wait for other active deploys to finish before failing
+                        if (graph.hasFailed()) {
+                            fail(graph.error);
+                        }
+                    }
+                }).catch((e) => {
+                    fail(e);
+                });
+            }
+            function startOne(x) {
+                x.deploymentState = work_graph_types_1.DeploymentState.DEPLOYING;
+                active[x.type]++;
+                void fn(x)
+                    .finally(() => {
+                    active[x.type]--;
+                })
+                    .then(() => {
+                    graph.deployed(x);
+                    start();
+                }).catch((err) => {
+                    // By recording the failure immediately as the queued task exits, we prevent the next
+                    // queued task from starting.
+                    graph.failed(x, err);
+                    start();
+                });
+            }
+        });
+    }
+    done() {
+        return Object.values(this.nodes).every((n) => work_graph_types_1.DeploymentState.COMPLETED === n.deploymentState);
+    }
+    deployed(node) {
+        node.deploymentState = work_graph_types_1.DeploymentState.COMPLETED;
+    }
+    failed(node, error) {
+        this.error = error;
+        node.deploymentState = work_graph_types_1.DeploymentState.FAILED;
+        this.skipRest();
+        this.readyPool.splice(0);
+    }
+    toString() {
+        return [
+            'digraph D {',
+            ...Object.entries(this.nodes).flatMap(([id, node]) => renderNode(id, node)),
+            '}',
+        ].join('\n');
+        function renderNode(id, node) {
+            const ret = [];
+            if (node.deploymentState === work_graph_types_1.DeploymentState.COMPLETED) {
+                ret.push(`  ${gv(id, { style: 'filled', fillcolor: 'yellow', comment: node.note })};`);
+            }
+            else {
+                ret.push(`  ${gv(id, { comment: node.note })};`);
+            }
+            for (const dep of node.dependencies) {
+                ret.push(`  ${gv(id)} -> ${gv(dep)};`);
+            }
+            return ret;
+        }
+    }
+    /**
+     * 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() {
+        for (const node of Object.values(this.nodes)) {
+            const removeDeps = Array.from(node.dependencies).filter((dep) => this.nodes[dep] === undefined);
+            removeDeps.forEach((d) => {
+                node.dependencies.delete(d);
+            });
+        }
+    }
+    /**
+     * 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)
+     */
+    async removeUnnecessaryAssets(isUnnecessary) {
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg('Checking for previously published assets'));
+        const publishes = this.nodesOfType('asset-publish');
+        const classifiedNodes = await (0, util_1.parallelPromises)(8, publishes.map((assetNode) => async () => [assetNode, await isUnnecessary(assetNode)]));
+        const alreadyPublished = classifiedNodes.filter(([_, unnecessary]) => unnecessary).map(([assetNode, _]) => assetNode);
+        for (const assetNode of alreadyPublished) {
+            this.removeNode(assetNode);
+        }
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${publishes.length} total assets, ${publishes.length - alreadyPublished.length} still need to be published`));
+        // Now also remove any asset build steps that don't have any dependencies on them anymore
+        const unusedBuilds = this.nodesOfType('asset-build').filter(build => this.dependees(build).length === 0);
+        for (const unusedBuild of unusedBuilds) {
+            this.removeNode(unusedBuild);
+        }
+    }
+    async updateReadyPool() {
+        const activeCount = Object.values(this.nodes).filter((x) => x.deploymentState === work_graph_types_1.DeploymentState.DEPLOYING).length;
+        const pendingCount = Object.values(this.nodes).filter((x) => x.deploymentState === work_graph_types_1.DeploymentState.PENDING).length;
+        const newlyReady = Object.values(this.nodes).filter((x) => x.deploymentState === work_graph_types_1.DeploymentState.PENDING &&
+            Array.from(x.dependencies).every((id) => this.node(id).deploymentState === work_graph_types_1.DeploymentState.COMPLETED));
+        // Add newly available nodes to the ready pool
+        for (const node of newlyReady) {
+            node.deploymentState = work_graph_types_1.DeploymentState.QUEUED;
+            this.readyPool.push(node);
+        }
+        // Remove nodes from the ready pool that have already started deploying
+        retainOnly(this.readyPool, (node) => node.deploymentState === work_graph_types_1.DeploymentState.QUEUED);
+        // Sort by reverse priority
+        this.readyPool.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        if (this.readyPool.length === 0 && activeCount === 0 && pendingCount > 0) {
+            const cycle = this.findCycle() ?? ['No cycle found!'];
+            await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_TRACE.msg(`Cycle ${cycle.join(' -> ')} in graph ${this}`));
+            throw new toolkit_error_1.ToolkitError(`Unable to make progress anymore, dependency cycle between remaining artifacts: ${cycle.join(' -> ')} (run with -vv for full graph)`);
+        }
+    }
+    skipRest() {
+        for (const node of Object.values(this.nodes)) {
+            if ([work_graph_types_1.DeploymentState.QUEUED, work_graph_types_1.DeploymentState.PENDING].includes(node.deploymentState)) {
+                node.deploymentState = work_graph_types_1.DeploymentState.SKIPPED;
+            }
+        }
+    }
+    /**
+     * Find cycles in a graph
+     *
+     * Not the fastest, but effective and should be rare
+     */
+    findCycle() {
+        const seen = new Set();
+        const self = this;
+        for (const nodeId of Object.keys(this.nodes)) {
+            const cycle = recurse(nodeId, [nodeId]);
+            if (cycle) {
+                return cycle;
+            }
+        }
+        return undefined;
+        function recurse(nodeId, path) {
+            if (seen.has(nodeId)) {
+                return undefined;
+            }
+            try {
+                for (const dep of self.nodes[nodeId].dependencies ?? []) {
+                    const index = path.indexOf(dep);
+                    if (index > -1) {
+                        return [...path.slice(index), dep];
+                    }
+                    const cycle = recurse(dep, [...path, dep]);
+                    if (cycle) {
+                        return cycle;
+                    }
+                }
+                return undefined;
+            }
+            finally {
+                seen.add(nodeId);
+            }
+        }
+    }
+    /**
+     * Whether the `end` node is reachable from the `start` node, following the dependency arrows
+     */
+    reachable(start, end) {
+        const seen = new Set();
+        const self = this;
+        return recurse(start);
+        function recurse(current) {
+            if (seen.has(current)) {
+                return false;
+            }
+            seen.add(current);
+            if (current === end) {
+                return true;
+            }
+            for (const dep of self.nodes[current].dependencies) {
+                if (recurse(dep)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}
+exports.WorkGraph = WorkGraph;
+function sum(xs) {
+    let ret = 0;
+    for (const x of xs) {
+        ret += x;
+    }
+    return ret;
+}
+function retainOnly(xs, pred) {
+    xs.splice(0, xs.length, ...xs.filter(pred));
+}
+function gv(id, attrs) {
+    const attrString = Object.entries(attrs ?? {}).flatMap(([k, v]) => v !== undefined ? [`${k}="${v}"`] : []).join(',');
+    return attrString ? `"${simplifyId(id)}" [${attrString}]` : `"${simplifyId(id)}"`;
+}
+function simplifyId(id) {
+    return id.replace(/([0-9a-f]{6})[0-9a-f]{6,}/g, '$1');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"work-graph.js","sourceRoot":"","sources":["work-graph.ts"],"names":[],"mappings":"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","sourcesContent":["import type { WorkNode, StackNode, AssetBuildNode, AssetPublishNode } from './work-graph-types';\nimport { DeploymentState } from './work-graph-types';\nimport { parallelPromises } from '../../util';\nimport { IO, type IoHelper } from '../io/private';\nimport { ToolkitError } from '../toolkit-error';\nexport type Concurrency = number | Record<WorkNode['type'], number>;\n\nexport class WorkGraph {\n  public readonly nodes: Record<string, WorkNode>;\n  private readonly readyPool: Array<WorkNode> = [];\n  private readonly lazyDependencies = new Map<string, string[]>();\n  private readonly ioHelper: IoHelper;\n\n  public error?: Error;\n\n  public constructor(nodes: Record<string, WorkNode>, ioHelper: IoHelper) {\n    this.nodes = { ...nodes };\n    this.ioHelper = ioHelper;\n  }\n\n  public addNodes(...nodes: WorkNode[]) {\n    for (const node of nodes) {\n      if (this.nodes[node.id]) {\n        throw new ToolkitError(`Duplicate use of node id: ${node.id}`);\n      }\n\n      const ld = this.lazyDependencies.get(node.id);\n      if (ld) {\n        for (const x of ld) {\n          node.dependencies.add(x);\n        }\n        this.lazyDependencies.delete(node.id);\n      }\n\n      this.nodes[node.id] = node;\n    }\n  }\n\n  public removeNode(nodeId: string | WorkNode) {\n    const id = typeof nodeId === 'string' ? nodeId : nodeId.id;\n    const removedNode = this.nodes[id];\n\n    this.lazyDependencies.delete(id);\n    delete this.nodes[id];\n\n    if (removedNode) {\n      for (const node of Object.values(this.nodes)) {\n        node.dependencies.delete(removedNode.id);\n      }\n    }\n  }\n\n  /**\n   * Return all nodes of a given type\n   */\n  public nodesOfType<T extends WorkNode['type']>(type: T): Extract<WorkNode, { type: T }>[] {\n    return Object.values(this.nodes).filter(n => n.type === type) as any;\n  }\n\n  /**\n   * Return all nodes that depend on a given node\n   */\n  public dependees(nodeId: string | WorkNode) {\n    const id = typeof nodeId === 'string' ? nodeId : nodeId.id;\n    return Object.values(this.nodes).filter(n => n.dependencies.has(id));\n  }\n\n  /**\n   * Add a dependency, that may come before or after the nodes involved\n   */\n  public addDependency(fromId: string, toId: string) {\n    const node = this.nodes[fromId];\n    if (node) {\n      node.dependencies.add(toId);\n      return;\n    }\n    let lazyDeps = this.lazyDependencies.get(fromId);\n    if (!lazyDeps) {\n      lazyDeps = [];\n      this.lazyDependencies.set(fromId, lazyDeps);\n    }\n    lazyDeps.push(toId);\n  }\n\n  public tryGetNode(id: string): WorkNode | undefined {\n    return this.nodes[id];\n  }\n\n  public node(id: string) {\n    const ret = this.nodes[id];\n    if (!ret) {\n      throw new ToolkitError(`No node with id ${id} among ${Object.keys(this.nodes)}`);\n    }\n    return ret;\n  }\n\n  public absorb(graph: WorkGraph) {\n    this.addNodes(...Object.values(graph.nodes));\n  }\n\n  private hasFailed(): boolean {\n    return Object.values(this.nodes).some((n) => n.deploymentState === DeploymentState.FAILED);\n  }\n\n  public doParallel(concurrency: Concurrency, actions: WorkGraphActions) {\n    return this.forAllArtifacts(concurrency, async (x: WorkNode) => {\n      switch (x.type) {\n        case 'stack':\n          await actions.deployStack(x);\n          break;\n        case 'asset-build':\n          await actions.buildAsset(x);\n          break;\n        case 'asset-publish':\n          await actions.publishAsset(x);\n          break;\n      }\n    });\n  }\n\n  /**\n   * Return the set of unblocked nodes\n   */\n  public async ready(): Promise<ReadonlyArray<WorkNode>> {\n    await this.updateReadyPool();\n    return this.readyPool;\n  }\n\n  private forAllArtifacts(n: Concurrency, fn: (x: WorkNode) => Promise<void>): Promise<void> {\n    const graph = this;\n\n    // If 'n' is a number, we limit all concurrency equally (effectively we will be using totalMax)\n    // If 'n' is a record, we limit each job independently (effectively we will be using max)\n    const max: Record<WorkNode['type'], number> = typeof n === 'number' ?\n      {\n        'asset-build': n,\n        'asset-publish': n,\n        'stack': n,\n      } : n;\n    const totalMax = typeof n === 'number' ? n : sum(Object.values(n));\n\n    return new Promise((ok, fail) => {\n      let active: Record<WorkNode['type'], number> = {\n        'asset-build': 0,\n        'asset-publish': 0,\n        'stack': 0,\n      };\n      function totalActive() {\n        return sum(Object.values(active));\n      }\n\n      start();\n\n      function start() {\n        graph.updateReadyPool().then(() => {\n          for (let i = 0; i < graph.readyPool.length; ) {\n            const node = graph.readyPool[i];\n\n            if (active[node.type] < max[node.type] && totalActive() < totalMax) {\n              graph.readyPool.splice(i, 1);\n              startOne(node);\n            } else {\n              i += 1;\n            }\n          }\n\n          if (totalActive() === 0) {\n            if (graph.done()) {\n              ok();\n            }\n            // wait for other active deploys to finish before failing\n            if (graph.hasFailed()) {\n              fail(graph.error);\n            }\n          }\n        }).catch((e) => {\n          fail(e);\n        });\n      }\n\n      function startOne(x: WorkNode) {\n        x.deploymentState = DeploymentState.DEPLOYING;\n        active[x.type]++;\n        void fn(x)\n          .finally(() => {\n            active[x.type]--;\n          })\n          .then(() => {\n            graph.deployed(x);\n            start();\n          }).catch((err) => {\n            // By recording the failure immediately as the queued task exits, we prevent the next\n            // queued task from starting.\n            graph.failed(x, err);\n            start();\n          });\n      }\n    });\n  }\n\n  private done(): boolean {\n    return Object.values(this.nodes).every((n) => DeploymentState.COMPLETED === n.deploymentState);\n  }\n\n  private deployed(node: WorkNode) {\n    node.deploymentState = DeploymentState.COMPLETED;\n  }\n\n  private failed(node: WorkNode, error?: Error) {\n    this.error = error;\n    node.deploymentState = DeploymentState.FAILED;\n    this.skipRest();\n    this.readyPool.splice(0);\n  }\n\n  public toString() {\n    return [\n      'digraph D {',\n      ...Object.entries(this.nodes).flatMap(([id, node]) => renderNode(id, node)),\n      '}',\n    ].join('\\n');\n\n    function renderNode(id: string, node: WorkNode): string[] {\n      const ret = [];\n      if (node.deploymentState === DeploymentState.COMPLETED) {\n        ret.push(`  ${gv(id, { style: 'filled', fillcolor: 'yellow', comment: node.note })};`);\n      } else {\n        ret.push(`  ${gv(id, { comment: node.note })};`);\n      }\n      for (const dep of node.dependencies) {\n        ret.push(`  ${gv(id)} -> ${gv(dep)};`);\n      }\n      return ret;\n    }\n  }\n\n  /**\n   * Ensure all dependencies actually exist. This protects against scenarios such as the following:\n   * StackA depends on StackB, but StackB is not selected to deploy. The dependency is redundant\n   * and will be dropped.\n   * This assumes the manifest comes uncorrupted so we will not fail if a dependency is not found.\n   */\n  public removeUnavailableDependencies() {\n    for (const node of Object.values(this.nodes)) {\n      const removeDeps = Array.from(node.dependencies).filter((dep) => this.nodes[dep] === undefined);\n\n      removeDeps.forEach((d) => {\n        node.dependencies.delete(d);\n      });\n    }\n  }\n\n  /**\n   * Remove all asset publishing steps for assets that are already published, and then build\n   * that aren't used anymore.\n   *\n   * Do this in parallel, because there may be a lot of assets in an application (seen in practice: >100 assets)\n   */\n  public async removeUnnecessaryAssets(isUnnecessary: (x: AssetPublishNode) => Promise<boolean>) {\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg('Checking for previously published assets'));\n\n    const publishes = this.nodesOfType('asset-publish');\n\n    const classifiedNodes = await parallelPromises(\n      8,\n      publishes.map((assetNode) => async() => [assetNode, await isUnnecessary(assetNode)] as const));\n\n    const alreadyPublished = classifiedNodes.filter(([_, unnecessary]) => unnecessary).map(([assetNode, _]) => assetNode);\n    for (const assetNode of alreadyPublished) {\n      this.removeNode(assetNode);\n    }\n\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${publishes.length} total assets, ${publishes.length - alreadyPublished.length} still need to be published`));\n\n    // Now also remove any asset build steps that don't have any dependencies on them anymore\n    const unusedBuilds = this.nodesOfType('asset-build').filter(build => this.dependees(build).length === 0);\n    for (const unusedBuild of unusedBuilds) {\n      this.removeNode(unusedBuild);\n    }\n  }\n\n  private async updateReadyPool() {\n    const activeCount = Object.values(this.nodes).filter((x) => x.deploymentState === DeploymentState.DEPLOYING).length;\n    const pendingCount = Object.values(this.nodes).filter((x) => x.deploymentState === DeploymentState.PENDING).length;\n\n    const newlyReady = Object.values(this.nodes).filter((x) =>\n      x.deploymentState === DeploymentState.PENDING &&\n      Array.from(x.dependencies).every((id) => this.node(id).deploymentState === DeploymentState.COMPLETED));\n\n    // Add newly available nodes to the ready pool\n    for (const node of newlyReady) {\n      node.deploymentState = DeploymentState.QUEUED;\n      this.readyPool.push(node);\n    }\n\n    // Remove nodes from the ready pool that have already started deploying\n    retainOnly(this.readyPool, (node) => node.deploymentState === DeploymentState.QUEUED);\n\n    // Sort by reverse priority\n    this.readyPool.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));\n\n    if (this.readyPool.length === 0 && activeCount === 0 && pendingCount > 0) {\n      const cycle = this.findCycle() ?? ['No cycle found!'];\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_TRACE.msg(`Cycle ${cycle.join(' -> ')} in graph ${this}`));\n      throw new ToolkitError(`Unable to make progress anymore, dependency cycle between remaining artifacts: ${cycle.join(' -> ')} (run with -vv for full graph)`);\n    }\n  }\n\n  private skipRest() {\n    for (const node of Object.values(this.nodes)) {\n      if ([DeploymentState.QUEUED, DeploymentState.PENDING].includes(node.deploymentState)) {\n        node.deploymentState = DeploymentState.SKIPPED;\n      }\n    }\n  }\n\n  /**\n   * Find cycles in a graph\n   *\n   * Not the fastest, but effective and should be rare\n   */\n  public findCycle(): string[] | undefined {\n    const seen = new Set<string>();\n    const self = this;\n    for (const nodeId of Object.keys(this.nodes)) {\n      const cycle = recurse(nodeId, [nodeId]);\n      if (cycle) {\n        return cycle;\n      }\n    }\n    return undefined;\n\n    function recurse(nodeId: string, path: string[]): string[] | undefined {\n      if (seen.has(nodeId)) {\n        return undefined;\n      }\n      try {\n        for (const dep of self.nodes[nodeId].dependencies ?? []) {\n          const index = path.indexOf(dep);\n          if (index > -1) {\n            return [...path.slice(index), dep];\n          }\n\n          const cycle = recurse(dep, [...path, dep]);\n          if (cycle) {\n            return cycle;\n          }\n        }\n\n        return undefined;\n      } finally {\n        seen.add(nodeId);\n      }\n    }\n  }\n\n  /**\n   * Whether the `end` node is reachable from the `start` node, following the dependency arrows\n   */\n  public reachable(start: string, end: string): boolean {\n    const seen = new Set<string>();\n    const self = this;\n    return recurse(start);\n\n    function recurse(current: string) {\n      if (seen.has(current)) {\n        return false;\n      }\n      seen.add(current);\n\n      if (current === end) {\n        return true;\n      }\n      for (const dep of self.nodes[current].dependencies) {\n        if (recurse(dep)) {\n          return true;\n        }\n      }\n      return false;\n    }\n  }\n}\n\nexport interface WorkGraphActions {\n  deployStack: (stackNode: StackNode) => Promise<void>;\n  buildAsset: (assetNode: AssetBuildNode) => Promise<void>;\n  publishAsset: (assetNode: AssetPublishNode) => Promise<void>;\n}\n\nfunction sum(xs: number[]) {\n  let ret = 0;\n  for (const x of xs) {\n    ret += x;\n  }\n  return ret;\n}\n\nfunction retainOnly<A>(xs: A[], pred: (x: A) => boolean) {\n  xs.splice(0, xs.length, ...xs.filter(pred));\n}\n\nfunction gv(id: string, attrs?: Record<string, string | undefined>) {\n  const attrString = Object.entries(attrs ?? {}).flatMap(([k, v]) => v !== undefined ? [`${k}=\"${v}\"`] : []).join(',');\n\n  return attrString ? `\"${simplifyId(id)}\" [${attrString}]` : `\"${simplifyId(id)}\"`;\n}\n\nfunction simplifyId(id: string) {\n  return id.replace(/([0-9a-f]{6})[0-9a-f]{6,}/g, '$1');\n}\n"]}

package/lib/context-providers/ami.d.ts

@@ -0,0 +1,13 @@
+import type { AmiContextQuery } from '@aws-cdk/cloud-assembly-schema';
+import type { IContextProviderMessages } from '.';
+import { type SdkProvider } from '../api/aws-auth/private';
+import type { ContextProviderPlugin } from '../api/plugin';
+/**
+ * Plugin to search AMIs for the current account
+ */
+export declare class AmiContextProviderPlugin implements ContextProviderPlugin {
+    private readonly aws;
+    private readonly io;
+    constructor(aws: SdkProvider, io: IContextProviderMessages);
+    getValue(args: AmiContextQuery): Promise<string>;
+}

package/lib/context-providers/ami.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmiContextProviderPlugin = void 0;
+const private_1 = require("../api/aws-auth/private");
+const toolkit_error_1 = require("../api/toolkit-error");
+/**
+ * Plugin to search AMIs for the current account
+ */
+class AmiContextProviderPlugin {
+    aws;
+    io;
+    constructor(aws, io) {
+        this.aws = aws;
+        this.io = io;
+    }
+    async getValue(args) {
+        const region = args.region;
+        const account = args.account;
+        // Normally we'd do this only as 'debug', but searching AMIs typically takes dozens
+        // of seconds, so be little more verbose about it so users know what is going on.
+        await this.io.info(`Searching for AMI in ${account}:${region}`);
+        await this.io.debug(`AMI search parameters: ${JSON.stringify(args)}`);
+        const ec2 = (await (0, private_1.initContextProviderSdk)(this.aws, args)).ec2();
+        const response = await ec2.describeImages({
+            Owners: args.owners,
+            Filters: Object.entries(args.filters).map(([key, values]) => ({
+                Name: key,
+                Values: values,
+            })),
+        });
+        const images = [...(response.Images || [])].filter((i) => i.ImageId !== undefined);
+        if (images.length === 0) {
+            throw new toolkit_error_1.ContextProviderError('No AMI found that matched the search criteria');
+        }
+        // Return the most recent one
+        // Note: Date.parse() is not going to respect the timezone of the string,
+        // but since we only care about the relative values that is okay.
+        images.sort(descending((i) => Date.parse(i.CreationDate || '1970')));
+        await this.io.debug(`Selected image '${images[0].ImageId}' created at '${images[0].CreationDate}'`);
+        return images[0].ImageId;
+    }
+}
+exports.AmiContextProviderPlugin = AmiContextProviderPlugin;
+/**
+ * Make a comparator that sorts in descending order given a sort key extractor
+ */
+function descending(valueOf) {
+    return (a, b) => {
+        return valueOf(b) - valueOf(a);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/context-providers/availability-zones.d.ts

@@ -0,0 +1,13 @@
+import type { AvailabilityZonesContextQuery } from '@aws-cdk/cloud-assembly-schema';
+import type { IContextProviderMessages } from '.';
+import { type SdkProvider } from '../api/aws-auth/private';
+import type { ContextProviderPlugin } from '../api/plugin';
+/**
+ * Plugin to retrieve the Availability Zones for the current account
+ */
+export declare class AZContextProviderPlugin implements ContextProviderPlugin {
+    private readonly aws;
+    private readonly io;
+    constructor(aws: SdkProvider, io: IContextProviderMessages);
+    getValue(args: AvailabilityZonesContextQuery): Promise<(string | undefined)[]>;
+}

package/lib/context-providers/availability-zones.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AZContextProviderPlugin = void 0;
+const private_1 = require("../api/aws-auth/private");
+/**
+ * Plugin to retrieve the Availability Zones for the current account
+ */
+class AZContextProviderPlugin {
+    aws;
+    io;
+    constructor(aws, io) {
+        this.aws = aws;
+        this.io = io;
+    }
+    async getValue(args) {
+        const region = args.region;
+        const account = args.account;
+        await this.io.debug(`Reading AZs for ${account}:${region}`);
+        const ec2 = (await (0, private_1.initContextProviderSdk)(this.aws, args)).ec2();
+        const response = await ec2.describeAvailabilityZones({});
+        if (!response.AvailabilityZones) {
+            return [];
+        }
+        const azs = response.AvailabilityZones.filter((zone) => zone.State === 'available').map((zone) => zone.ZoneName);
+        return azs;
+    }
+}
+exports.AZContextProviderPlugin = AZContextProviderPlugin;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/context-providers/cc-api-provider.d.ts

@@ -0,0 +1,30 @@
+import type { CcApiContextQuery } from '@aws-cdk/cloud-assembly-schema';
+import type { SdkProvider } from '../api/aws-auth/private';
+import type { ContextProviderPlugin } from '../api/plugin';
+export declare class CcApiContextProviderPlugin implements ContextProviderPlugin {
+    private readonly aws;
+    constructor(aws: SdkProvider);
+    /**
+     * This returns a data object with the value from CloudControl API result.
+     *
+     * See the documentation in the Cloud Assembly Schema for the semantics of
+     * each query parameter.
+     */
+    getValue(args: CcApiContextQuery): Promise<any>;
+    /**
+     * Calls getResource from CC API to get the resource.
+     * See https://docs.aws.amazon.com/cli/latest/reference/cloudcontrol/get-resource.html
+     *
+     * Will always return exactly one resource, or fail.
+     */
+    private getResource;
+    /**
+     * Calls listResources from CC API to get the resources and apply args.propertyMatch to find the resources.
+     * See https://docs.aws.amazon.com/cli/latest/reference/cloudcontrol/list-resources.html
+     *
+     * Will return 0 or more resources.
+     *
+     * Does not currently paginate through more than one result page.
+     */
+    private listResources;
+}