def test_provision_db_instance(): client = RDSClient() db_instance = RDSDBInstance({}) db_instance.region = AWSAccount.get_aws_region() db_instance.id = "instance-db-test-1" db_instance.db_instance_class = "db.t3.medium" db_instance.db_cluster_identifier = "cluster-db-test" db_instance.db_subnet_group_name = "db_subnet-test" db_instance.db_parameter_group_name = "param-group-test" db_instance.engine = "aurora-mysql" db_instance.engine_version = "5.7.mysql_aurora.2.09.2" db_instance.preferred_maintenance_window = "sun:03:30-sun:04:00" db_instance.storage_encrypted = True db_instance.copy_tags_to_snapshot = True db_instance.tags = [{ 'Key': 'lvl', 'Value': "tst" }, { 'Key': 'name', 'Value': db_instance.id }] client.provision_db_instance(db_instance) assert db_instance.arn is not None
def test_get_certificate_by_tags(): client = ACMClient() domain_name = "*.test.comp.com" ret = client.get_certificate_by_tags(AWSAccount.get_aws_region(), {"name": domain_name.replace("*", "star")}) assert ret is not None
def test_provision_replication_group(): client = ElasticacheClient() replication_group = ElasticacheReplicationGroup({}) replication_group.region = AWSAccount.get_aws_region() replication_group.id = "horey-test-redis" replication_group.az_mode = "cross-az" replication_group.description = "horey-test-redis replication group" replication_group.preferred_cache_cluster_azs = mock_values[ "elasticache.replication_group.preferred_cache_cluster_azs"] replication_group.num_cache_clusters = 2 replication_group.cache_node_type = "cache.t3.micro" replication_group.engine = "redis" replication_group.engine_version = "6.x" #replication_group.security_group_ids = [redis_security_group.id] replication_group.cache_parameter_group_name = "default.redis6.x" replication_group.cache_subnet_group_name = "subnet-group-horey-test" replication_group.preferred_maintenance_window = "sat:01:30-sat:02:30" replication_group.auto_minor_version_upgrade = True replication_group.snapshot_retention_limit = 2 replication_group.snapshot_window = "02:31-03:32" replication_group.tags = [{ 'Key': 'lvl', 'Value': "tst" }, { 'Key': 'name', 'Value': replication_group.id }] client.provision_replication_group(replication_group) assert replication_group.arn is not None
def yield_log_events(self, log_group, stream): """ :param log_group: :return: """ if AWSAccount.get_aws_region() != log_group.region: AWSAccount.set_aws_region(log_group.region) self.NEXT_PAGE_RESPONSE_KEY = "nextForwardToken" token = None for response in self.execute(self.client.get_log_events, "events", raw_data=True, filters_req={ "logGroupName": log_group.name, "logStreamName": stream.name }): token = response["nextForwardToken"] yield response #todo: refactor for response in self.execute(self.client.get_log_events, "events", raw_data=True, filters_req={ "logGroupName": log_group.name, "logStreamName": stream.name, "nextToken": token }): if token != response["nextForwardToken"]: raise ValueError()
def test_dispose_db_cluster(): client = RDSClient() cluster = RDSDBCluster({}) cluster.region = AWSAccount.get_aws_region() cluster.skip_final_snapshot = True cluster.id = "cluster-db-test" client.dispose_db_cluster(cluster)
def get_connection_id(): """ Each connection has a unique id- in order to reuse it. This function generates it. :return: """ aws_account = AWSAccount.get_aws_account() aws_region = AWSAccount.get_aws_region() region_mark = aws_region.region_mark if aws_region is not None else "" return f"{aws_account.id}/{region_mark}"
def get_region_amis(self, region, full_information=True, custom_filters=None): AWSAccount.set_aws_region(region) final_result = list() for response in self.execute(self.client.describe_images, "Images", filters_req=custom_filters): obj = AMI(response) obj.region = AWSAccount.get_aws_region() if full_information is True: pass final_result.append(obj) return final_result
def test_provision_queue(): client = SQSClient() sqs_queue = SQSQueue({}) sqs_queue.region = AWSAccount.get_aws_region() sqs_queue.name = "sqs_queue_horey_test" sqs_queue.visibility_timeout = "30" sqs_queue.maximum_message_size = "262144" sqs_queue.message_retention_period = "604800" sqs_queue.delay_seconds = "0" sqs_queue.tags = {'name': sqs_queue.name} client.provision_queue(sqs_queue) assert sqs_queue.queue_url is not None
def get_client(self, client_name): """ If client to a specific region does not exists- creates it. :param client_name: :return: """ aws_region = AWSAccount.get_aws_region() region_mark = aws_region.region_mark if aws_region is not None else self.session.region_name logger.info(f"region_mark: {region_mark} client: {client_name}") if region_mark not in self.clients or client_name not in self.clients[ region_mark]: self.connect_client(region_mark, client_name) return self.clients[region_mark][client_name]
def yield_log_group_streams(self, log_group): """ Yields streams - made to handle large log groups, in order to prevent the OOM collapse. :param log_group: :return: """ if AWSAccount.get_aws_region() != log_group.region: AWSAccount.set_aws_region(log_group.region) for response in self.execute( self.client.describe_log_streams, "logStreams", filters_req={"logGroupName": log_group.name}): yield response
def test_provision_subnet_group(): client = ElasticacheClient() subnet_group = ElasticacheCacheSubnetGroup({}) subnet_group.region = AWSAccount.get_aws_region() subnet_group.name = "subnet-group-horey-test" subnet_group.cache_subnet_group_description = "db subnet test" subnet_group.subnet_ids = mock_values[ "elasticache.subnet_group.subnet_ids"] subnet_group.tags = [{ 'Key': 'lvl', 'Value': "tst" }, { 'Key': 'name', 'Value': subnet_group.name }] client.provision_subnet_group(subnet_group) assert subnet_group.arn is not None
def test_provision_subnet_group(): client = RDSClient() subnet_group = RDSDBSubnetGroup({}) subnet_group.region = AWSAccount.get_aws_region() subnet_group.name = "db_subnet-test" subnet_group.db_subnet_group_description = "db subnet test" subnet_group.subnet_ids = ["subnet-yy", "subnet-xx"] subnet_group.tags = [{ 'Key': 'lvl', 'Value': "tst" }, { 'Key': 'name', 'Value': subnet_group.name }] client.provision_db_subnet_group(subnet_group) assert subnet_group.arn is not None
def test_provision_db_cluster_parameter_group(): client = RDSClient() db_cluster_parameter_group = RDSDBClusterParameterGroup({}) db_cluster_parameter_group.region = AWSAccount.get_aws_region() db_cluster_parameter_group.name = "cluster-param-group-test" db_cluster_parameter_group.db_parameter_group_family = "aurora-mysql5.7" db_cluster_parameter_group.description = "test" db_cluster_parameter_group.tags = [{ 'Key': 'lvl', 'Value': "tst" }, { 'Key': 'name', 'Value': db_cluster_parameter_group.name }] client.provision_db_cluster_parameter_group(db_cluster_parameter_group) assert db_cluster_parameter_group.arn is not None
def test_provision_cluster_from_snapshot(): client = RDSClient() cluster = RDSDBCluster({}) cluster.region = AWSAccount.get_aws_region() cluster.db_subnet_group_name = "db_subnet-test" cluster.db_cluster_parameter_group_name = "cluster-param-group-test" cluster.backup_retention_period = 35 cluster.database_name = "db_test" cluster.id = "cluster-db-test" cluster.vpc_security_group_ids = [ mock_values["cluster.vpc_security_group_ids"] ] cluster.engine = "aurora-mysql" cluster.engine_version = "5.7.mysql_aurora.2.09.2" cluster.port = 3306 cluster.master_username = "******" cluster.master_user_password = "******" cluster.preferred_backup_window = "09:23-09:53" cluster.preferred_maintenance_window = "sun:03:30-sun:04:00" cluster.storage_encrypted = True #cluster.kms_key_id = True cluster.engine_mode = "provisioned" cluster.deletion_protection = False cluster.copy_tags_to_snapshot = True cluster.enable_cloudwatch_logs_exports = [ "audit", "error", "general", "slowquery" ] cluster.tags = [{ 'Key': 'lvl', 'Value': "tst" }, { 'Key': 'name', 'Value': cluster.id }] client.provision_db_cluster(cluster, snapshot_id="horey-test-snapshot-id") assert cluster.arn is not None
def get_cloud_watch_alarms(self): """ Get all alarms in all regions. :return: """ final_result = list() for region in AWSAccount.get_aws_account().regions.values(): AWSAccount.set_aws_region(region) for dict_src in self.execute(self.client.describe_alarms, None, raw_data=True): if len(dict_src["CompositeAlarms"]) != 0: raise NotImplementedError("CompositeAlarms") for dict_alarm in dict_src["MetricAlarms"]: alarm = CloudWatchAlarm(dict_alarm) alarm.region = AWSAccount.get_aws_region() final_result.append(alarm) return final_result
def get_cloud_watch_log_group_metric_filters(self, full_information=False): """ Be sure you know what you do, when you set full_information=True. This can kill your memory, if you have a lot of data in cloudwatch. Better using yield_log_group_streams if you need. :param full_information: :return: """ final_result = list() for region in AWSAccount.get_aws_account().regions.values(): AWSAccount.set_aws_region(region) for result in self.execute(self.client.describe_metric_filters, "metricFilters"): obj = CloudWatchLogGroupMetricFilter(result) if full_information: self.update_log_group_full_information(obj) obj.region = AWSAccount.get_aws_region() final_result.append(obj) return final_result
def test_provision_certificate(): client = ACMClient() cert = ACMCertificate({}) cert.region = AWSAccount.get_aws_region() cert.domain_name = "*.test.comp.com" cert.tags = [ { 'Key': 'lvl', 'Value': "tst" }, { 'Key': 'name', 'Value': cert.domain_name.replace("*", "star") } ] cert.validation_method = "DNS" ret = client.provision_certificate(cert) pdb.set_trace() assert cert.arn is not None
def test_provision_launch_template(): ec2_client = EC2Client() iam_instance_profile = Mock() iam_instance_profile.arn = mock_values["iam_instance_profile.arn"] security_group = Mock() security_group.id = mock_values["security_group.id"] ami = Mock() ami.id = mock_values["ami.id"] subnet = Mock() subnet.id = mock_values["subnet.id"] ssh_key_pair = Mock() ssh_key_pair.name = mock_values["ssh_key_pair.name"] user_data = ec2_client.generate_user_data_from_file( "ecs_container_instance_user_data.sh") #filter_request = dict() # filter_request["Filters"] = [{'Name': 'name', # 'Values': [ # "amzn2-ami-ecs-hvm-2.0.20201209-x86_64-ebs", # ]}] # ami = self.aws_api.ec2_client.get_region_amis(self.configuration.region, custom_filters=filter_request)[0] launch_template = EC2LaunchTemplate({}) launch_template.name = "test_launch_template_name" launch_template.tags = [{'Key': 'lvl', 'Value': "tst"}] launch_template.region = AWSAccount.get_aws_region() launch_template.tags.append({'Key': 'Name', 'Value': launch_template.name}) launch_template.launch_template_data = { "EbsOptimized": False, "IamInstanceProfile": { "Arn": iam_instance_profile.arn }, "BlockDeviceMappings": [{ "DeviceName": "/dev/xvda", "Ebs": { "VolumeSize": 40, "VolumeType": "gp2" } }], 'NetworkInterfaces': [ { 'AssociatePublicIpAddress': True, 'DeleteOnTermination': True, 'DeviceIndex': 0, 'Groups': [ security_group.id, ], 'SubnetId': subnet.id, }, ], "ImageId": ami.id, "InstanceType": "c5.large", "KeyName": ssh_key_pair.name, "Monitoring": { "Enabled": False }, "UserData": user_data } ec2_client.provision_launch_template(launch_template) assert launch_template.id is not None