def __init__(self, dict_src, from_cache=False): self.statements = [] super(CloudWatchLogGroup.LogStream, self).__init__(dict_src, from_cache=from_cache) if from_cache: self.init_log_stream_from_cache(dict_src) return init_options = { "logStreamName": self.init_default_attr, "creationTime": lambda name, value: (name, CommonUtils.timestamp_to_datetime(value / 1000.0)), "firstEventTimestamp": self.init_default_attr, "lastEventTimestamp": self.init_default_attr, "lastIngestionTime": self.init_default_attr, "uploadSequenceToken": self.init_default_attr, "arn": self.init_default_attr, "storedBytes": self.init_default_attr } self.init_attrs(dict_src, init_options)
def init_from_python_file(self): config = CommonUtils.load_object_from_module( self.configuration_file_full_path, "main") self.init_from_dictionary( config.__dict__, custom_source_log="Init attribute '{}' from python file: '" + self.configuration_file_full_path + "'")
def init_configuration(self): """ Sets current active account from configuration """ if self.configuration is None: return accounts = CommonUtils.load_object_from_module(self.configuration.accounts_file, "main") AzureAccount.set_azure_account(accounts[self.configuration.azure_account])
def update_tags(self, objects): if len(objects) == 0: return for response in self.execute( self.client.describe_tags, "TagDescriptions", filters_req={"ResourceArns": [obj.arn for obj in objects]}): obj = \ CommonUtils.find_objects_by_values(objects, {"arn": response["ResourceArn"]}, max_count=1)[0] obj.tags = response["Tags"]
def update_iam_role_managed_policies(self, iam_role, policies): """ Full information part update. :param iam_role: :return: """ for managed_policy in self.execute(self.client.list_attached_role_policies, "AttachedPolicies", filters_req={"RoleName": iam_role.name, "MaxItems": 1000}): found_policies = CommonUtils.find_objects_by_values(policies, {"arn": managed_policy["PolicyArn"]}) if len(found_policies) != 1: found_policies = [managed_policy["PolicyArn"]] policy = found_policies[0] iam_role.add_policy(policy)
def provision_iam_role(self, iam_role: IamRole): all_roles = self.get_all_roles(full_information=False) found_role = CommonUtils.find_objects_by_values(all_roles, {"name": iam_role.name}) if found_role: found_role = found_role[0] role_dict_src = found_role.dict_src else: role_dict_src = self.provision_iam_role_raw(iam_role.generate_create_request()) iam_role.update_from_raw_response(role_dict_src) for request in iam_role.generate_attach_policies_requests(): self.attach_role_policy_raw(request)
def get_all_users(self, full_information=True): """ Get all users. :param full_information: :return: """ final_result = list() for response in self.execute(self.client.list_users, "Users"): user = IamUser(response) final_result.append(user) if full_information: for update_info in self.execute(self.client.get_account_authorization_details, "UserDetailList"): user = CommonUtils.find_objects_by_values(final_result, {"id": update_info["UserId"]}, max_count=1)[0] user.update_attributes(update_info) return final_result
def provision_security_group(self, security_group): try: group_id = self.raw_create_security_group(security_group.generate_create_request()) security_group.id = group_id # wait for propagation? #for i in range(60): # region_groups = self.get_all_security_groups_in_region(security_group.region, full_information=False) # named_region_groups = CommonUtils.find_objects_by_values(region_groups, {"name": security_group.name}, max_count=1) # if len(named_region_groups) > 0: # break # time.sleep(5) except Exception as exception_inst: repr_exception_inst = repr(exception_inst) if "already exists for VPC" not in repr_exception_inst: raise logger.warning(repr_exception_inst) region_groups = self.get_region_security_groups(security_group.region, full_information=False) existing_group = CommonUtils.find_objects_by_values(region_groups, {"name": security_group.name}, max_count=1)[0] security_group.update_from_raw_create(existing_group.dict_src)
def clear_indices(self, time_limit=None): if time_limit is None: time_limit = datetime.datetime.now() - datetime.timedelta(days=30 * 2) self.init_indices() to_del_indices = [] for es_index_name, es_index in self.indices.items(): if es_index_name.startswith("."): continue created_date = CommonUtils.timestamp_to_datetime( es_index["settings"]["index"]["creation_date"], microseconds_value=True) if created_date < time_limit: logger.info( f"Deleting index '{es_index_name}' created at {created_date}" ) to_del_indices.append(es_index_name) pdb.set_trace() self.client.indices.delete(to_del_indices) logger.info( f"Deleted {len(to_del_indices)} out of {len(self.indices)}")
def set_session_credentials(arguments, configs_dict) -> None: configuration = AWSAPIConfigurationPolicy() configuration.configuration_file_full_path = "~/Desktop/tmp/configuration_values.py" configuration.init_from_file() accounts = CommonUtils.load_object_from_module(configuration.accounts_file, "main") AWSAccount.set_aws_account(accounts[configuration.aws_api_account]) session = SessionsManager.connect_session() credentials = session.get_credentials() credentials = credentials.get_frozen_credentials() ret = f"\n\n[{arguments.profile_name}]" ret += f"\naws_access_key_id = {credentials.access_key}" ret += f"\naws_secret_access_key = {credentials.secret_key}" ret += f"\naws_session_token = {credentials.token}" with open("~/.aws/credentials") as file_handler: contents = file_handler.read() if arguments.profile_name in contents: start_index = contents.index(f"[{arguments.profile_name}]") try: end_index = contents.index("[", start_index + 1) tail_string = "\n\n" + contents[end_index:].strip("\n") except ValueError: tail_string = "" new_contents = contents[:start_index].strip("\n") + ret + tail_string with open("~/.aws/credentials", "w+") as file_handler: file_handler.write(new_contents) else: with open("~/.aws/credentials", "a+") as file_handler: file_handler.write(ret)
def publish(arguments) -> None: accounts = CommonUtils.load_object_from_module(arguments.accounts_file, "main") AWSAccount.set_aws_account(accounts[arguments.account]) SNSClient().raw_publish(arguments.topic_arn, arguments.subject, arguments.message)
from unittest.mock import Mock from horey.aws_api.base_entities.aws_account import AWSAccount from horey.aws_api.aws_services_entities.ec2_launch_template import EC2LaunchTemplate configuration_values_file_full_path = os.path.join( os.path.dirname(os.path.abspath(__file__)), "h_logger_configuration_values.py") logger = get_logger( configuration_values_file_full_path=configuration_values_file_full_path) accounts_file_full_path = os.path.abspath( os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "ignore", "aws_api_managed_accounts.py")) accounts = CommonUtils.load_object_from_module(accounts_file_full_path, "main") AWSAccount.set_aws_account(accounts["1111"]) AWSAccount.set_aws_region(accounts["1111"].regions['us-west-2']) mock_values_file_path = os.path.abspath( os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "ignore", "mock_values.py")) mock_values = CommonUtils.load_object_from_module(mock_values_file_path, "main") def test_init_ec2_client(): assert isinstance(EC2Client(), EC2Client) DICT_CREATE_SECURITY_GROUP_REQUEST = {
import pdb from horey.docker_api.docker_api import DockerAPI import os from horey.common_utils.common_utils import CommonUtils from horey.aws_api.aws_api import AWSAPI mock_values_file_path = os.path.abspath( os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "ignore", "mock_values.py")) mock_values = CommonUtils.load_object_from_module(mock_values_file_path, "main") src_aws_region = "us-west-2" dst_aws_region = "us-west-2" def test_init_docker_api(): assert isinstance(DockerAPI(), DockerAPI) def login(docker_api): aws_api = AWSAPI() credentials = aws_api.get_ecr_authorization_info(region=src_aws_region) credentials = credentials[0] registry, username, password = credentials["proxy_host"], credentials["user_name"], credentials["decoded_token"] docker_api.login(registry, username, password) def test_login(): docker_api = DockerAPI() aws_api = AWSAPI() credentials = aws_api.get_ecr_authorization_info(region=src_aws_region)
import os import pdb from horey.aws_api.aws_clients.route53_client import Route53Client from horey.aws_api.aws_api_configuration_policy import AWSAPIConfigurationPolicy from horey.h_logger import get_logger from horey.common_utils.common_utils import CommonUtils from horey.aws_api.base_entities.aws_account import AWSAccount logger = get_logger() configuration = AWSAPIConfigurationPolicy() configuration.configuration_file_full_path = os.path.abspath( os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "ignore", "aws_api_configuration_values.py")) configuration.init_from_file() accounts = CommonUtils.load_object_from_module(configuration.accounts_file, "main") AWSAccount.set_aws_account(accounts[configuration.aws_api_account]) def test_init_route53_client(): assert isinstance(Route53Client(), Route53Client) if __name__ == "__main__": test_init_route53_client()