fix(aws-elasticloadbalancingv2): fix rule dependency

packages/@aws-cdk/aws-ecs/lib/base/base-service.ts

@@ -215,7 +215,7 @@ export abstract class BaseService extends cdk.Construct
       containerPort: this.taskDefinition.defaultContainer!.containerPort,
     });
 
-    this.resource.addDependency(targetGroup.listenerDependency());
+    this.resource.addDependency(targetGroup.loadBalancerDependency());
 
     const targetType = this.taskDefinition.networkMode === NetworkMode.AwsVpc ? elbv2.TargetType.Ip : elbv2.TargetType.Instance;
     return { targetType };
@@ -239,4 +239,4 @@ export abstract class BaseService extends cdk.Construct
 /**
  * The port range to open up for dynamic port mapping
  */
-const EPHEMERAL_PORT_RANGE = new ec2.TcpPortRange(32768, 65535);
+const EPHEMERAL_PORT_RANGE = new ec2.TcpPortRange(32768, 65535);

packages/@aws-cdk/aws-elasticloadbalancingv2/README.md

@@ -196,10 +196,10 @@ group rules.
 If your load balancer target requires that the TargetGroup has been
 associated with a LoadBalancer before registration can happen (such as is the
 case for ECS Services for example), take a resource dependency on
-`targetGroup.listenerDependency()` as follows:
+`targetGroup.loadBalancerDependency()` as follows:
 
 ```ts
 // Make sure that the listener has been created, and so the TargetGroup
 // has been associated with the LoadBalancer, before 'resource' is created.
-resourced.addDependency(targetGroup.listenerDependency());
-```
+resourced.addDependency(targetGroup.loadBalancerDependency());
+```

packages/@aws-cdk/aws-elasticloadbalancingv2/lib/alb/application-listener-rule.ts

@@ -127,7 +127,7 @@ export class ApplicationListenerRule extends cdk.Construct implements cdk.IDepen
       targetGroupArn: targetGroup.targetGroupArn,
       type: 'forward'
     });
-    targetGroup.registerListener(this.listener);
+    targetGroup.registerListener(this.listener, this);
   }
 
   /**
@@ -142,4 +142,4 @@ export class ApplicationListenerRule extends cdk.Construct implements cdk.IDepen
     }
     return ret;
   }
-}
+}

packages/@aws-cdk/aws-elasticloadbalancingv2/lib/alb/application-target-group.ts

@@ -137,14 +137,14 @@ export class ApplicationTargetGroup extends BaseTargetGroup {
    *
    * Don't call this directly. It will be called by listeners.
    */
-  public registerListener(listener: IApplicationListener) {
+  public registerListener(listener: IApplicationListener, dependable?: cdk.IDependable) {
     // Notify this listener of all connectables that we know about.
     // Then remember for new connectables that might get added later.
     for (const member of this.connectableMembers) {
       listener.registerConnectable(member.connectable, member.portRange);
     }
     this.listeners.push(listener);
-    this.dependableListeners.push(listener);
+    this.loadBalancerAssociationDependencies.push(dependable || listener);
   }
 }
 
@@ -172,18 +172,18 @@ export interface IApplicationTargetGroup extends ITargetGroup {
    *
    * Don't call this directly. It will be called by listeners.
    */
-  registerListener(listener: IApplicationListener): void;
+  registerListener(listener: IApplicationListener, dependable?: cdk.IDependable): void;
 }
 
 /**
  * An imported application target group
  */
 class ImportedApplicationTargetGroup extends BaseImportedTargetGroup implements IApplicationTargetGroup {
-  public registerListener(_listener: IApplicationListener) {
+  public registerListener(_listener: IApplicationListener, _dependable?: cdk.IDependable) {
     // Nothing to do, we know nothing of our members
   }
 
-  public listenerDependency(): cdk.IDependable {
+  public loadBalancerDependency(): cdk.IDependable {
     return new LazyDependable([]);
   }
 }

packages/@aws-cdk/aws-elasticloadbalancingv2/lib/nlb/network-target-group.ts

@@ -71,7 +71,7 @@ export class NetworkTargetGroup extends BaseTargetGroup {
    * Don't call this directly. It will be called by listeners.
    */
   public registerListener(listener: INetworkListener) {
-    this.dependableListeners.push(listener);
+    this.loadBalancerAssociationDependencies.push(listener);
   }
 }
 
@@ -96,7 +96,7 @@ class ImportedNetworkTargetGroup extends BaseImportedTargetGroup implements INet
     // Nothing to do, we know nothing of our members
   }
 
-  public listenerDependency(): cdk.IDependable {
+  public loadBalancerDependency(): cdk.IDependable {
     return new LazyDependable([]);
   }
 }

packages/@aws-cdk/aws-elasticloadbalancingv2/lib/shared/base-target-group.ts

@@ -147,9 +147,9 @@ export abstract class BaseTargetGroup extends cdk.Construct implements ITargetGr
   protected readonly defaultPort: string;
 
   /**
-   * List of listeners routing to this target group
+   * List of dependables that need to be depended on to ensure the TargetGroup is associated to a load balancer
    */
-  protected readonly dependableListeners = new Array<cdk.IDependable>();
+  protected readonly loadBalancerAssociationDependencies = new Array<cdk.IDependable>();
 
   /**
    * Attributes of this target group
@@ -249,10 +249,10 @@ export abstract class BaseTargetGroup extends cdk.Construct implements ITargetGr
   }
 
   /**
-   * Return an object to depend on the listeners added to this target group
+   * Return an object to depend on this TargetGroup being attached to a load balancer
    */
-  public listenerDependency(): cdk.IDependable {
-    return new LazyDependable(this.dependableListeners);
+  public loadBalancerDependency(): cdk.IDependable {
+    return new LazyDependable(this.loadBalancerAssociationDependencies);
   }
 
   /**
@@ -297,7 +297,7 @@ export interface ITargetGroup {
   /**
    * Return an object to depend on the listeners added to this target group
    */
-  listenerDependency(): cdk.IDependable;
+  loadBalancerDependency(): cdk.IDependable;
 }
 
 /**

packages/@aws-cdk/aws-elasticloadbalancingv2/test/alb/test.listener.ts

@@ -345,7 +345,7 @@ export = {
 
     // WHEN
     const resource = new cdk.Resource(stack, 'SomeResource', { type: 'Test::Resource' });
-    resource.addDependency(group.listenerDependency());
+    resource.addDependency(group.loadBalancerDependency());
 
     loadBalancer.addListener('Listener', {
       port: 80,
@@ -363,5 +363,40 @@ export = {
     }, MatchStyle.SUPERSET);
 
     test.done();
-  }
+  },
+
+  'Can add dependency on ListenerRule via TargetGroup'(test: Test) {
+    // GIVEN
+    const stack = new cdk.Stack();
+    const vpc = new ec2.VpcNetwork(stack, 'VPC');
+    const loadBalancer = new elbv2.ApplicationLoadBalancer(stack, 'LoadBalancer', { vpc });
+    const group1 = new elbv2.ApplicationTargetGroup(stack, 'TargetGroup1', { vpc, port: 80 });
+    const group2 = new elbv2.ApplicationTargetGroup(stack, 'TargetGroup2', { vpc, port: 80 });
+    const listener = loadBalancer.addListener('Listener', {
+      port: 80,
+      defaultTargetGroups: [group1]
+    });
+
+    // WHEN
+    const resource = new cdk.Resource(stack, 'SomeResource', { type: 'Test::Resource' });
+    resource.addDependency(group2.loadBalancerDependency());
+
+    listener.addTargetGroups('SecondGroup', {
+      pathPattern: '/bla',
+      priority: 10,
+      targetGroups: [group2]
+    });
+
+    // THEN
+    expect(stack).toMatch({
+      Resources: {
+        SomeResource: {
+          Type: "Test::Resource",
+          DependsOn: ["LoadBalancerListenerSecondGroupRuleF5FDC196"]
+        }
+      }
+    }, MatchStyle.SUPERSET);
+
+    test.done();
+  },
 };

packages/@aws-cdk/aws-elasticloadbalancingv2/test/nlb/test.listener.ts

@@ -128,7 +128,7 @@ export = {
     const resource = new cdk.Resource(stack, 'MyResource', {
       type: 'SomeResource',
     });
-    resource.addDependency(group.listenerDependency());
+    resource.addDependency(group.loadBalancerDependency());
 
     // THEN
     expect(stack).toMatch({