Merge branch 'master' into add-vpc-arn

packages/@aws-cdk/aws-cloudfront/lib/cache-policy.ts

@@ -85,9 +85,13 @@ export interface CachePolicyProps {
  * A Cache Policy configuration.
  *
  * @resource AWS::CloudFront::CachePolicy
+ * @link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-cache-policies.html
  */
 export class CachePolicy extends Resource implements ICachePolicy {
-
+  /**
+   * This policy is designed for use with an origin that is an AWS Amplify web app.
+   */
+  public static readonly AMPLIFY = CachePolicy.fromManagedCachePolicy('2e54312d-136d-493c-8eb9-b001f22f67d2');
   /**
    * Optimize cache efficiency by minimizing the values that CloudFront includes in the cache key.
    * Query strings and cookies are not included in the cache key, and only the normalized 'Accept-Encoding' header is included.

packages/@aws-cdk/aws-ec2/lib/vpc-lookup.ts

@@ -48,4 +48,11 @@ export interface VpcLookupOptions {
    * @default aws-cdk:subnet-name
    */
   readonly subnetGroupNameTag?: string;
+
+  /**
+   * Optional to override inferred region
+   *
+   * @default Current stack's environment region
+   */
+  readonly region?: string;
 }

packages/@aws-cdk/aws-ec2/lib/vpc.ts

@@ -1129,9 +1129,15 @@ export class Vpc extends VpcBase {
       filter.isDefault = options.isDefault ? 'true' : 'false';
     }
 
+    const overrides: {[key: string]: string} = {};
+    if (options.region) {
+      overrides.region = options.region;
+    }
+
     const attributes: cxapi.VpcContextResponse = ContextProvider.getValue(scope, {
       provider: cxschema.ContextProvider.VPC_PROVIDER,
       props: {
+        ...overrides,
         filter,
         returnAsymmetricSubnets: true,
         subnetGroupNameTag: options.subnetGroupNameTag,

packages/@aws-cdk/aws-ec2/test/vpc.from-lookup.test.ts

@@ -250,6 +250,24 @@ describe('vpc from lookup', () => {
       restoreContextProvider(previous);
 
     });
+    test('passes account and region', () => {
+      const previous = mockVpcContextProviderWith({
+        vpcId: 'vpc-1234',
+        subnetGroups: [],
+      }, options => {
+        expect(options.region).toEqual('region-1234');
+      });
+
+      const stack = new Stack();
+      const vpc = Vpc.fromLookup(stack, 'Vpc', {
+        vpcId: 'vpc-1234',
+        region: 'region-1234',
+      });
+
+      expect(vpc.vpcId).toEqual('vpc-1234');
+
+      restoreContextProvider(previous);
+    });
   });
 });
 

packages/@aws-cdk/aws-route53/lib/vpc-endpoint-service-domain-name.ts

@@ -46,6 +46,11 @@ export class VpcEndpointServiceDomainName extends CoreConstruct {
   // Track all domain names created, so someone doesn't accidentally associate two domains with a single service
   private static readonly endpointServicesMap: { [endpointService: string]: string} = {};
 
+  /**
+   * The domain name associated with the private DNS configuration
+   */
+  public domainName: string;
+
   // The way this class works is by using three custom resources and a TxtRecord in conjunction
   // The first custom resource tells the VPC endpoint service to use the given DNS name
   // The VPC endpoint service will then say:
@@ -58,16 +63,16 @@ export class VpcEndpointServiceDomainName extends CoreConstruct {
 
     const serviceUniqueId = Names.nodeUniqueId(props.endpointService.node);
     const serviceId = props.endpointService.vpcEndpointServiceId;
-    const privateDnsName = props.domainName;
+    this.domainName = props.domainName;
 
     // Make sure a user doesn't accidentally add multiple domains
     this.validateProps(props);
 
-    VpcEndpointServiceDomainName.endpointServicesMap[serviceUniqueId] = privateDnsName;
+    VpcEndpointServiceDomainName.endpointServicesMap[serviceUniqueId] = this.domainName;
     VpcEndpointServiceDomainName.endpointServices.push(props.endpointService);
 
     // Enable Private DNS on the endpoint service and retrieve the AWS-generated configuration
-    const privateDnsConfiguration = this.getPrivateDnsConfiguration(serviceUniqueId, serviceId, privateDnsName);
+    const privateDnsConfiguration = this.getPrivateDnsConfiguration(serviceUniqueId, serviceId, this.domainName);
 
     // Tell AWS to verify that this account owns the domain attached to the service
     this.verifyPrivateDnsConfiguration(privateDnsConfiguration, props.publicHostedZone);

packages/@aws-cdk/aws-route53/test/vpc-endpoint-service-domain-name.test.ts

@@ -264,4 +264,20 @@ test('throws if creating multiple domains for a single service', () => {
       publicHostedZone: zone,
     });
   }).toThrow(/Cannot create a VpcEndpointServiceDomainName for service/);
+});
+
+
+test('endpoint domain name property equals input domain name', () => {
+  // GIVEN
+  vpces = new VpcEndpointService(stack, 'NameTest', {
+    vpcEndpointServiceLoadBalancers: [nlb],
+  });
+
+  const dn = new VpcEndpointServiceDomainName(stack, 'EndpointDomain', {
+    endpointService: vpces,
+    domainName: 'name-test.aws-cdk.dev',
+    publicHostedZone: zone,
+  });
+  expect(dn.domainName).toEqual('name-test.aws-cdk.dev');
+
 });