x-elbv2 - Fix index at which to pull the service name (#787)

* Fix index at which to pull the service name. Otherwise pulls the port
* Fixing targets names vs service names using ports in service name
* Allowing for ProtocolVersion to be set on TargetGroup [Enum in spec]

Author: JohnPreston

ecs_composex/compose/x_resources/services_resources.py

@@ -34,10 +34,10 @@ def __init__(
     ):
         self.services = []
         self.families_targets: list[tuple] = []
-        self.families_scaling = []
+        self.families_scaling: list = []
         self.arn_parameter = None
         super().__init__(name, definition, module, settings)
-        self.services = set_else_none("Services", definition, alt_value={})
+        self.services: dict = set_else_none("Services", definition, alt_value={})
         self.set_services_targets(settings)
         self.set_services_scaling(settings)
 

ecs_composex/elbv2/elbv2_ecs.py

@@ -524,6 +524,9 @@ def define_service_target_group(
         if not keyisset("protocol", target_definition)
         else target_definition["protocol"]
     )
+    props["ProtocolVersion"] = set_else_none(
+        "ProtocolVersion", target_definition, Ref(AWS_NO_VALUE)
+    )
     props["TargetType"] = "ip"
     import_target_group_attributes(props, target_definition, resource)
     validate_props_and_service_definition(props, service)
@@ -606,20 +609,25 @@ def handle_services_association(
     identified = []
     for target in load_balancer.families_targets:
         family: ComposeFamily = target[0]
-        print("TARGET?", target)
+        target_service: ComposeService = target[1]
+        service_def: dict = target[2]
+        target_combo_name: str = target[3]
         if target[1].launch_type == "EXTERNAL":
             LOG.error(
                 f"x-elbv2.{load_balancer.name} - Target family {family.name} uses EXTERNAL launch type. Ignoring"
             )
             continue
-        tgt_group = define_service_target_group_definition(
-            load_balancer, family, target[1], target[2], res_root_stack
+        tgt_group: ComposeTargetGroup = define_service_target_group_definition(
+            load_balancer, family, target_service, service_def, res_root_stack
         )
         for service_name, service in load_balancer.services.items():
-            target_name = f"{family.name}:{target[1].name}"
+            target_name = f"{family.name}:{target_service.name}"
             if target_name not in service_name:
                 continue
-            if target_name == service_name and tgt_group.Port == int(service["port"]):
+            if (service_name == target_combo_name) or (
+                service_name.find(target_name) == 0
+                and tgt_group.Port == int(service["port"])
+            ):
                 service["target_arn"] = Ref(tgt_group)
                 identified.append(True)
                 break
@@ -629,7 +637,6 @@ def handle_services_association(
             f"{load_balancer.module.res_key}.{load_balancer.name} - No services found as targets. Skipping association"
         )
         return
-
     for listener in load_balancer.new_listeners:
         listener.map_lb_target_groups_service_to_listener_targets(load_balancer)
 
@@ -657,13 +664,15 @@ def handle_target_groups_association(
     add_outputs(template, load_balancer.outputs)
     _targets = set_else_none("TargetGroups", load_balancer.definition, {})
     if not _targets:
-        print("NO TARGET GROUPS")
         return
     for _target_name, _target_def in _targets.items():
         props = {}
         set_healthcheck_definition(props, _target_def, "HealthCheck")
         props["Port"] = _target_def["Port"]
         props["Protocol"] = _target_def["Protocol"]
+        props["ProtocolVersion"] = set_else_none(
+            "ProtocolVersion", _target_def, Ref(AWS_NO_VALUE)
+        )
         props["TargetType"] = "ip"
         import_target_group_attributes(props, _target_def, load_balancer)
         _tgt_group = MergedTargetGroup(
@@ -686,7 +695,6 @@ def handle_target_groups_association(
             listener.map_target_group_to_listener(_tgt_group)
 
         for listener in load_balancer.lookup_listeners.values():
-            print("MAPPING TARGET TO LISTENER", _tgt_group, listener)
             listener.map_target_group_to_listener(_tgt_group)
 
     for listener_port, listener_def in load_balancer.lookup_listeners.items():

ecs_composex/elbv2/elbv2_stack/elbv2.py

@@ -156,10 +156,15 @@ def set_listeners(self, template):
                             f" - Target {target['name']} is not a valid value. Must match",
                             LISTENER_TARGET_RE.pattern,
                         )
-                    if (
+                    simple_family: str = (
                         f"{target_parts.group('family')}:{target_parts.group('container')}"
-                        not in self.services
-                    ):
+                    )
+                    family_id: str = (
+                        simple_family + ":" + target_parts.group("port")
+                        if target_parts.group("port")
+                        else simple_family
+                    )
+                    if family_id not in self.services:
                         listener_def["Targets"].remove(target)
             if keyisset("Targets", listener_def) or keyisset(
                 "DefaultActions", listener_def
@@ -199,8 +204,9 @@ def set_services_targets(self, settings):
             LOG.debug(f"{self.module.res_key}.{self.name} No Services defined.")
             return
         for family_combo_name, service_def in self.services.items():
-            service_name = family_combo_name.split(":")[-1]
-            family_name = NONALPHANUM.sub("", family_combo_name.split(":")[0])
+            family_combo_parts: list[str] = family_combo_name.split(":")
+            family_name: str = NONALPHANUM.sub("", family_combo_parts[0])
+            service_name: str = family_combo_parts[1]
             LOG.info(
                 f"{self.module.res_key}.{self.name} - Adding target {family_name}:{service_name}"
             )
@@ -229,7 +235,7 @@ def set_services_targets(self, settings):
                                 f_service.family,
                                 f_service,
                                 service_def,
-                                f"{family_combo_name}{service_def['port']}",
+                                family_combo_name,
                             )
                         )
                         break

ecs_composex/elbv2/elbv2_stack/elbv2_listener/lookup_listener.py

@@ -11,7 +11,7 @@
     from troposphere import Template
 
 from compose_x_common.aws.elasticloadbalancing import LB_V2_LISTENER_ARN_RE
-from compose_x_common.compose_x_common import keyisset, keypresent, set_else_none
+from compose_x_common.compose_x_common import keyisset, set_else_none
 from troposphere import Ref
 from troposphere.cognito import UserPoolClient
 from troposphere.elasticloadbalancingv2 import ListenerRule
@@ -21,16 +21,10 @@
 from ecs_composex.common.logging import LOG
 from ecs_composex.elbv2.elbv2_stack.helpers import (
     LISTENER_TARGET_RE,
-    add_acm_certs_arn,
     define_actions,
-    define_listener_rules_actions,
     define_target_conditions,
-    handle_default_actions,
-    handle_non_default_services,
     import_cognito_pool,
-    import_new_acm_certs,
     map_service_target,
-    tea_pot,
     validate_duplicate_targets,
 )
 from ecs_composex.resources_import import import_record_properties
@@ -86,7 +80,6 @@ def __init__(self, lb: Elbv2, port: int, definition: dict):
             and isinstance(self.definition[self.targets_keys], list)
             else []
         )
-        print("PROPS?", self.properties)
 
     def __repr__(self):
         return self.arn
@@ -216,13 +209,11 @@ def map_lb_target_groups_service_to_listener_targets(self, lb: Elbv2) -> None:
                 )
 
     def map_target_group_to_listener(self, target_group: MergedTargetGroup) -> None:
-        print("MAPPING TARGET TO LOOKUP LISTENER")
         if not self.services:
             LOG.warning(
                 f"{self.lb.module.res_key}.{self.lb.name} - Listener {self.Port} - No Targets defined."
             )
             return
-        print("TARGET GROUP??", target_group)
         for _tgt_group in self.services:
             _tgt_name = _tgt_group["name"]
             if _tgt_name == target_group.name:

ecs_composex/elbv2/x-elbv2.spec.json

@@ -283,6 +283,15 @@
         },
         "TargetGroupAttributes": {
           "$ref": "#/definitions/TargetGroupAttributeDef"
+        },
+        "ProtocolVersion": {
+          "type": "string",
+          "description": "https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-targetgroup.html#cfn-elasticloadbalancingv2-targetgroup-protocolversion",
+          "enum": [
+            "GRPC",
+            "HTTP1",
+            "HTTP2"
+          ]
         }
       }
     },