fix(appmesh): Move Client Policy from Virtual Service to backend structure

packages/@aws-cdk-containers/ecs-service-extensions/lib/extensions/appmesh.ts

@@ -346,7 +346,7 @@ export class AppMeshExtension extends ServiceExtension {
     // Next update the app mesh config so that the local Envoy
     // proxy on this service knows how to route traffic to
     // nodes from the other service.
-    this.virtualNode.addBackend({ virtualService: otherAppMesh.virtualService });
+    this.virtualNode.addBackend(appmesh.Backend.virtualServiceBackend({ virtualService: otherAppMesh.virtualService }));
   }
 
   private routeSpec(weightedTargets: appmesh.WeightedTarget[], serviceName: string): appmesh.RouteSpec {

packages/@aws-cdk/aws-appmesh/lib/shared-interfaces.ts

@@ -197,31 +197,83 @@ class FileAccessLog extends AccessLog {
 }
 
 /**
- * Represents the properties needed to define a backend
+ * Represents the properties needed to define backend defaults
+ */
+export interface BackendDefaults {
+  /**
+   * Client policy for backend defaults
+   *
+   * @default none
+   */
+  readonly clientPolicy?: ClientPolicy;
+}
+
+/**
+ * Represents the properties needed to define a Virtual Service backend
  */
-export interface Backend {
+export interface VirtualServiceBackendOptions {
   /**
    * The Virtual Service this backend points to
    */
   readonly virtualService: IVirtualService;
 
   /**
-   * Client policy for a backend
+   * Client policy for the backend
    *
    * @default none
    */
   readonly clientPolicy?: ClientPolicy;
 }
 
 /**
- * Represents the properties needed to define backend defaults
+ * Properties for a backend
  */
-export interface BackendDefaults {
+export interface BackendConfig {
   /**
-   * Client policy for backend defaults
-   *
-   * @default none
+   * Config for a Virtual Service backend
    */
-  readonly clientPolicy?: ClientPolicy;
+  readonly virtualServiceBackend: CfnVirtualNode.BackendProperty;
 }
 
+
+/**
+ * Contains static factory methods to create backends
+ */
+export abstract class Backend {
+  /**
+   * Construct a Virtual Service backend
+   */
+  public static virtualServiceBackend(props: VirtualServiceBackendOptions): Backend {
+    return new VirtualServiceBackend(props.virtualService, props.clientPolicy);
+  }
+
+  /**
+   * Return backend config
+   */
+  public abstract bind(_scope: Construct): BackendConfig;
+}
+
+/**
+ * Represents the properties needed to define a Virtual Service backend
+ */
+class VirtualServiceBackend extends Backend {
+
+  constructor (private readonly virtualService: IVirtualService,
+    private readonly clientPolicy: ClientPolicy | undefined) {
+    super();
+  }
+
+  /**
+   * Return config for a Virtual Service backend
+   */
+  public bind(_scope: Construct): BackendConfig {
+    return {
+      virtualServiceBackend: {
+        virtualService: {
+          virtualServiceName: this.virtualService.virtualServiceName,
+          clientPolicy: this.clientPolicy?.bind(_scope).clientPolicy,
+        },
+      },
+    };
+  }
+}

packages/@aws-cdk/aws-appmesh/lib/virtual-node.ts

@@ -215,12 +215,7 @@ export class VirtualNode extends VirtualNodeBase {
    * Add a Virtual Services that this node is expected to send outbound traffic to
    */
   public addBackend(backend: Backend) {
-    this.backends.push({
-      virtualService: {
-        virtualServiceName: backend.virtualService.virtualServiceName,
-        clientPolicy: backend.clientPolicy?.bind(this).clientPolicy,
-      },
-    });
+    this.backends.push(backend.bind(this).virtualServiceBackend);
   }
 }
 

packages/@aws-cdk/aws-appmesh/test/integ.mesh.ts

@@ -46,16 +46,14 @@ const node = mesh.addVirtualNode('node', {
       path: '/check-path',
     },
   })],
-  backends: [
-    {
-      virtualService: virtualService,
-    },
-  ],
+  backends: [appmesh.Backend.virtualServiceBackend({
+    virtualService: virtualService,
+  })],
 });
 
-node.addBackend({
+node.addBackend(appmesh.Backend.virtualServiceBackend({
   virtualService: virtualService2,
-});
+}));
 
 router.addRoute('route-1', {
   routeSpec: appmesh.RouteSpec.http({
@@ -93,11 +91,9 @@ const node2 = mesh.addVirtualNode('node2', {
       certificateChain: 'path/to/cert',
     }),
   },
-  backends: [
-    {
-      virtualService: virtualService3,
-    },
-  ],
+  backends: [appmesh.Backend.virtualServiceBackend({
+    virtualService: virtualService3,
+  })],
 });
 
 const node3 = mesh.addVirtualNode('node3', {

packages/@aws-cdk/aws-appmesh/test/test.mesh.ts

@@ -270,11 +270,9 @@ export = {
           listeners: [appmesh.VirtualNodeListener.http({
             port: 8080,
           })],
-          backends: [
-            {
-              virtualService: service1,
-            },
-          ],
+          backends: [appmesh.Backend.virtualServiceBackend({
+            virtualService: service1,
+          })],
         });
 
         // THEN

packages/@aws-cdk/aws-appmesh/test/test.virtual-node.ts

@@ -29,10 +29,12 @@ export = {
         const node = new appmesh.VirtualNode(stack, 'test-node', {
           mesh,
           serviceDiscovery: appmesh.ServiceDiscovery.dns('test'),
-          backends: [{ virtualService: service1 }],
+          backends: [appmesh.Backend.virtualServiceBackend({
+            virtualService: service1,
+          })],
         });
 
-        node.addBackend({ virtualService: service2 });
+        node.addBackend(appmesh.Backend.virtualServiceBackend({ virtualService: service2 }));
 
         // THEN
         expect(stack).to(haveResourceLike('AWS::AppMesh::VirtualNode', {
@@ -324,13 +326,13 @@ export = {
           virtualServiceProvider: appmesh.VirtualServiceProvider.none(mesh),
         });
 
-        node.addBackend({
+        node.addBackend(appmesh.Backend.virtualServiceBackend({
           virtualService: service1,
           clientPolicy: appmesh.ClientPolicy.fileTrust({
             certificateChain: 'path-to-certificate',
             ports: [8080, 8081],
           }),
-        });
+        }));
 
         // THEN
         expect(stack).to(haveResourceLike('AWS::AppMesh::VirtualNode', {

packages/@aws-cdk/aws-appmesh/test/test.virtual-router.ts

@@ -109,9 +109,9 @@ export = {
         listeners: [appmesh.VirtualNodeListener.http({
           port: 8080,
         })],
-        backends: [{
+        backends: [appmesh.Backend.virtualServiceBackend({
           virtualService: service1,
-        }],
+        })],
       });
 
       router.addRoute('route-1', {
@@ -184,27 +184,27 @@ export = {
         listeners: [appmesh.VirtualNodeListener.http({
           port: 8080,
         })],
-        backends: [{
+        backends: [appmesh.Backend.virtualServiceBackend({
           virtualService: service1,
-        }],
+        })],
       });
       const node2 = mesh.addVirtualNode('test-node2', {
         serviceDiscovery: appmesh.ServiceDiscovery.dns('test'),
         listeners: [appmesh.VirtualNodeListener.http({
           port: 8080,
         })],
-        backends: [{
+        backends: [appmesh.Backend.virtualServiceBackend({
           virtualService: service2,
-        }],
+        })],
       });
       const node3 = mesh.addVirtualNode('test-node3', {
         serviceDiscovery: appmesh.ServiceDiscovery.dns('test'),
         listeners: [appmesh.VirtualNodeListener.http({
           port: 8080,
         })],
-        backends: [{
+        backends: [appmesh.Backend.virtualServiceBackend({
           virtualService: service1,
-        }],
+        })],
       });
 
       router.addRoute('route-1', {
@@ -342,9 +342,9 @@ export = {
         listeners: [appmesh.VirtualNodeListener.http({
           port: 8080,
         })],
-        backends: [{
+        backends: [appmesh.Backend.virtualServiceBackend({
           virtualService: service1,
-        }],
+        })],
       });
 
       router.addRoute('route-tcp-1', {