cdk-bundle

packages/@aws-cdk/assert/lib/expect.ts

@@ -1,27 +1,32 @@
 import cdk = require('@aws-cdk/cdk');
-import { ConstructNode, ConstructOrder } from '@aws-cdk/cdk';
+import { ConstructNode, ConstructOrder, FileSystemStore } from '@aws-cdk/cdk';
 import api = require('@aws-cdk/cx-api');
 import { StackInspector } from './inspector';
 import { SynthUtils } from './synth-utils';
 
+import fs = require('fs');
+import os = require('os');
+
 export function expect(stack: api.SynthesizedStack | cdk.Stack, skipValidation = false): StackInspector {
   // Can't use 'instanceof' here, that breaks if we have multiple copies
   // of this library.
   let sstack: api.SynthesizedStack;
 
   if (cdk.Stack.isStack(stack)) {
     const session = SynthUtils.synthesize(stack, {
+      store: new FileSystemStore({
+        path: fs.mkdtempSync(os.tmpdir())
+      }),
       skipValidation
     });
 
     sstack = {
       name: stack.name,
       template: SynthUtils.templateForStackName(session, stack.name),
-      metadata: collectStackMetadata(stack.node),
-      environment: {
-        name: 'test',
-        account: 'test',
-        region: 'test'
+      artifact: {
+        metadata: collectStackMetadata(stack.node),
+        type: api.ArtifactType.AwsCloudFormationStack,
+        environment: 'aws://test/test'
       }
     };
   } else {

packages/@aws-cdk/assert/lib/inspector.ts

@@ -54,9 +54,12 @@ export class StackPathInspector extends Inspector {
     // The names of paths in metadata in tests are very ill-defined. Try with the full path first,
     // then try with the stack name preprended for backwards compat with most tests that happen to give
     // their stack an ID that's the same as the stack name.
-    const md = this.stack.metadata[this.path] || this.stack.metadata[`/${this.stack.name}${this.path}`];
+    if (this.stack.artifact.metadata === undefined) {
+      return undefined;
+    }
+    const md = this.stack.artifact.metadata[this.path] || this.stack.artifact.metadata[`/${this.stack.name}${this.path}`];
     if (md === undefined) { return undefined; }
-    const resourceMd = md.find(entry => entry.type === 'aws:cdk:logicalId');
+    const resourceMd = md.find((entry: any) => entry.type === 'aws:cdk:logicalId');
     if (resourceMd === undefined) { return undefined; }
     const logicalId = resourceMd.data;
     return this.stack.template.Resources[logicalId];

packages/@aws-cdk/assert/lib/synth-utils.ts

@@ -1,13 +1,13 @@
 import { ISynthesisSession, Stack, SynthesisOptions, Synthesizer } from '@aws-cdk/cdk';
 
 export class SynthUtils {
-  public static toCloudFormation(stack: Stack, options: SynthesisOptions = { }): any {
+  public static toCloudFormation(stack: Stack, options: SynthesisOptions): any {
     const session = this.synthesize(stack, options);
     return this.templateForStackName(session, stack.name);
   }
 
   public static templateForStackName(session: ISynthesisSession, stackName: string): any {
-    return session.store.readJson(session.getArtifact(stackName).properties!.templateFile);
+    return session.assembly.readJson(session.getArtifact(stackName).properties!.templateFile);
   }
 
   public static synthesize(stack: Stack, options: SynthesisOptions): ISynthesisSession {

packages/@aws-cdk/assert/test/test.assertions.ts

@@ -42,7 +42,12 @@ passingExample('expect <synthStack> to match (exactly) <template>', () => {
   });
   const expected = {
     Resources: {
-      TestResource: { Type: resourceType }
+      TestResource: {
+        Type: resourceType,
+        Metadata: {
+          "aws:cdk:path": "TestStack/TestResource"
+        }
+      }
     }
   };
   expect(synthStack).to(matchTemplate(expected, MatchStyle.EXACT));
@@ -66,8 +71,19 @@ passingExample('expect <synthStack> to be a superset of <template>', () => {
   });
   const expected = {
     Resources: {
-      TestResourceA: { Type: 'Test::Resource' },
-      TestResourceB: { Type: 'Test::Resource', Properties: { Foo: 'Bar' } }
+      TestResourceA: {
+        Type: 'Test::Resource',
+        Metadata: {
+          "aws:cdk:path": "TestStack/TestResourceA"
+        }
+      },
+      TestResourceB: {
+        Type: 'Test::Resource',
+        Metadata: {
+          "aws:cdk:path": "TestStack/TestResourceB"
+        },
+        Properties: { Foo: 'Bar' }
+      }
     }
   };
   expect(synthStack).to(matchTemplate(expected, MatchStyle.SUPERSET));
@@ -206,10 +222,21 @@ function failingExample(title: string, cb: (test: Test) => void) {
 }
 
 function synthesizedStack(fn: (stack: cdk.Stack) => void): cx.SynthesizedStack {
-  const app = new cdk.App();
+  const app = new cdk.App({
+    context: {
+      [cx.PATH_METADATA_ENABLE_CONTEXT]: 'true'
+    }
+  });
   const stack = new cdk.Stack(app, 'TestStack');
   fn(stack);
-  return app.synthesizeStack(stack.name);
+  const session = app.run();
+  const artifact: cx.Artifact = session.manifest.artifacts![stack.name];
+  const template = session.assembly.readJson(artifact.properties!.templateFile);
+  return {
+    name: 'TestStack',
+    artifact,
+    template
+  };
 }
 
 interface TestResourceProps extends cdk.CfnResourceProps {

packages/@aws-cdk/assert/test/test.have-resource.ts

@@ -1,3 +1,4 @@
+import { ArtifactType, SynthesizedStack } from '@aws-cdk/cx-api';
 import { Test } from 'nodeunit';
 import { expect, haveResource } from '../lib/index';
 
@@ -89,15 +90,14 @@ export = {
   },
 };
 
-function mkStack(template: any) {
+function mkStack(template: any): SynthesizedStack {
   return {
     name: 'test',
     template,
-    metadata: {},
-    environment: {
-      name: 'test',
-      account: 'test',
-      region: 'test'
+    artifact: {
+      type: ArtifactType.AwsCloudFormationStack,
+      metadata: {},
+      environment: 'aws://test/test'
     }
   };
 }

packages/@aws-cdk/assets/lib/artifact.ts

@@ -0,0 +1,218 @@
+import cdk = require('@aws-cdk/cdk');
+import cxapi = require('@aws-cdk/cx-api');
+import fs = require('fs');
+import path = require('path');
+import { AssetPackaging, GenericAssetProps } from './asset';
+import { copyDirectory } from './fs-copy';
+import { fingerprint } from './fs-fingerprint';
+
+export interface AssetArtifactProps extends GenericAssetProps {
+  fingerprint: string;
+}
+
+/**
+ * This is an internal construct (only available within this module) which represents a unique
+ * asset within the app.
+ *
+ * To get an instance, use `AssetArtifact.forAsset`. It will calculate the fingerprint
+ * of the asset based on content hash and look up if there is already an artifact with this
+ * fingerprint in the app.
+ */
+export class AssetArtifact extends cdk.Construct implements cdk.ISynthesizable {
+
+  /**
+   * @returns gets or creates a singletone asset artifact for a specific asset
+   */
+  public static forAsset(scope: cdk.Construct, props: GenericAssetProps): AssetArtifact {
+    const extra = {
+      packaging: props.packaging,
+      extra: props.extra,
+    };
+
+    const sourcePath = path.resolve(props.path);
+    validateAssetOnDisk(sourcePath, props.packaging);
+
+    // calculate content hash, which is what we use as the app-level ID of this asset
+    const fp = fingerprint(props.path, {
+      exclude: props.exclude,
+      follow: props.follow,
+      extra: JSON.stringify(extra)
+    });
+
+    const root = scope.node.root;
+
+    const id = `asset_${fp}`;
+    const artifact = root.node.tryFindChild(id) as AssetArtifact || new AssetArtifact(root, id, {
+      fingerprint: fp,
+      path: sourcePath,
+      ...props
+    });
+
+    return artifact;
+  }
+
+  /**
+   * The unique fingerprint of this asset, based MD5 hash of the content and the
+   * directory structure.
+   */
+  public readonly fingerprint: string;
+
+  private readonly artifactId: string;
+  private readonly environments = new Set<string>();
+
+  private constructor(scope: cdk.Construct, id: string, private readonly props: AssetArtifactProps) {
+    super(scope, id);
+
+    this.fingerprint = props.fingerprint;
+    this.artifactId = id; // based on the fingerprint
+  }
+
+  /**
+   * Creates (or reuses) the set of bucket/key parameters that will be used to wire assets
+   * into a specific stack. Called by the `Asset` class to "subscribe" the asset to the stack.
+   *
+   * @param stack
+   */
+  public wireToStack(stack: cdk.Stack): AssetArtifactParameters {
+    const bucketParamId = `asset-${this.fingerprint}-S3Bucket`;
+    const keyParamId = `asset-${this.fingerprint}-S3Key`;
+    const hashParamId = `asset-${this.fingerprint}-S3ContentHash`;
+
+    // if we already have a parameters wired for this asset, just return them (assuming they all exist)
+    if (stack.node.tryFindChild(keyParamId)) {
+      return {
+        bucket: stack.node.findChild(bucketParamId) as cdk.Parameter,
+        key: stack.node.findChild(keyParamId) as cdk.Parameter,
+        sha256: stack.node.findChild(hashParamId) as cdk.Parameter
+      };
+    }
+
+    // okay, "register" this asset with the stack. this includes adding a bunch of parameters
+    // and a metadata entry that tells the toolkit how to build the asset.
+
+    const bucketParam = new cdk.Parameter(stack, bucketParamId, {
+      type: 'String',
+      description: `S3 bucket for asset ${this.fingerprint} from ${this.props.path}`,
+    });
+
+    const keyParam = new cdk.Parameter(stack, keyParamId, {
+      type: 'String',
+      description: `S3 key for asset ${this.fingerprint} from ${this.props.path}`
+    });
+
+    const contentHashParam = new cdk.Parameter(stack, hashParamId, {
+      type: 'String',
+      description: 'SHA-256 hash of the asset as it was uploaded to S3'
+    });
+
+    stack.setParameterValue(bucketParam, `\${${this.artifactId}}.s3bucket`);
+    stack.setParameterValue(keyParam, `\${${this.artifactId}}.s3key`);
+    stack.setParameterValue(contentHashParam, `\${${this.artifactId}}.sha256`);
+
+    this.environments.add(stack.environment);
+
+    return {
+      bucket: bucketParam,
+      key: keyParam,
+      sha256: contentHashParam
+    };
+  }
+
+  public synthesize(session: cdk.ISynthesisSession) {
+
+    switch (this.props.packaging) {
+      case AssetPackaging.File:
+        this.synthesizeFile(session);
+        return;
+
+      case AssetPackaging.ZipDirectory:
+        this.synthesizeZipDirectory(session);
+        return;
+    }
+
+  }
+
+  private synthesizeFile(session: cdk.ISynthesisSession) {
+    const ext = path.extname(this.props.path);
+    const fileName = `${this.fingerprint}${ext}`;
+
+    const stagingFile = path.join(this.fingerprint, path.basename(this.props.path));
+
+    fs.mkdirSync(path.join(session.staging.path, this.fingerprint));
+    fs.copyFileSync(this.props.path, path.join(session.staging.path, stagingFile));
+
+    session.addBuildStep(this.artifactId, {
+      type: 'CopyFileTask',
+      parameters: {
+        src: `staging/${stagingFile}`,
+        dest: `assembly/${fileName}` // relative to outdir
+      }
+    });
+
+    for (const env of this.environments) {
+      session.addArtifact(this.artifactId, {
+        type: cxapi.ArtifactType.AwsS3Object,
+        environment: env,
+        properties: {
+          file: fileName // relative to assembly
+        }
+      });
+    }
+  }
+
+  private synthesizeZipDirectory(session: cdk.ISynthesisSession) {
+    const fileName = `${this.fingerprint}.zip`;
+
+    // copy source contents to a staging directory
+    const stagingDir = this.fingerprint;
+    fs.mkdirSync(path.join(session.staging.path, stagingDir));
+    copyDirectory(this.props.path, path.join(session.staging.path, stagingDir));
+
+    session.addBuildStep(this.artifactId, {
+      type: 'ZipDirectoryTask',
+      parameters: {
+        src: `staging/${stagingDir}`,
+        dest: `assembly/${fileName}`, // relative to outdir
+      }
+    });
+
+    for (const env of this.environments) {
+      session.addArtifact(this.artifactId, {
+        type: cxapi.ArtifactType.AwsS3Object,
+        environment: env,
+        properties: {
+          file: fileName // relative to assembly/
+        }
+      });
+    }
+  }
+}
+
+export interface AssetArtifactParameters {
+  bucket: cdk.Parameter;
+  key: cdk.Parameter;
+  sha256: cdk.Parameter;
+}
+
+function validateAssetOnDisk(assetPath: string, packaging: AssetPackaging) {
+  if (!fs.existsSync(assetPath)) {
+    throw new Error(`Cannot find asset at ${assetPath}`);
+  }
+
+  switch (packaging) {
+    case AssetPackaging.ZipDirectory:
+      if (!fs.statSync(assetPath).isDirectory()) {
+        throw new Error(`${assetPath} is expected to be a directory when asset packaging is 'zip'`);
+      }
+      break;
+
+    case AssetPackaging.File:
+      if (!fs.statSync(assetPath).isFile()) {
+        throw new Error(`${assetPath} is expected to be a regular file when asset packaging is 'file'`);
+      }
+      break;
+
+    default:
+      throw new Error(`Unsupported asset packaging format: ${packaging}`);
+  }
+}