@aws-cdk/core/lib/asset-staging.js

"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.AssetStaging = void 0;
const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const crypto = require("crypto");
const os = require("os");
const path = require("path");
const cxapi = require("@aws-cdk/cx-api");
const fs = require("fs-extra");
const assets_1 = require("./assets");
const bundling_1 = require("./bundling");
const fs_1 = require("./fs");
const names_1 = require("./names");
const cache_1 = require("./private/cache");
const stack_1 = require("./stack");
const stage_1 = require("./stage");
// v2 - keep this import as a separate section to reduce merge conflict when forward merging with the v2 branch.
// eslint-disable-next-line
const construct_compat_1 = require("./construct-compat");
const ARCHIVE_EXTENSIONS = ['.zip', '.jar'];
/**
 * Stages a file or directory from a location on the file system into a staging
 * directory.
 *
 * This is controlled by the context key 'aws:cdk:asset-staging' and enabled
 * by the CLI by default in order to ensure that when the CDK app exists, all
 * assets are available for deployment. Otherwise, if an app references assets
 * in temporary locations, those will not be available when it exists (see
 * https://github.com/aws/aws-cdk/issues/1716).
 *
 * The `stagedPath` property is a stringified token that represents the location
 * of the file or directory after staging. It will be resolved only during the
 * "prepare" stage and may be either the original path or the staged path
 * depending on the context setting.
 *
 * The file/directory are staged based on their content hash (fingerprint). This
 * means that only if content was changed, copy will happen.
 */
class AssetStaging extends construct_compat_1.Construct {
    constructor(scope, id, props) {
        super(scope, id);
        try {
            jsiiDeprecationWarnings._aws_cdk_core_AssetStagingProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, AssetStaging);
            }
            throw error;
        }
        this.sourcePath = path.resolve(props.sourcePath);
        this.fingerprintOptions = props;
        if (!fs.existsSync(this.sourcePath)) {
            throw new Error(`Cannot find asset at ${this.sourcePath}`);
        }
        this.sourceStats = fs.statSync(this.sourcePath);
        const outdir = stage_1.Stage.of(this)?.assetOutdir;
        if (!outdir) {
            throw new Error('unable to determine cloud assembly asset output directory. Assets must be defined indirectly within a "Stage" or an "App" scope');
        }
        this.assetOutdir = outdir;
        // Determine the hash type based on the props as props.assetHashType is
        // optional from a caller perspective.
        this.customSourceFingerprint = props.assetHash;
        this.hashType = determineHashType(props.assetHashType, this.customSourceFingerprint);
        // Decide what we're going to do, without actually doing it yet
        let stageThisAsset;
        let skip = false;
        if (props.bundling) {
            // Check if we actually have to bundle for this stack
            skip = !stack_1.Stack.of(this).bundlingRequired;
            const bundling = props.bundling;
            stageThisAsset = () => this.stageByBundling(bundling, skip);
        }
        else {
            stageThisAsset = () => this.stageByCopying();
        }
        // Calculate a cache key from the props. This way we can check if we already
        // staged this asset and reuse the result (e.g. the same asset with the same
        // configuration is used in multiple stacks). In this case we can completely
        // skip file system and bundling operations.
        //
        // The output directory and whether this asset is skipped or not should also be
        // part of the cache key to make sure we don't accidentally return the wrong
        // staged asset from the cache.
        this.cacheKey = calculateCacheKey({
            outdir: this.assetOutdir,
            sourcePath: path.resolve(props.sourcePath),
            bundling: props.bundling,
            assetHashType: this.hashType,
            customFingerprint: this.customSourceFingerprint,
            extraHash: props.extraHash,
            exclude: props.exclude,
            ignoreMode: props.ignoreMode,
            skip,
        });
        const staged = AssetStaging.assetCache.obtain(this.cacheKey, stageThisAsset);
        this.stagedPath = staged.stagedPath;
        this.absoluteStagedPath = staged.stagedPath;
        this.assetHash = staged.assetHash;
        this.packaging = staged.packaging;
        this.isArchive = staged.isArchive;
    }
    /**
     * Clears the asset hash cache
     */
    static clearAssetHashCache() {
        this.assetCache.clear();
    }
    /**
     * A cryptographic hash of the asset.
     *
     * @deprecated see `assetHash`.
     */
    get sourceHash() {
        try {
            jsiiDeprecationWarnings.print("@aws-cdk/core.AssetStaging#sourceHash", "see `assetHash`.");
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, jsiiDeprecationWarnings.getPropertyDescriptor(this, "sourceHash").get);
            }
            throw error;
        }
        return this.assetHash;
    }
    /**
     * Return the path to the staged asset, relative to the Cloud Assembly (manifest) directory of the given stack
     *
     * Only returns a relative path if the asset was staged, returns an absolute path if
     * it was not staged.
     *
     * A bundled asset might end up in the outDir and still not count as
     * "staged"; if asset staging is disabled we're technically expected to
     * reference source directories, but we don't have a source directory for the
     * bundled outputs (as the bundle output is written to a temporary
     * directory). Nevertheless, we will still return an absolute path.
     *
     * A non-obvious directory layout may look like this:
     *
     * ```
     *   CLOUD ASSEMBLY ROOT
     *     +-- asset.12345abcdef/
     *     +-- assembly-Stage
     *           +-- MyStack.template.json
     *           +-- MyStack.assets.json <- will contain { "path": "../asset.12345abcdef" }
     * ```
     */
    relativeStagedPath(stack) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_Stack(stack);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.relativeStagedPath);
            }
            throw error;
        }
        const asmManifestDir = stage_1.Stage.of(stack)?.outdir;
        if (!asmManifestDir) {
            return this.stagedPath;
        }
        const isOutsideAssetDir = path.relative(this.assetOutdir, this.stagedPath).startsWith('..');
        if (isOutsideAssetDir || this.stagingDisabled) {
            return this.stagedPath;
        }
        return path.relative(asmManifestDir, this.stagedPath);
    }
    /**
     * Stage the source to the target by copying
     *
     * Optionally skip if staging is disabled, in which case we pretend we did something but we don't really.
     */
    stageByCopying() {
        const assetHash = this.calculateHash(this.hashType);
        const stagedPath = this.stagingDisabled
            ? this.sourcePath
            : path.resolve(this.assetOutdir, renderAssetFilename(assetHash, path.extname(this.sourcePath)));
        if (!this.sourceStats.isDirectory() && !this.sourceStats.isFile()) {
            throw new Error(`Asset ${this.sourcePath} is expected to be either a directory or a regular file`);
        }
        this.stageAsset(this.sourcePath, stagedPath, 'copy');
        return {
            assetHash,
            stagedPath,
            packaging: this.sourceStats.isDirectory() ? assets_1.FileAssetPackaging.ZIP_DIRECTORY : assets_1.FileAssetPackaging.FILE,
            isArchive: this.sourceStats.isDirectory() || ARCHIVE_EXTENSIONS.includes(path.extname(this.sourcePath).toLowerCase()),
        };
    }
    /**
     * Stage the source to the target by bundling
     *
     * Optionally skip, in which case we pretend we did something but we don't really.
     */
    stageByBundling(bundling, skip) {
        if (!this.sourceStats.isDirectory()) {
            throw new Error(`Asset ${this.sourcePath} is expected to be a directory when bundling`);
        }
        if (skip) {
            // We should have bundled, but didn't to save time. Still pretend to have a hash.
            // If the asset uses OUTPUT or BUNDLE, we use a CUSTOM hash to avoid fingerprinting
            // a potentially very large source directory. Other hash types are kept the same.
            let hashType = this.hashType;
            if (hashType === assets_1.AssetHashType.OUTPUT || hashType === assets_1.AssetHashType.BUNDLE) {
                this.customSourceFingerprint = names_1.Names.uniqueId(this);
                hashType = assets_1.AssetHashType.CUSTOM;
            }
            return {
                assetHash: this.calculateHash(hashType, bundling),
                stagedPath: this.sourcePath,
                packaging: assets_1.FileAssetPackaging.ZIP_DIRECTORY,
                isArchive: true,
            };
        }
        // Try to calculate assetHash beforehand (if we can)
        let assetHash = this.hashType === assets_1.AssetHashType.SOURCE || this.hashType === assets_1.AssetHashType.CUSTOM
            ? this.calculateHash(this.hashType, bundling)
            : undefined;
        const bundleDir = this.determineBundleDir(this.assetOutdir, assetHash);
        this.bundle(bundling, bundleDir);
        // Check bundling output content and determine if we will need to archive
        const bundlingOutputType = bundling.outputType ?? bundling_1.BundlingOutput.AUTO_DISCOVER;
        const bundledAsset = determineBundledAsset(bundleDir, bundlingOutputType);
        // Calculate assetHash afterwards if we still must
        assetHash = assetHash ?? this.calculateHash(this.hashType, bundling, bundledAsset.path);
        const stagedPath = path.resolve(this.assetOutdir, renderAssetFilename(assetHash, bundledAsset.extension));
        this.stageAsset(bundledAsset.path, stagedPath, 'move');
        // If bundling produced a single archive file we "touch" this file in the bundling
        // directory after it has been moved to the staging directory. This way if bundling
        // is skipped because the bundling directory already exists we can still determine
        // the correct packaging type.
        if (bundledAsset.packaging === assets_1.FileAssetPackaging.FILE) {
            fs.closeSync(fs.openSync(bundledAsset.path, 'w'));
        }
        return {
            assetHash,
            stagedPath,
            packaging: bundledAsset.packaging,
            isArchive: true,
        };
    }
    /**
     * Whether staging has been disabled
     */
    get stagingDisabled() {
        return !!this.node.tryGetContext(cxapi.DISABLE_ASSET_STAGING_CONTEXT);
    }
    /**
     * Copies or moves the files from sourcePath to targetPath.
     *
     * Moving implies the source directory is temporary and can be trashed.
     *
     * Will not do anything if source and target are the same.
     */
    stageAsset(sourcePath, targetPath, style) {
        // Is the work already done?
        const isAlreadyStaged = fs.existsSync(targetPath);
        if (isAlreadyStaged) {
            if (style === 'move' && sourcePath !== targetPath) {
                fs.removeSync(sourcePath);
            }
            return;
        }
        // Moving can be done quickly
        if (style == 'move') {
            fs.renameSync(sourcePath, targetPath);
            return;
        }
        // Copy file/directory to staging directory
        if (this.sourceStats.isFile()) {
            fs.copyFileSync(sourcePath, targetPath);
        }
        else if (this.sourceStats.isDirectory()) {
            fs.mkdirSync(targetPath);
            fs_1.FileSystem.copyDirectory(sourcePath, targetPath, this.fingerprintOptions);
        }
        else {
            throw new Error(`Unknown file type: ${sourcePath}`);
        }
    }
    /**
     * Determine the directory where we're going to write the bundling output
     *
     * This is the target directory where we're going to write the staged output
     * files if we can (if the hash is fully known), or a temporary directory
     * otherwise.
     */
    determineBundleDir(outdir, sourceHash) {
        if (sourceHash) {
            return path.resolve(outdir, renderAssetFilename(sourceHash));
        }
        // When the asset hash isn't known in advance, bundler outputs to an
        // intermediate directory named after the asset's cache key
        return path.resolve(outdir, `bundling-temp-${this.cacheKey}`);
    }
    /**
     * Bundles an asset to the given directory
     *
     * If the given directory already exists, assume that everything's already
     * in order and don't do anything.
     *
     * @param options Bundling options
     * @param bundleDir Where to create the bundle directory
     * @returns The fully resolved bundle output directory.
     */
    bundle(options, bundleDir) {
        if (fs.existsSync(bundleDir)) {
            return;
        }
        fs.ensureDirSync(bundleDir);
        // Chmod the bundleDir to full access.
        fs.chmodSync(bundleDir, 0o777);
        // Always mount input and output dir
        const volumes = [
            {
                hostPath: this.sourcePath,
                containerPath: AssetStaging.BUNDLING_INPUT_DIR,
            },
            {
                hostPath: bundleDir,
                containerPath: AssetStaging.BUNDLING_OUTPUT_DIR,
            },
            ...options.volumes ?? [],
        ];
        let localBundling;
        try {
            process.stderr.write(`Bundling asset ${this.node.path}...\n`);
            localBundling = options.local?.tryBundle(bundleDir, options);
            if (!localBundling) {
                let user;
                if (options.user) {
                    user = options.user;
                }
                else { // Default to current user
                    const userInfo = os.userInfo();
                    user = userInfo.uid !== -1 // uid is -1 on Windows
                        ? `${userInfo.uid}:${userInfo.gid}`
                        : '1000:1000';
                }
                options.image.run({
                    command: options.command,
                    user,
                    volumes,
                    environment: options.environment,
                    workingDirectory: options.workingDirectory ?? AssetStaging.BUNDLING_INPUT_DIR,
                    securityOpt: options.securityOpt ?? '',
                });
            }
        }
        catch (err) {
            // When bundling fails, keep the bundle output for diagnosability, but
            // rename it out of the way so that the next run doesn't assume it has a
            // valid bundleDir.
            const bundleErrorDir = bundleDir + '-error';
            if (fs.existsSync(bundleErrorDir)) {
                // Remove the last bundleErrorDir.
                fs.removeSync(bundleErrorDir);
            }
            fs.renameSync(bundleDir, bundleErrorDir);
            throw new Error(`Failed to bundle asset ${this.node.path}, bundle output is located at ${bundleErrorDir}: ${err}`);
        }
        if (fs_1.FileSystem.isEmpty(bundleDir)) {
            const outputDir = localBundling ? bundleDir : AssetStaging.BUNDLING_OUTPUT_DIR;
            throw new Error(`Bundling did not produce any output. Check that content is written to ${outputDir}.`);
        }
    }
    calculateHash(hashType, bundling, outputDir) {
        // When bundling a CUSTOM or SOURCE asset hash type, we want the hash to include
        // the bundling configuration. We handle CUSTOM and bundled SOURCE hash types
        // as a special case to preserve existing user asset hashes in all other cases.
        if (hashType == assets_1.AssetHashType.CUSTOM || (hashType == assets_1.AssetHashType.SOURCE && bundling)) {
            const hash = crypto.createHash('sha256');
            // if asset hash is provided by user, use it, otherwise fingerprint the source.
            hash.update(this.customSourceFingerprint ?? fs_1.FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions));
            // If we're bundling an asset, include the bundling configuration in the hash
            if (bundling) {
                hash.update(JSON.stringify(bundling));
            }
            return hash.digest('hex');
        }
        switch (hashType) {
            case assets_1.AssetHashType.SOURCE:
                return fs_1.FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions);
            case assets_1.AssetHashType.BUNDLE:
            case assets_1.AssetHashType.OUTPUT:
                if (!outputDir) {
                    throw new Error(`Cannot use \`${hashType}\` hash type when \`bundling\` is not specified.`);
                }
                return fs_1.FileSystem.fingerprint(outputDir, this.fingerprintOptions);
            default:
                throw new Error('Unknown asset hash type.');
        }
    }
}
exports.AssetStaging = AssetStaging;
_a = JSII_RTTI_SYMBOL_1;
AssetStaging[_a] = { fqn: "@aws-cdk/core.AssetStaging", version: "1.204.0" };
/**
 * The directory inside the bundling container into which the asset sources will be mounted.
 */
AssetStaging.BUNDLING_INPUT_DIR = '/asset-input';
/**
 * The directory inside the bundling container into which the bundled output should be written.
 */
AssetStaging.BUNDLING_OUTPUT_DIR = '/asset-output';
/**
 * Cache of asset hashes based on asset configuration to avoid repeated file
 * system and bundling operations.
 */
AssetStaging.assetCache = new cache_1.Cache();
function renderAssetFilename(assetHash, extension = '') {
    return `asset.${assetHash}${extension}`;
}
/**
 * Determines the hash type from user-given prop values.
 *
 * @param assetHashType Asset hash type construct prop
 * @param customSourceFingerprint Asset hash seed given in the construct props
 */
function determineHashType(assetHashType, customSourceFingerprint) {
    const hashType = customSourceFingerprint
        ? (assetHashType ?? assets_1.AssetHashType.CUSTOM)
        : (assetHashType ?? assets_1.AssetHashType.SOURCE);
    if (customSourceFingerprint && hashType !== assets_1.AssetHashType.CUSTOM) {
        throw new Error(`Cannot specify \`${assetHashType}\` for \`assetHashType\` when \`assetHash\` is specified. Use \`CUSTOM\` or leave \`undefined\`.`);
    }
    if (hashType === assets_1.AssetHashType.CUSTOM && !customSourceFingerprint) {
        throw new Error('`assetHash` must be specified when `assetHashType` is set to `AssetHashType.CUSTOM`.');
    }
    return hashType;
}
/**
 * Calculates a cache key from the props. Normalize by sorting keys.
 */
function calculateCacheKey(props) {
    return crypto.createHash('sha256')
        .update(JSON.stringify(sortObject(props)))
        .digest('hex');
}
/**
 * Recursively sort object keys
 */
function sortObject(object) {
    if (typeof object !== 'object' || object instanceof Array) {
        return object;
    }
    const ret = {};
    for (const key of Object.keys(object).sort()) {
        ret[key] = sortObject(object[key]);
    }
    return ret;
}
/**
 * Returns the single archive file of a directory or undefined
 */
function singleArchiveFile(directory) {
    if (!fs.existsSync(directory)) {
        throw new Error(`Directory ${directory} does not exist.`);
    }
    if (!fs.statSync(directory).isDirectory()) {
        throw new Error(`${directory} is not a directory.`);
    }
    const content = fs.readdirSync(directory);
    if (content.length === 1) {
        const file = path.join(directory, content[0]);
        const extension = path.extname(content[0]).toLowerCase();
        if (fs.statSync(file).isFile() && ARCHIVE_EXTENSIONS.includes(extension)) {
            return file;
        }
    }
    return undefined;
}
/**
 * Returns the bundled asset to use based on the content of the bundle directory
 * and the type of output.
 */
function determineBundledAsset(bundleDir, outputType) {
    const archiveFile = singleArchiveFile(bundleDir);
    // auto-discover means that if there is an archive file, we take it as the
    // bundle, otherwise, we will archive here.
    if (outputType === bundling_1.BundlingOutput.AUTO_DISCOVER) {
        outputType = archiveFile ? bundling_1.BundlingOutput.ARCHIVED : bundling_1.BundlingOutput.NOT_ARCHIVED;
    }
    switch (outputType) {
        case bundling_1.BundlingOutput.NOT_ARCHIVED:
            return { path: bundleDir, packaging: assets_1.FileAssetPackaging.ZIP_DIRECTORY };
        case bundling_1.BundlingOutput.ARCHIVED:
            if (!archiveFile) {
                throw new Error('Bundling output directory is expected to include only a single .zip or .jar file when `output` is set to `ARCHIVED`');
            }
            return { path: archiveFile, packaging: assets_1.FileAssetPackaging.FILE, extension: path.extname(archiveFile) };
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-staging.js","sourceRoot":"","sources":["asset-staging.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'crypto';\nimport * as os from 'os';\nimport * as path from 'path';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport { Construct } from 'constructs';\nimport * as fs from 'fs-extra';\nimport { AssetHashType, AssetOptions, FileAssetPackaging } from './assets';\nimport { BundlingOptions, BundlingOutput } from './bundling';\nimport { FileSystem, FingerprintOptions } from './fs';\nimport { Names } from './names';\nimport { Cache } from './private/cache';\nimport { Stack } from './stack';\nimport { Stage } from './stage';\n\n// v2 - keep this import as a separate section to reduce merge conflict when forward merging with the v2 branch.\n// eslint-disable-next-line\nimport { Construct as CoreConstruct } from './construct-compat';\n\nconst ARCHIVE_EXTENSIONS = ['.zip', '.jar'];\n\n/**\n * A previously staged asset\n */\ninterface StagedAsset {\n  /**\n   * The path where we wrote this asset previously\n   */\n  readonly stagedPath: string;\n\n  /**\n   * The hash we used previously\n   */\n  readonly assetHash: string;\n\n  /**\n   * The packaging of the asset\n   */\n  readonly packaging: FileAssetPackaging,\n\n  /**\n   * Whether this asset is an archive\n   */\n  readonly isArchive: boolean;\n}\n\n/**\n * Initialization properties for `AssetStaging`.\n */\nexport interface AssetStagingProps extends FingerprintOptions, AssetOptions {\n  /**\n   * The source file or directory to copy from.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * Stages a file or directory from a location on the file system into a staging\n * directory.\n *\n * This is controlled by the context key 'aws:cdk:asset-staging' and enabled\n * by the CLI by default in order to ensure that when the CDK app exists, all\n * assets are available for deployment. Otherwise, if an app references assets\n * in temporary locations, those will not be available when it exists (see\n * https://github.com/aws/aws-cdk/issues/1716).\n *\n * The `stagedPath` property is a stringified token that represents the location\n * of the file or directory after staging. It will be resolved only during the\n * \"prepare\" stage and may be either the original path or the staged path\n * depending on the context setting.\n *\n * The file/directory are staged based on their content hash (fingerprint). This\n * means that only if content was changed, copy will happen.\n */\nexport class AssetStaging extends CoreConstruct {\n  /**\n   * The directory inside the bundling container into which the asset sources will be mounted.\n   */\n  public static readonly BUNDLING_INPUT_DIR = '/asset-input';\n\n  /**\n   * The directory inside the bundling container into which the bundled output should be written.\n   */\n  public static readonly BUNDLING_OUTPUT_DIR = '/asset-output';\n\n  /**\n   * Clears the asset hash cache\n   */\n  public static clearAssetHashCache() {\n    this.assetCache.clear();\n  }\n\n  /**\n   * Cache of asset hashes based on asset configuration to avoid repeated file\n   * system and bundling operations.\n   */\n  private static assetCache = new Cache<StagedAsset>();\n\n  /**\n   * Absolute path to the asset data.\n   *\n   * If asset staging is disabled, this will just be the source path or\n   * a temporary directory used for bundling.\n   *\n   * If asset staging is enabled it will be the staged path.\n   *\n   * IMPORTANT: If you are going to call `addFileAsset()`, use\n   * `relativeStagedPath()` instead.\n   *\n   * @deprecated - Use `absoluteStagedPath` instead.\n   */\n  public readonly stagedPath: string;\n\n  /**\n   * Absolute path to the asset data.\n   *\n   * If asset staging is disabled, this will just be the source path or\n   * a temporary directory used for bundling.\n   *\n   * If asset staging is enabled it will be the staged path.\n   *\n   * IMPORTANT: If you are going to call `addFileAsset()`, use\n   * `relativeStagedPath()` instead.\n   */\n  public readonly absoluteStagedPath: string;\n\n  /**\n   * The absolute path of the asset as it was referenced by the user.\n   */\n  public readonly sourcePath: string;\n\n  /**\n   * A cryptographic hash of the asset.\n   */\n  public readonly assetHash: string;\n\n  /**\n   * How this asset should be packaged.\n   */\n  public readonly packaging: FileAssetPackaging;\n\n  /**\n   * Whether this asset is an archive (zip or jar).\n   */\n  public readonly isArchive: boolean;\n\n  private readonly fingerprintOptions: FingerprintOptions;\n\n  private readonly hashType: AssetHashType;\n  private readonly assetOutdir: string;\n\n  /**\n   * A custom source fingerprint given by the user\n   *\n   * Will not be used literally, always hashed later on.\n   */\n  private customSourceFingerprint?: string;\n\n  private readonly cacheKey: string;\n\n  private readonly sourceStats: fs.Stats;\n\n  constructor(scope: Construct, id: string, props: AssetStagingProps) {\n    super(scope, id);\n\n    this.sourcePath = path.resolve(props.sourcePath);\n    this.fingerprintOptions = props;\n\n    if (!fs.existsSync(this.sourcePath)) {\n      throw new Error(`Cannot find asset at ${this.sourcePath}`);\n    }\n\n    this.sourceStats = fs.statSync(this.sourcePath);\n\n    const outdir = Stage.of(this)?.assetOutdir;\n    if (!outdir) {\n      throw new Error('unable to determine cloud assembly asset output directory. Assets must be defined indirectly within a \"Stage\" or an \"App\" scope');\n    }\n    this.assetOutdir = outdir;\n\n    // Determine the hash type based on the props as props.assetHashType is\n    // optional from a caller perspective.\n    this.customSourceFingerprint = props.assetHash;\n    this.hashType = determineHashType(props.assetHashType, this.customSourceFingerprint);\n\n    // Decide what we're going to do, without actually doing it yet\n    let stageThisAsset: () => StagedAsset;\n    let skip = false;\n    if (props.bundling) {\n      // Check if we actually have to bundle for this stack\n      skip = !Stack.of(this).bundlingRequired;\n      const bundling = props.bundling;\n      stageThisAsset = () => this.stageByBundling(bundling, skip);\n    } else {\n      stageThisAsset = () => this.stageByCopying();\n    }\n\n    // Calculate a cache key from the props. This way we can check if we already\n    // staged this asset and reuse the result (e.g. the same asset with the same\n    // configuration is used in multiple stacks). In this case we can completely\n    // skip file system and bundling operations.\n    //\n    // The output directory and whether this asset is skipped or not should also be\n    // part of the cache key to make sure we don't accidentally return the wrong\n    // staged asset from the cache.\n    this.cacheKey = calculateCacheKey({\n      outdir: this.assetOutdir,\n      sourcePath: path.resolve(props.sourcePath),\n      bundling: props.bundling,\n      assetHashType: this.hashType,\n      customFingerprint: this.customSourceFingerprint,\n      extraHash: props.extraHash,\n      exclude: props.exclude,\n      ignoreMode: props.ignoreMode,\n      skip,\n    });\n\n    const staged = AssetStaging.assetCache.obtain(this.cacheKey, stageThisAsset);\n    this.stagedPath = staged.stagedPath;\n    this.absoluteStagedPath = staged.stagedPath;\n    this.assetHash = staged.assetHash;\n    this.packaging = staged.packaging;\n    this.isArchive = staged.isArchive;\n  }\n\n  /**\n   * A cryptographic hash of the asset.\n   *\n   * @deprecated see `assetHash`.\n   */\n  public get sourceHash(): string {\n    return this.assetHash;\n  }\n\n  /**\n   * Return the path to the staged asset, relative to the Cloud Assembly (manifest) directory of the given stack\n   *\n   * Only returns a relative path if the asset was staged, returns an absolute path if\n   * it was not staged.\n   *\n   * A bundled asset might end up in the outDir and still not count as\n   * \"staged\"; if asset staging is disabled we're technically expected to\n   * reference source directories, but we don't have a source directory for the\n   * bundled outputs (as the bundle output is written to a temporary\n   * directory). Nevertheless, we will still return an absolute path.\n   *\n   * A non-obvious directory layout may look like this:\n   *\n   * ```\n   *   CLOUD ASSEMBLY ROOT\n   *     +-- asset.12345abcdef/\n   *     +-- assembly-Stage\n   *           +-- MyStack.template.json\n   *           +-- MyStack.assets.json <- will contain { \"path\": \"../asset.12345abcdef\" }\n   * ```\n   */\n  public relativeStagedPath(stack: Stack) {\n    const asmManifestDir = Stage.of(stack)?.outdir;\n    if (!asmManifestDir) { return this.stagedPath; }\n\n    const isOutsideAssetDir = path.relative(this.assetOutdir, this.stagedPath).startsWith('..');\n    if (isOutsideAssetDir || this.stagingDisabled) {\n      return this.stagedPath;\n    }\n\n    return path.relative(asmManifestDir, this.stagedPath);\n  }\n\n  /**\n   * Stage the source to the target by copying\n   *\n   * Optionally skip if staging is disabled, in which case we pretend we did something but we don't really.\n   */\n  private stageByCopying(): StagedAsset {\n    const assetHash = this.calculateHash(this.hashType);\n    const stagedPath = this.stagingDisabled\n      ? this.sourcePath\n      : path.resolve(this.assetOutdir, renderAssetFilename(assetHash, path.extname(this.sourcePath)));\n\n    if (!this.sourceStats.isDirectory() && !this.sourceStats.isFile()) {\n      throw new Error(`Asset ${this.sourcePath} is expected to be either a directory or a regular file`);\n    }\n\n    this.stageAsset(this.sourcePath, stagedPath, 'copy');\n\n    return {\n      assetHash,\n      stagedPath,\n      packaging: this.sourceStats.isDirectory() ? FileAssetPackaging.ZIP_DIRECTORY : FileAssetPackaging.FILE,\n      isArchive: this.sourceStats.isDirectory() || ARCHIVE_EXTENSIONS.includes(path.extname(this.sourcePath).toLowerCase()),\n    };\n  }\n\n  /**\n   * Stage the source to the target by bundling\n   *\n   * Optionally skip, in which case we pretend we did something but we don't really.\n   */\n  private stageByBundling(bundling: BundlingOptions, skip: boolean): StagedAsset {\n    if (!this.sourceStats.isDirectory()) {\n      throw new Error(`Asset ${this.sourcePath} is expected to be a directory when bundling`);\n    }\n\n    if (skip) {\n      // We should have bundled, but didn't to save time. Still pretend to have a hash.\n      // If the asset uses OUTPUT or BUNDLE, we use a CUSTOM hash to avoid fingerprinting\n      // a potentially very large source directory. Other hash types are kept the same.\n      let hashType = this.hashType;\n      if (hashType === AssetHashType.OUTPUT || hashType === AssetHashType.BUNDLE) {\n        this.customSourceFingerprint = Names.uniqueId(this);\n        hashType = AssetHashType.CUSTOM;\n      }\n      return {\n        assetHash: this.calculateHash(hashType, bundling),\n        stagedPath: this.sourcePath,\n        packaging: FileAssetPackaging.ZIP_DIRECTORY,\n        isArchive: true,\n      };\n    }\n\n    // Try to calculate assetHash beforehand (if we can)\n    let assetHash = this.hashType === AssetHashType.SOURCE || this.hashType === AssetHashType.CUSTOM\n      ? this.calculateHash(this.hashType, bundling)\n      : undefined;\n\n    const bundleDir = this.determineBundleDir(this.assetOutdir, assetHash);\n    this.bundle(bundling, bundleDir);\n\n    // Check bundling output content and determine if we will need to archive\n    const bundlingOutputType = bundling.outputType ?? BundlingOutput.AUTO_DISCOVER;\n    const bundledAsset = determineBundledAsset(bundleDir, bundlingOutputType);\n\n    // Calculate assetHash afterwards if we still must\n    assetHash = assetHash ?? this.calculateHash(this.hashType, bundling, bundledAsset.path);\n    const stagedPath = path.resolve(this.assetOutdir, renderAssetFilename(assetHash, bundledAsset.extension));\n\n    this.stageAsset(bundledAsset.path, stagedPath, 'move');\n\n    // If bundling produced a single archive file we \"touch\" this file in the bundling\n    // directory after it has been moved to the staging directory. This way if bundling\n    // is skipped because the bundling directory already exists we can still determine\n    // the correct packaging type.\n    if (bundledAsset.packaging === FileAssetPackaging.FILE) {\n      fs.closeSync(fs.openSync(bundledAsset.path, 'w'));\n    }\n\n    return {\n      assetHash,\n      stagedPath,\n      packaging: bundledAsset.packaging,\n      isArchive: true, // bundling always produces an archive\n    };\n  }\n\n  /**\n   * Whether staging has been disabled\n   */\n  private get stagingDisabled() {\n    return !!this.node.tryGetContext(cxapi.DISABLE_ASSET_STAGING_CONTEXT);\n  }\n\n  /**\n   * Copies or moves the files from sourcePath to targetPath.\n   *\n   * Moving implies the source directory is temporary and can be trashed.\n   *\n   * Will not do anything if source and target are the same.\n   */\n  private stageAsset(sourcePath: string, targetPath: string, style: 'move' | 'copy') {\n    // Is the work already done?\n    const isAlreadyStaged = fs.existsSync(targetPath);\n    if (isAlreadyStaged) {\n      if (style === 'move' && sourcePath !== targetPath) {\n        fs.removeSync(sourcePath);\n      }\n      return;\n    }\n\n    // Moving can be done quickly\n    if (style == 'move') {\n      fs.renameSync(sourcePath, targetPath);\n      return;\n    }\n\n    // Copy file/directory to staging directory\n    if (this.sourceStats.isFile()) {\n      fs.copyFileSync(sourcePath, targetPath);\n    } else if (this.sourceStats.isDirectory()) {\n      fs.mkdirSync(targetPath);\n      FileSystem.copyDirectory(sourcePath, targetPath, this.fingerprintOptions);\n    } else {\n      throw new Error(`Unknown file type: ${sourcePath}`);\n    }\n  }\n\n  /**\n   * Determine the directory where we're going to write the bundling output\n   *\n   * This is the target directory where we're going to write the staged output\n   * files if we can (if the hash is fully known), or a temporary directory\n   * otherwise.\n   */\n  private determineBundleDir(outdir: string, sourceHash?: string) {\n    if (sourceHash) {\n      return path.resolve(outdir, renderAssetFilename(sourceHash));\n    }\n\n    // When the asset hash isn't known in advance, bundler outputs to an\n    // intermediate directory named after the asset's cache key\n    return path.resolve(outdir, `bundling-temp-${this.cacheKey}`);\n  }\n\n  /**\n   * Bundles an asset to the given directory\n   *\n   * If the given directory already exists, assume that everything's already\n   * in order and don't do anything.\n   *\n   * @param options Bundling options\n   * @param bundleDir Where to create the bundle directory\n   * @returns The fully resolved bundle output directory.\n   */\n  private bundle(options: BundlingOptions, bundleDir: string) {\n    if (fs.existsSync(bundleDir)) { return; }\n\n    fs.ensureDirSync(bundleDir);\n    // Chmod the bundleDir to full access.\n    fs.chmodSync(bundleDir, 0o777);\n\n    // Always mount input and output dir\n    const volumes = [\n      {\n        hostPath: this.sourcePath,\n        containerPath: AssetStaging.BUNDLING_INPUT_DIR,\n      },\n      {\n        hostPath: bundleDir,\n        containerPath: AssetStaging.BUNDLING_OUTPUT_DIR,\n      },\n      ...options.volumes ?? [],\n    ];\n\n    let localBundling: boolean | undefined;\n    try {\n      process.stderr.write(`Bundling asset ${this.node.path}...\\n`);\n\n      localBundling = options.local?.tryBundle(bundleDir, options);\n      if (!localBundling) {\n        let user: string;\n        if (options.user) {\n          user = options.user;\n        } else { // Default to current user\n          const userInfo = os.userInfo();\n          user = userInfo.uid !== -1 // uid is -1 on Windows\n            ? `${userInfo.uid}:${userInfo.gid}`\n            : '1000:1000';\n        }\n\n        options.image.run({\n          command: options.command,\n          user,\n          volumes,\n          environment: options.environment,\n          workingDirectory: options.workingDirectory ?? AssetStaging.BUNDLING_INPUT_DIR,\n          securityOpt: options.securityOpt ?? '',\n        });\n      }\n    } catch (err) {\n      // When bundling fails, keep the bundle output for diagnosability, but\n      // rename it out of the way so that the next run doesn't assume it has a\n      // valid bundleDir.\n      const bundleErrorDir = bundleDir + '-error';\n      if (fs.existsSync(bundleErrorDir)) {\n        // Remove the last bundleErrorDir.\n        fs.removeSync(bundleErrorDir);\n      }\n\n      fs.renameSync(bundleDir, bundleErrorDir);\n      throw new Error(`Failed to bundle asset ${this.node.path}, bundle output is located at ${bundleErrorDir}: ${err}`);\n    }\n\n    if (FileSystem.isEmpty(bundleDir)) {\n      const outputDir = localBundling ? bundleDir : AssetStaging.BUNDLING_OUTPUT_DIR;\n      throw new Error(`Bundling did not produce any output. Check that content is written to ${outputDir}.`);\n    }\n  }\n\n  private calculateHash(hashType: AssetHashType, bundling?: BundlingOptions, outputDir?: string): string {\n    // When bundling a CUSTOM or SOURCE asset hash type, we want the hash to include\n    // the bundling configuration. We handle CUSTOM and bundled SOURCE hash types\n    // as a special case to preserve existing user asset hashes in all other cases.\n    if (hashType == AssetHashType.CUSTOM || (hashType == AssetHashType.SOURCE && bundling)) {\n      const hash = crypto.createHash('sha256');\n\n      // if asset hash is provided by user, use it, otherwise fingerprint the source.\n      hash.update(this.customSourceFingerprint ?? FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions));\n\n      // If we're bundling an asset, include the bundling configuration in the hash\n      if (bundling) {\n        hash.update(JSON.stringify(bundling));\n      }\n\n      return hash.digest('hex');\n    }\n\n    switch (hashType) {\n      case AssetHashType.SOURCE:\n        return FileSystem.fingerprint(this.sourcePath, this.fingerprintOptions);\n      case AssetHashType.BUNDLE:\n      case AssetHashType.OUTPUT:\n        if (!outputDir) {\n          throw new Error(`Cannot use \\`${hashType}\\` hash type when \\`bundling\\` is not specified.`);\n        }\n        return FileSystem.fingerprint(outputDir, this.fingerprintOptions);\n      default:\n        throw new Error('Unknown asset hash type.');\n    }\n  }\n}\n\nfunction renderAssetFilename(assetHash: string, extension = '') {\n  return `asset.${assetHash}${extension}`;\n}\n\n/**\n * Determines the hash type from user-given prop values.\n *\n * @param assetHashType Asset hash type construct prop\n * @param customSourceFingerprint Asset hash seed given in the construct props\n */\nfunction determineHashType(assetHashType?: AssetHashType, customSourceFingerprint?: string) {\n  const hashType = customSourceFingerprint\n    ? (assetHashType ?? AssetHashType.CUSTOM)\n    : (assetHashType ?? AssetHashType.SOURCE);\n\n  if (customSourceFingerprint && hashType !== AssetHashType.CUSTOM) {\n    throw new Error(`Cannot specify \\`${assetHashType}\\` for \\`assetHashType\\` when \\`assetHash\\` is specified. Use \\`CUSTOM\\` or leave \\`undefined\\`.`);\n  }\n  if (hashType === AssetHashType.CUSTOM && !customSourceFingerprint) {\n    throw new Error('`assetHash` must be specified when `assetHashType` is set to `AssetHashType.CUSTOM`.');\n  }\n\n  return hashType;\n}\n\n/**\n * Calculates a cache key from the props. Normalize by sorting keys.\n */\nfunction calculateCacheKey<A extends object>(props: A): string {\n  return crypto.createHash('sha256')\n    .update(JSON.stringify(sortObject(props)))\n    .digest('hex');\n}\n\n/**\n * Recursively sort object keys\n */\nfunction sortObject(object: { [key: string]: any }): { [key: string]: any } {\n  if (typeof object !== 'object' || object instanceof Array) {\n    return object;\n  }\n  const ret: { [key: string]: any } = {};\n  for (const key of Object.keys(object).sort()) {\n    ret[key] = sortObject(object[key]);\n  }\n  return ret;\n}\n\n/**\n * Returns the single archive file of a directory or undefined\n */\nfunction singleArchiveFile(directory: string): string | undefined {\n  if (!fs.existsSync(directory)) {\n    throw new Error(`Directory ${directory} does not exist.`);\n  }\n\n  if (!fs.statSync(directory).isDirectory()) {\n    throw new Error(`${directory} is not a directory.`);\n  }\n\n  const content = fs.readdirSync(directory);\n  if (content.length === 1) {\n    const file = path.join(directory, content[0]);\n    const extension = path.extname(content[0]).toLowerCase();\n    if (fs.statSync(file).isFile() && ARCHIVE_EXTENSIONS.includes(extension)) {\n      return file;\n    }\n  }\n\n  return undefined;\n}\n\ninterface BundledAsset {\n  path: string,\n  packaging: FileAssetPackaging,\n  extension?: string\n}\n\n/**\n * Returns the bundled asset to use based on the content of the bundle directory\n * and the type of output.\n */\nfunction determineBundledAsset(bundleDir: string, outputType: BundlingOutput): BundledAsset {\n  const archiveFile = singleArchiveFile(bundleDir);\n\n  // auto-discover means that if there is an archive file, we take it as the\n  // bundle, otherwise, we will archive here.\n  if (outputType === BundlingOutput.AUTO_DISCOVER) {\n    outputType = archiveFile ? BundlingOutput.ARCHIVED : BundlingOutput.NOT_ARCHIVED;\n  }\n\n  switch (outputType) {\n    case BundlingOutput.NOT_ARCHIVED:\n      return { path: bundleDir, packaging: FileAssetPackaging.ZIP_DIRECTORY };\n    case BundlingOutput.ARCHIVED:\n      if (!archiveFile) {\n        throw new Error('Bundling output directory is expected to include only a single .zip or .jar file when `output` is set to `ARCHIVED`');\n      }\n      return { path: archiveFile, packaging: FileAssetPackaging.FILE, extension: path.extname(archiveFile) };\n  }\n}\n"]}