temp

Author: rushmash91

test/e2e/bootstrap_resources.py

@@ -4,7 +4,7 @@
 # not use this file except in compliance with the License. A copy of the
 # License is located at
 #
-#	 http://aws.amazon.com/apache2.0/
+# http://aws.amazon.com/apache2.0/
 #
 # or in the "license" file accompanying this file. This file is distributed
 # on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
@@ -16,79 +16,33 @@
 """
 
 from dataclasses import dataclass
+from acktest.bootstrapping import Resources
 from e2e import bootstrap_directory
-import yaml
-import logging
-from pathlib import Path
+
 
 @dataclass
-class TestBootstrapResources:
-    SnsTopic1: str
-    SnsTopic2: str
-    SecurityGroup1: str
-    SecurityGroup2: str
-    UserGroup1: str
-    UserGroup2: str
+class TestBootstrapResources(Resources):
+    # For test_snapshot.py and test_replicationgroup.py
+    Snapshot: str
     KmsKeyID: str
-    SnapshotName: str
+
+    # For test_usergroup.py
     NonDefaultUser: str
-    CWLogGroup1: str
-    CWLogGroup2: str
-    CPGName: str
 
     def replacement_dict(self):
         return {
-            "SNS_TOPIC_ARN": self.SnsTopic1,
-            "SNS_TOPIC_ARN_2": self.SnsTopic2,
-            "SG_ID": self.SecurityGroup1,
-            "SG_ID_2": self.SecurityGroup2,
-            "USERGROUP_ID": self.UserGroup1,
-            "USERGROUP_ID_2": self.UserGroup2,
+            "SNAPSHOT_NAME": self.Snapshot,
             "KMS_KEY_ID": self.KmsKeyID,
-            "SNAPSHOT_NAME": self.SnapshotName,
             "NON_DEFAULT_USER": self.NonDefaultUser,
-            "LOG_GROUP": self.CWLogGroup1,
-            "LOG_GROUP_2": self.CWLogGroup2,
-            "CACHE_PARAMETER_GROUP_NAME": self.CPGName
         }
 
+
 _bootstrap_resources = None
 
 
-def get_bootstrap_resources(bootstrap_file_name: str = "bootstrap.yaml"):
+def get_bootstrap_resources(bootstrap_file_name: str = "bootstrap.pkl") -> TestBootstrapResources:
     global _bootstrap_resources
     if _bootstrap_resources is None:
-        _bootstrap_resources = TestBootstrapResources(
-            **read_bootstrap_config(bootstrap_directory, bootstrap_file_name=bootstrap_file_name),
-        )
+        _bootstrap_resources = TestBootstrapResources.deserialize(
+            bootstrap_directory, bootstrap_file_name=bootstrap_file_name)
     return _bootstrap_resources
-
-
-def write_bootstrap_config(bootstrap: dict, output_path: Path, bootstrap_file_name: str = "bootstrap.yaml"):
-    """ Dumps the bootstrap object into a YAML file at a given path.
-
-    Args:
-        bootstrap: The bootstrap object.
-        output_path: The directory in which to dump the bootstrap yaml.
-        bootstrap_file_name: The name of the created bootstrap yaml file.
-    """
-    path =  output_path / bootstrap_file_name
-    logging.info(f"Wrote bootstrap to {path}")
-    with open(path, "w") as stream:
-        yaml.safe_dump(bootstrap, stream)
-
-
-def read_bootstrap_config(config_dir: Path, bootstrap_file_name: str = "bootstrap.yaml") -> dict:
-    """ Reads a bootstrap dictionary from a given bootstrap file.
-
-    Args:
-        config_dir: The directory in which the bootstrap yaml exists.
-        bootstrap_file_name: The name of the created bootstrap yaml file.
-
-    Returns:
-        dict: The bootstrap dictionary read from the file.
-    """
-    path = config_dir / bootstrap_file_name
-    with open(path, "r") as stream:
-        bootstrap = yaml.safe_load(stream)
-    return bootstrap

test/e2e/service_bootstrap.py

@@ -4,7 +4,7 @@
 # not use this file except in compliance with the License. A copy of the
 # License is located at
 #
-#	 http://aws.amazon.com/apache2.0/
+# http://aws.amazon.com/apache2.0/
 #
 # or in the "license" file accompanying this file. This file is distributed
 # on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
@@ -26,6 +26,7 @@
 from e2e.util import wait_usergroup_active, wait_snapshot_available
 from e2e.bootstrap_resources import TestBootstrapResources, write_bootstrap_config
 
+
 def create_sns_topic() -> str:
     topic_name = random_suffix_name("ack-sns-topic", 32)
 
@@ -36,35 +37,42 @@ def create_sns_topic() -> str:
     return response['TopicArn']
 
 # create an EC2 VPC security group from the default VPC (not an ElastiCache security group)
+
+
 def create_security_group() -> str:
     region = get_region()
     account_id = get_account_id()
 
     ec2 = boto3.client("ec2")
-    vpc_response = ec2.describe_vpcs(Filters=[{"Name": "isDefault", "Values": ["true"]}])
+    vpc_response = ec2.describe_vpcs(
+        Filters=[{"Name": "isDefault", "Values": ["true"]}])
     if len(vpc_response['Vpcs']) == 0:
-        raise ValueError(f"Default VPC not found for account {account_id} in region {region}")
+        raise ValueError(
+            f"Default VPC not found for account {account_id} in region {region}")
     default_vpc_id = vpc_response['Vpcs'][0]['VpcId']
 
     sg_name = random_suffix_name("ack-security-group", 32)
     sg_description = "Security group for ACK ElastiCache tests"
-    sg_response = ec2.create_security_group(GroupName=sg_name, VpcId=default_vpc_id, Description=sg_description)
+    sg_response = ec2.create_security_group(
+        GroupName=sg_name, VpcId=default_vpc_id, Description=sg_description)
     logging.info(f"Created VPC Security Group {sg_response['GroupId']}")
 
     return sg_response['GroupId']
 
+
 def create_user_group() -> str:
     ec = boto3.client("elasticache")
 
     usergroup_id = random_suffix_name("ack-ec-usergroup", 32)
     _ = ec.create_user_group(UserGroupId=usergroup_id,
-                                    Engine="Redis",
-                                    UserIds=["default"])
+                             Engine="Redis",
+                             UserIds=["default"])
     logging.info(f"Creating ElastiCache User Group {usergroup_id}")
     assert wait_usergroup_active(usergroup_id)
 
     return usergroup_id
 
+
 def create_kms_key() -> str:
     kms = boto3.client("kms")
 
@@ -75,6 +83,8 @@ def create_kms_key() -> str:
     return key_id
 
 # create a cache cluster, snapshot it, and return the snapshot name
+
+
 def create_cc_snapshot():
     ec = boto3.client("elasticache")
 
@@ -95,6 +105,7 @@ def create_cc_snapshot():
         SnapshotName=snapshot_name
     )
     assert wait_snapshot_available(snapshot_name)
+    logging.info(f"Created snapshot {snapshot_name}")
 
     return snapshot_name
 
@@ -103,13 +114,14 @@ def create_non_default_user() -> str:
     ec = boto3.client("elasticache")
     user_id = random_suffix_name("ackecuser", 32)
 
-    _ = ec.create_user(UserId=user_id,
-                       UserName="ACKNonDefaultUser",
-                       Engine="Redis",
-                       NoPasswordRequired=True,
-                       AccessString="on -@all")
-
-    logging.info(f"Creating ElastiCache non default User {user_id}")
+    _ = ec.create_user(
+        UserId=user_id,
+        UserName="ACKNonDefaultUser",
+        Engine="Redis",
+        NoPasswordRequired=True,
+        AccessString="on -@all"
+    )
+    logging.info(f"Created ElastiCache non default User {user_id}")
     return user_id
 
 
@@ -172,4 +184,4 @@ def service_bootstrap() -> dict:
 
 if __name__ == "__main__":
     config = service_bootstrap()
-    write_bootstrap_config(config, bootstrap_directory)
+    write_bootstrap_config(config, bootstrap_directory)

test/e2e/service_cleanup.py

@@ -4,45 +4,26 @@
 # not use this file except in compliance with the License. A copy of the
 # License is located at
 #
-#	 http://aws.amazon.com/apache2.0/
+# http://aws.amazon.com/apache2.0/
 #
 # or in the "license" file accompanying this file. This file is distributed
 # on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 # express or implied. See the License for the specific language governing
 # permissions and limitations under the License.
+
 """Cleans up the resources created by the Elasticache bootstrapping process.
 """
 
 import boto3
 import logging
-
-from acktest import resources
 from e2e import bootstrap_directory
-from e2e.bootstrap_resources import TestBootstrapResources, read_bootstrap_config
-
-def delete_sns_topic(topic_ARN: str):
-    sns = boto3.client("sns")
-    sns.delete_topic(TopicArn=topic_ARN)
-    logging.info(f"Deleted SNS topic {topic_ARN}")
-
-def delete_security_group(sg_id: str):
-    ec2 = boto3.client("ec2")
-    ec2.delete_security_group(GroupId=sg_id)
-    logging.info(f"Deleted VPC Security Group {sg_id}")
-
-def delete_user_group(usergroup_id: str):
-    ec = boto3.client("elasticache")
-    ec.delete_user_group(UserGroupId=usergroup_id)
-    logging.info(f"Deleted ElastiCache User Group {usergroup_id}")
+from e2e.bootstrap_resources import TestBootstrapResources
 
-# KMS does not allow immediate key deletion; 7 days is the shortest deletion window
-def delete_kms_key(key_id: str):
-    kms = boto3.client("kms")
-    kms.schedule_key_deletion(KeyId=key_id, PendingWindowInDays=7)
-    logging.info(f"Deletion scheduled for KMS key {key_id}")
 
-# delete snapshot and also associated cluster/RG
 def delete_snapshot(snapshot_name: str):
+    if not snapshot_name:
+        return
+
     ec = boto3.client("elasticache")
 
     # delete actual snapshot
@@ -55,97 +36,48 @@ def delete_snapshot(snapshot_name: str):
     if snapshot['CacheClusterId']:
         ec.delete_cache_cluster(CacheClusterId=snapshot['CacheClusterId'])
         logging.info(f"Deleted cache cluster {snapshot['CacheClusterId']}")
-    elif snapshot['ReplicationGroupId']: # should not happen
-        ec.delete_replication_group(ReplicationGroupId=snapshot['ReplicationGroupId'])
-        logging.info(f"Deleted replication group {snapshot['ReplicationGroupId']}")
 
 
-def delete_non_default_user(user_id: str):
-    ec = boto3.client("elasticache")
-    ec.delete_user(UserId=user_id)
-    logging.info(f"Deleted non default user {user_id}")
+def delete_kms_key(key_id: str):
+    if not key_id:
+        return
 
+    kms = boto3.client("kms")
+    kms.schedule_key_deletion(KeyId=key_id, PendingWindowInDays=7)
+    logging.info(f"Scheduled deletion for KMS key {key_id}")
 
-def delete_log_group(log_group_name: str):
-    logs = boto3.client("logs")
-    logs.delete_log_group(logGroupName=log_group_name)
-    logging.info(f"Deleted CW log group {log_group_name}")
 
+def delete_non_default_user(user_id: str):
+    if not user_id:
+        return
 
-def delete_cpg(cpg_name: str):
     ec = boto3.client("elasticache")
-    ec.delete_cache_parameter_group(CacheParameterGroupName=cpg_name)
-    logging.info(f"Deleted ElastiCache cache parameter group {cpg_name}")
+    ec.delete_user(UserId=user_id)
+    logging.info(f"Deleted non default user {user_id}")
 
 
 def service_cleanup(config: dict):
     logging.getLogger().setLevel(logging.INFO)
 
-    resources = TestBootstrapResources(
-        **config
-    )
-
-    try:
-        delete_sns_topic(resources.SnsTopic1)
-    except:
-        logging.exception(f"Unable to delete SNS topic {resources.SnsTopic1}")
+    resources = TestBootstrapResources(**config)
 
     try:
-        delete_sns_topic(resources.SnsTopic2)
+        delete_snapshot(resources.Snapshot)
     except:
-        logging.exception(f"Unable to delete SNS topic {resources.SnsTopic2}")
-
-    try:
-        delete_security_group(resources.SecurityGroup1)
-    except:
-        logging.exception(f"Unable to delete VPC Security Group {resources.SecurityGroup1}")
-
-    try:
-        delete_security_group(resources.SecurityGroup2)
-    except:
-        logging.exception(f"Unable to delete VPC Security Group {resources.SecurityGroup2}")
-
-    try:
-        delete_user_group(resources.UserGroup1)
-    except:
-        logging.exception(f"Unable to delete ElastiCache User Group {resources.UserGroup1}")
-
-    try:
-        delete_user_group(resources.UserGroup2)
-    except:
-        logging.exception(f"Unable to delete ElastiCache User Group {resources.UserGroup2}")
+        logging.exception(f"Unable to delete snapshot {resources.Snapshot}")
 
     try:
         delete_kms_key(resources.KmsKeyID)
     except:
-        logging.exception(f"Unable to schedule deletion for KMS key {resources.KmsKeyID}")
-
-    try:
-        delete_snapshot(resources.SnapshotName)
-    except:
-        logging.exception(f"Unable to delete snapshot {resources.SnapshotName}")
+        logging.exception(
+            f"Unable to schedule deletion for KMS key {resources.KmsKeyID}")
 
     try:
         delete_non_default_user(resources.NonDefaultUser)
     except:
         logging.exception(f"Unable to delete user {resources.NonDefaultUser}")
 
-    try:
-        delete_log_group(resources.CWLogGroup1)
-    except:
-        logging.exception(f"Unable to delete CW log group {resources.CWLogGroup1}")
-
-    try:
-        delete_log_group(resources.CWLogGroup2)
-    except:
-        logging.exception(f"Unable to delete CW log group {resources.CWLogGroup2}")
-
-    try:
-        delete_cpg(resources.CPGName)
-    except:
-        logging.exception(f"Unable to delete Elasticache cache parameter group {resources.CPGName}")
-
 
 if __name__ == "__main__":
-    bootstrap_config = read_bootstrap_config(bootstrap_directory)
-    service_cleanup(bootstrap_config)
+    config = TestBootstrapResources.deserialize(bootstrap_directory)
+    service_cleanup(config.__dict__)