Update tags support for RouteTable resource (#103)

Description of changes:

- Implemented `updateTags` support for **RouteTable** resource.
- Added e2e tests for update tags.

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.

Author: LikithaVemulapalli

apis/v1alpha1/ack-generate-metadata.yaml

@@ -1,5 +1,5 @@
 ack_generate_info:
-  build_date: "2022-09-16T18:43:47Z"
+  build_date: "2022-09-20T18:05:13Z"
   build_hash: 1da44f4be322eea156ed23a86e33c29da5cede9c
   go_version: go1.18.3
   version: v0.20.1-2-g1da44f4

pkg/resource/route_table/hooks.go

@@ -198,12 +198,19 @@ func (rm *resourceManager) customUpdateRouteTable(
 		if err := rm.syncRoutes(ctx, desired, latest); err != nil {
 			return nil, err
 		}
-		latest, err = rm.sdkFind(ctx, latest)
-		if err != nil {
+	}
+
+	if delta.DifferentAt("Spec.Tags") {
+		if err := rm.syncTags(ctx, desired, latest); err != nil {
 			return nil, err
 		}
 	}
 
+	latest, err = rm.sdkFind(ctx, latest)
+	if err != nil {
+		return nil, err
+	}
+
 	return latest, nil
 }
 
@@ -259,6 +266,105 @@ func removeLocalRoute(
 	return ret
 }
 
+// syncTags used to keep tags in sync by calling Create and Delete Tags API's
+func (rm *resourceManager) syncTags(
+	ctx context.Context,
+	desired *resource,
+	latest *resource,
+) (err error) {
+	rlog := ackrtlog.FromContext(ctx)
+	exit := rlog.Trace("rm.syncTags")
+	defer func(err error) {
+		exit(err)
+	}(err)
+
+	resourceId := []*string{latest.ko.Status.RouteTableID}
+
+	toAdd, toDelete := computeTagsDelta(
+		desired.ko.Spec.Tags, latest.ko.Spec.Tags,
+	)
+
+	if len(toDelete) > 0 {
+		rlog.Debug("removing tags from route table resource", "tags", toDelete)
+		_, err = rm.sdkapi.DeleteTagsWithContext(
+			ctx,
+			&svcsdk.DeleteTagsInput{
+				Resources: resourceId,
+				Tags:      rm.sdkTags(toDelete),
+			},
+		)
+		rm.metrics.RecordAPICall("UPDATE", "DeleteTags", err)
+		if err != nil {
+			return err
+		}
+
+	}
+
+	if len(toAdd) > 0 {
+		rlog.Debug("adding tags to route table resource", "tags", toAdd)
+		_, err = rm.sdkapi.CreateTagsWithContext(
+			ctx,
+			&svcsdk.CreateTagsInput{
+				Resources: resourceId,
+				Tags:      rm.sdkTags(toAdd),
+			},
+		)
+		rm.metrics.RecordAPICall("UPDATE", "CreateTags", err)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// sdkTags converts *svcapitypes.Tag array to a *svcsdk.Tag array
+func (rm *resourceManager) sdkTags(
+	tags []*svcapitypes.Tag,
+) (sdktags []*svcsdk.Tag) {
+
+	for _, i := range tags {
+		sdktag := rm.newTag(*i)
+		sdktags = append(sdktags, sdktag)
+	}
+
+	return sdktags
+}
+
+// computeTagsDelta returns tags to be added and removed from the resource
+func computeTagsDelta(
+	desired []*svcapitypes.Tag,
+	latest []*svcapitypes.Tag,
+) (toAdd []*svcapitypes.Tag, toDelete []*svcapitypes.Tag) {
+
+	desiredTags := map[string]string{}
+	for _, tag := range desired {
+		desiredTags[*tag.Key] = *tag.Value
+	}
+
+	latestTags := map[string]string{}
+	for _, tag := range latest {
+		latestTags[*tag.Key] = *tag.Value
+	}
+
+	for _, tag := range desired {
+		val, ok := latestTags[*tag.Key]
+		if !ok || val != *tag.Value {
+			toAdd = append(toAdd, tag)
+		}
+	}
+
+	for _, tag := range latest {
+		_, ok := desiredTags[*tag.Key]
+		if !ok {
+			toDelete = append(toDelete, tag)
+		}
+	}
+
+	return toAdd, toDelete
+
+}
+
 // updateTagSpecificationsInCreateRequest adds
 // Tags defined in the Spec to CreateRouteTableInput.TagSpecification
 // and ensures the ResourceType is always set to 'route-table'

pkg/resource/route_table/sdk.go

@@ -30,6 +30,30 @@ func (rm *resourceManager) new{{ $memberRefName }}(
 	return res
 }
 
+{{/* Helper method for tag support */}}
+{{- range $specFieldName, $specField := $CRD.Config.Resources.RouteTable.Fields }}
+{{- if $specField.From }}
+{{- $operationName := $specField.From.Operation }}
+{{- $operation := (index $SDKAPI.API.Operations $operationName) -}}
+{{- range $rtRefName, $rtMemberRefs := $operation.InputRef.Shape.MemberRefs -}}
+{{- if eq $rtRefName "Tags" }}
+{{- $rtRef := $rtMemberRefs.Shape.MemberRef }}
+{{- $rtRefName = "Tag" }}
+
+func (rm *resourceManager) new{{ $rtRefName }}(
+	    c svcapitypes.{{ $rtRefName }},
+) *svcsdk.{{ $rtRefName }} {
+	res := &svcsdk.{{ $rtRefName }}{}
+{{ GoCodeSetSDKForStruct $CRD "" "res" $rtRef "" "c" 1 }}
+	return res
+}
+
+{{- end }}
+
+{{- end }}
+{{- end }}
+{{- end }}
+
 {{- end }}
 {{- end }}
 {{- end }}

templates/hooks/route_table/sdk_file_end.go.tpl

@@ -6,4 +6,7 @@ spec:
   routes:
     - destinationCIDRBlock: $DEST_CIDR_BLOCK
       gatewayID: $IGW_ID
-  vpcID: $VPC_ID
+  vpcID: $VPC_ID
+  tags:
+    - key: $TAG_KEY
+      value: $TAG_VALUE

test/e2e/resources/route_table.yaml

@@ -88,6 +88,17 @@ def get_ami_id(ec2_client):
     except Exception as e:
         logging.debug(e)
 
+def contains_tag(resource, tag):
+    try:
+        tag_key, tag_val = tag.popitem()
+        for t in resource["spec"]["tags"]:
+            if t["key"] == tag_key and t["value"] == tag_val:
+                return True
+    except:
+        pass
+
+    return False
+
 
 @pytest.fixture
 def instance(ec2_client):
@@ -178,17 +189,17 @@ def test_crud_tags(self, ec2_client, instance):
         assert instance is not None
 
         # Check tags exist for Instance resource
-        assert resource["spec"]["tags"][0]["key"] == INSTANCE_TAG_KEY
-        assert resource["spec"]["tags"][0]["value"] == INSTANCE_TAG_VAL
+        assert contains_tag(resource, {INSTANCE_TAG_KEY: INSTANCE_TAG_VAL})
+
+        # Fetch all tags including ACK tags applied by default
+        new_tags = resource['spec']['tags']
 
         # New pair of tags
-        new_tags = [
-                {
+        new_tag = {
                     "key": "updatedtagkey",
                     "value": "updatedtagvalue",
-                }
-               
-            ]
+        }
+        new_tags.append(new_tag)
 
         # Patch the Instance, updating the tags with new pair
         updates = {
@@ -203,12 +214,12 @@ def test_crud_tags(self, ec2_client, instance):
 
         # Assert tags are updated for Instance resource
         resource = k8s.get_resource(ref)
-        assert resource["spec"]["tags"][0]["key"] == "updatedtagkey"
-        assert resource["spec"]["tags"][0]["value"] == "updatedtagvalue"
+        assert contains_tag(resource, {"updatedtagkey": "updatedtagvalue"})
 
+        new_tags = []
         # Patch the Instance resource, deleting the tags
         updates = {
-                "spec": {"tags": []},
+                "spec": {"tags": new_tags},
         }
 
         k8s.patch_custom_resource(ref, updates)
@@ -219,7 +230,7 @@ def test_crud_tags(self, ec2_client, instance):
 
         # Assert tags are deleted
         resource = k8s.get_resource(ref)
-        assert len(resource['spec']['tags']) == 0
+        assert contains_tag(resource, {"updatedtagkey": "updatedtagvalue"}) is False
 
         # Delete k8s resource
         _, deleted = k8s.delete_custom_resource(ref)

test/e2e/tests/test_instance.py

@@ -30,9 +30,21 @@
 DEFAULT_WAIT_AFTER_SECONDS = 5
 CREATE_WAIT_AFTER_SECONDS = 10
 DELETE_WAIT_AFTER_SECONDS = 10
+MODIFY_WAIT_AFTER_SECONDS = 10
+
+def contains_tag(resource, tag):
+    try:
+        tag_key, tag_val = tag.popitem()
+        for t in resource["spec"]["tags"]:
+            if t["key"] == tag_key and t["value"] == tag_val:
+                return True
+    except:
+        pass
+
+    return False
 
 @pytest.fixture
-def simple_route_table():
+def simple_route_table(request):
     replacements = REPLACEMENT_VALUES.copy()
     resource_name = random_suffix_name("route-table-test", 24)
     test_vpc = get_bootstrap_resources().SharedTestVPC
@@ -45,6 +57,14 @@ def simple_route_table():
     replacements["IGW_ID"] = igw_id
     replacements["DEST_CIDR_BLOCK"] = test_cidr_block
 
+    marker = request.node.get_closest_marker("resource_data")
+    if marker is not None:
+        data = marker.args[0]
+        if 'tag_key' in data:
+            replacements["TAG_KEY"] = data["tag_key"]
+        if 'tag_value' in data:
+            replacements["TAG_VALUE"] = data["tag_value"]
+
     # Load RouteTable CR
     resource_data = load_ec2_resource(
         "route_table",
@@ -141,5 +161,71 @@ def test_crud_route(self, ec2_client, simple_route_table):
 
         time.sleep(DELETE_WAIT_AFTER_SECONDS)
 
+        # Check Route Table no longer exists in AWS
+        ec2_validator.assert_route_table(resource_id, exists=False)
+    
+    @pytest.mark.resource_data({'tag_key': 'initialtagkey', 'tag_value': 'initialtagvalue'})
+    def test_crud_tags(self, ec2_client, simple_route_table):
+        (ref, cr) = simple_route_table
+        
+        resource = k8s.get_resource(ref)
+        resource_id = cr["status"]["routeTableID"]
+
+        time.sleep(CREATE_WAIT_AFTER_SECONDS)
+
+        # Check Route Table exists in AWS
+        ec2_validator = EC2Validator(ec2_client)
+        ec2_validator.assert_route_table(resource_id)
+        
+        # Check tags exist for Route Table resource
+        assert contains_tag(resource, {"initialtagkey": "initialtagvalue"})
+
+        # Fetch all tags including ACK tags applied by default
+        new_tags = resource['spec']['tags']
+
+        # New tag
+        new_tag = {
+                    "key": "updatedtagkey",
+                    "value": "updatedtagvalue",
+         }
+        new_tags.append(new_tag)      
+
+        # Patch the Route Table, updating the tags with new pair
+        updates = {
+            "spec": {"tags": new_tags},
+        }
+
+        k8s.patch_custom_resource(ref, updates)
+        time.sleep(MODIFY_WAIT_AFTER_SECONDS)
+
+        # Check resource synced successfully
+        assert k8s.wait_on_condition(ref, "ACK.ResourceSynced", "True", wait_periods=5)
+        
+        # Assert tags are updated for Route Table resource
+        resource = k8s.get_resource(ref)
+        assert contains_tag(resource, {"updatedtagkey": "updatedtagvalue"})
+
+        new_tags = []
+        # Patch the Route Table resource, deleting the tags
+        updates = {
+                "spec": {"tags": new_tags},
+        }
+
+        k8s.patch_custom_resource(ref, updates)
+        time.sleep(MODIFY_WAIT_AFTER_SECONDS)
+
+        # Check resource synced successfully
+        assert k8s.wait_on_condition(ref, "ACK.ResourceSynced", "True", wait_periods=5)
+        
+        # Assert tags are deleted
+        resource = k8s.get_resource(ref)
+        assert contains_tag(resource, {"updatedtagkey": "updatedtagvalue"}) is False
+
+        # Delete k8s resource
+        _, deleted = k8s.delete_custom_resource(ref)
+        assert deleted is True
+
+        time.sleep(DELETE_WAIT_AFTER_SECONDS)
+
         # Check Route Table no longer exists in AWS
         ec2_validator.assert_route_table(resource_id, exists=False)