def create(ctx, iface, resource_config, **_): """Creates an AWS Autoscaling Lifecycle Hook""" params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = params.get(RESOURCE_NAME) if not resource_id: resource_id = \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, use_instance_id=True) params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) # Ensure the $GROUP_NAME parameter is populated. autoscaling_group = params.get(GROUP_NAME) if not autoscaling_group: autoscaling_group = \ utils.find_resource_id_by_type( ctx.instance, GROUP_TYPE) params[GROUP_NAME] = autoscaling_group ctx.instance.runtime_properties[GROUP_NAME] = \ autoscaling_group if not iface.resource_id: setattr(iface, 'resource_id', params.get(RESOURCE_NAME)) # Actually create the resource iface.create(params)
def create(ctx, iface, resource_config, **_): '''Creates an AWS IAM Policy''' # Build API params params = \ utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = \ utils.get_resource_id( ctx.node, ctx.instance, params.get(RESOURCE_NAME), use_instance_id=True ) or iface.resource_id params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) if 'PolicyDocument' in params and \ isinstance(params['PolicyDocument'], dict): params['PolicyDocument'] = json_dumps(params['PolicyDocument']) # Actually create the resource create_response = iface.create(params) resource_id = create_response['Policy']['PolicyName'] iface.update_resource_id(resource_id) utils.update_resource_id(ctx.instance, resource_id) utils.update_resource_arn(ctx.instance, create_response['Policy']['Arn'])
def create(ctx, iface, resource_config, **_): '''Creates an AWS EC2 Security Group''' params = utils.clean_params( dict() if not resource_config else resource_config.copy()) vpc_id = params.get(VPC_ID) # Try to get the group_name and if it does not exits then try to # generate new one based on instance_id group_name = params.get(GROUP_NAME) params[GROUP_NAME] = utils.get_ec2_vpc_resource_name(group_name) if not vpc_id: vpc = \ utils.find_rel_by_node_type( ctx.instance, VPC_TYPE) or utils.find_rel_by_node_type( ctx.instance, VPC_TYPE_DEPRECATED) if vpc_id or vpc: params[VPC_ID] = \ vpc_id or \ vpc.target.instance.runtime_properties.get( EXTERNAL_RESOURCE_ID) # Actually create the resource create_response = iface.create(params) ctx.instance.runtime_properties['create_response'] = \ utils.JsonCleanuper(create_response).to_dict() group_id = create_response.get(GROUPID, '') iface.update_resource_id(group_id) utils.update_resource_id(ctx.instance, group_id)
def delete(ctx, iface, resource_config, **_): '''Deletes an AWS ELB load balancer''' params = utils.clean_params( dict() if not resource_config else resource_config.copy()) if LB_ARN not in params.keys(): params.update({LB_ARN: iface.properties.get(LB_ARN)}) iface.delete(params)
def create(ctx, iface, resource_config, **_): """Creates an AWS ELB classic policy""" # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, params.get(RESOURCE_NAME), use_instance_id=True) params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) ctx.instance.runtime_properties[RESOURCE_NAME] = \ resource_id lb_name = params.get(LB_NAME) if not lb_name: targs = \ utils.find_rels_by_node_type( ctx.instance, LB_TYPE) lb_name = \ targs[0].target.instance.runtime_properties[ EXTERNAL_RESOURCE_ID] params.update({LB_NAME: lb_name}) ctx.instance.runtime_properties[LB_NAME] = \ lb_name # Actually create the resource iface.create(params)
def create(ctx, iface, resource_config, **_): '''Creates an AWS Lambda Permission''' # Build API params params = utils.clean_params( dict() if not resource_config else resource_config.copy()) function_rels = \ utils.find_rels_by_node_type( ctx.instance, FUNCTION_TYPE) lambda_function = None if len(function_rels) != 1 else function_rels[0] if lambda_function: params[FUNCTION_NAME] = utils.get_resource_id( node=lambda_function.target.node, instance=lambda_function.target.instance, raise_on_missing=False) if STATEMENT_ID not in params and iface.resource_id: params.update({'StatementId': iface.resource_id}) create_response = iface.create(params) statement = create_response.get('Statement') # The actual value for key "statement" is not a python dict type, # so it is required to check if it is "unicode" and then convert it back # as python dict type if statement: if isinstance(statement, unicode): statement = json.loads(statement) resource_id = statement['Sid'] if statement.get('Sid') else None iface.update_resource_id(resource_id) utils.update_resource_id(ctx.instance, resource_id) utils.update_resource_arn(ctx.instance, resource_id)
def create(ctx, iface, resource_config, **_): """Creates an AWS S3 Bucket Policy""" # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # Get the bucket name from either params or a relationship. bucket_name = params.get(BUCKET) if not bucket_name: targ = utils.find_rel_by_node_type(ctx.instance, BUCKET_TYPE) bucket_name = \ targ.target.instance.runtime_properties.get( EXTERNAL_RESOURCE_ID ) params[BUCKET] = bucket_name ctx.instance.runtime_properties[BUCKET] = bucket_name utils.update_resource_id(ctx.instance, bucket_name) # Get the policy name from either params or a relationship. bucket_policy = params.get(POLICY) if not isinstance(bucket_policy, basestring): bucket_policy = json.dumps(bucket_policy) params[POLICY] = bucket_policy ctx.instance.runtime_properties[POLICY] = bucket_policy # Actually create the resource iface.create(params)
def create(ctx, iface, resource_config, **_): """ Creates an AWS EC2 EBS Volume :param ctx: :param iface: :param resource_config: :param _: :return: """ params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # Create ebs resource create_response = iface.create(params) # Check if the resource created if create_response: ctx.instance.runtime_properties['eps_create'] =\ utils.JsonCleanuper(create_response).to_dict() # Update the esp_id (volume_id) esp_id = create_response.get(VOLUME_ID, '') utils.update_resource_id(ctx.instance, esp_id) iface.update_resource_id(esp_id) else: raise NonRecoverableError( '{0} ID# "{1}" reported an empty response' .format(RESOURCE_TYPE_VOLUME, iface.resource_id))
def create(ctx, iface, resource_config, **_): '''Creates an AWS Lambda Permission''' # Build API params params = utils.clean_params( dict() if not resource_config else resource_config.copy()) function_rels = \ utils.find_rels_by_node_type( ctx.instance, FUNCTION_TYPE) lambda_function = None if len(function_rels) != 1 else function_rels[0] if lambda_function: params[FUNCTION_NAME] = utils.get_resource_id( node=lambda_function.target.node, instance=lambda_function.target.instance, raise_on_missing=False) if STATEMENT_ID not in params and iface.resource_id: params.update({'StatementId': iface.resource_id}) create_response = iface.create(params) statement = create_response.get('Statement') # The actual value for key "statement" is not a python dict type, # so it is required to check if it is "unicode" and then convert it back # as python dict type if statement: if isinstance(statement, text_type): statement = json.loads(statement) resource_id = statement['Sid'] if statement.get('Sid') else None iface.update_resource_id(resource_id) utils.update_resource_id(ctx.instance, resource_id) utils.update_resource_arn(ctx.instance, resource_id)
def create(ctx, iface, resource_config, **_): '''Creates an AWS ELB target group''' # Build API params params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # TG attributes are only applied in modify operation. params.pop(GRP_ATTR, {}) if VPC_ID not in params.keys(): targs = \ utils.find_rels_by_node_type( ctx.instance, VPC_TYPE) or utils.find_rels_by_node_name( ctx.instance, VPC_TYPE_DEPRECATED) tg_attr = targs[0].target.instance.runtime_properties params[VPC_ID] = \ tg_attr.get(EXTERNAL_RESOURCE_ID) del targs # Actually create the resource create_response = iface.create(params) iface.update_resource_id( create_response['TargetGroups'][0][TARGETGROUP_ARN]) utils.update_resource_id( ctx.instance, create_response['TargetGroups'][0][TARGETGROUP_ARN]) utils.update_resource_arn( ctx.instance, create_response['TargetGroups'][0][TARGETGROUP_ARN])
def wrapper_inner(*argc, **kwargs): ctx = kwargs.get('ctx') iface = kwargs.get('iface') resource_config = kwargs.get('resource_config') # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) if params_priority: # params value will overwrite other resources id resource_id = params.get(resource_name) if not resource_id: resource_id = \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, use_instance_id=True) params[resource_name] = resource_id else: # resource id from runtime has priority over params resource_id = \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, params.get(resource_name), use_instance_id=True) params[resource_name] = resource_id ctx.instance.runtime_properties[resource_name] = \ resource_id utils.update_resource_id(ctx.instance, resource_id) kwargs['params'] = params return function(*argc, **kwargs)
def create(ctx, iface, resource_config, **_): '''Creates an AWS EC2 Security Group''' params = utils.clean_params( dict() if not resource_config else resource_config.copy()) vpc_id = params.get(VPC_ID) # Try to get the group_name and if it does not exits then try to # generate new one based on instance_id group_name = params.get(GROUP_NAME) params[GROUP_NAME] = utils.get_ec2_vpc_resource_name(group_name) if not vpc_id: vpc = \ utils.find_rel_by_node_type( ctx.instance, VPC_TYPE) or utils.find_rel_by_node_type( ctx.instance, VPC_TYPE_DEPRECATED) if vpc_id or vpc: params[VPC_ID] = \ vpc_id or \ vpc.target.instance.runtime_properties.get( EXTERNAL_RESOURCE_ID) # Actually create the resource create_response = iface.create(params) ctx.instance.runtime_properties['create_response'] = \ utils.JsonCleanuper(create_response).to_dict() group_id = create_response.get(GROUPID, '') iface.update_resource_id(group_id) utils.update_resource_id( ctx.instance, group_id)
def create(ctx, iface, resource_config, **_): """Creates an AWS S3 Bucket Policy""" # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # Get the bucket name from either params or a relationship. bucket_name = params.get(BUCKET) if not bucket_name: targ = utils.find_rel_by_node_type( ctx.instance, BUCKET_TYPE ) bucket_name = \ targ.target.instance.runtime_properties.get( EXTERNAL_RESOURCE_ID ) params[BUCKET] = bucket_name ctx.instance.runtime_properties[BUCKET] = bucket_name utils.update_resource_id(ctx.instance, bucket_name) # Get the policy name from either params or a relationship. bucket_policy = params.get(POLICY) if not isinstance(bucket_policy, basestring): bucket_policy = json.dumps(bucket_policy) params[POLICY] = bucket_policy ctx.instance.runtime_properties[POLICY] = bucket_policy # Actually create the resource iface.create(params)
def create(ctx, iface, resource_config, **_): '''Creates an AWS IAM Role Policy''' # Build API params params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = \ utils.get_resource_id( ctx.node, ctx.instance, params.get(RESOURCE_NAME), use_instance_id=True ) or iface.resource_id params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) # Add RoleName role_name = params.get(ROLE_NAME, '') if not role_name: params[ROLE_NAME] = \ utils.find_resource_id_by_type( ctx.instance, ROLE_TYPE) if 'PolicyDocument' in params and \ isinstance(params['PolicyDocument'], dict): params['PolicyDocument'] = json_dumps(params['PolicyDocument']) # Actually create the resource iface.create(params)
def create(ctx, iface, resource_config, **_): """ Creates an AWS EC2 EBS Volume :param ctx: :param iface: :param resource_config: :param _: :return: """ params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # Create ebs resource create_response = iface.create(params) # Check if the resource created if create_response: ctx.instance.runtime_properties['eps_create'] =\ utils.JsonCleanuper(create_response).to_dict() # Update the esp_id (volume_id) esp_id = create_response.get(VOLUME_ID, '') utils.update_resource_id(ctx.instance, esp_id) iface.update_resource_id(esp_id) else: raise NonRecoverableError( '{0} ID# "{1}" reported an empty response'.format( RESOURCE_TYPE_VOLUME, iface.resource_id))
def create(ctx, iface, resource_config, **_): '''Creates an AWS ELB load balancer''' # Build API params params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = \ params.get('Name') or \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, use_instance_id=True) params['Name'] = resource_id utils.update_resource_id(ctx.instance, resource_id) # LB attributes are only applied in modify operation. params.pop(LB_ATTR, {}) # Add Subnets subnets_from_params = params.get(SUBNETS, []) subnets = \ utils.find_rels_by_node_type( ctx.instance, SUBNET_TYPE) or utils.find_rels_by_node_name( ctx.instance, SUBNET_TYPE_DEPRECATED) for subnet in subnets: subnet_id = \ subnet.target.instance.runtime_properties[EXTERNAL_RESOURCE_ID] subnets_from_params.append(subnet_id) params[SUBNETS] = subnets_from_params # Add Security Groups secgroups_from_params = params.get(SECGROUPS, []) secgroups = \ utils.find_rels_by_node_type( ctx.instance, SECGROUP_TYPE) or \ utils.find_rels_by_node_type( ctx.instance, SECGROUP_TYPE_DEPRECATED) for secgroup in secgroups: secgroup_id = \ secgroup.target.instance.runtime_properties[EXTERNAL_RESOURCE_ID] secgroups_from_params.append(secgroup_id) params[SECGROUPS] = secgroups_from_params # Actually create the resource output = iface.create(params) lb_id = output['LoadBalancers'][0][RESOURCE_NAME] iface.resource_id = lb_id try: utils.update_resource_id(ctx.instance, lb_id) utils.update_resource_arn(ctx.instance, output['LoadBalancers'][0][LB_ARN]) except (IndexError, KeyError) as e: raise NonRecoverableError( '{0}: {1} or {2} not located in response: {3}'.format( str(e), RESOURCE_NAME, LB_ARN, output))
def create(ctx, iface, resource_config, **_): """ Creates an AWS EC2 EBS Volume :param ctx: :param iface: :param resource_config: :param _: :return: """ params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # Actually create ebs resource region_name = ctx.node.properties['client_config']['region_name'] use_available_zones = ctx.node.properties.get('use_available_zones', False) try: create_response = iface.create(params) except CapacityNotAvailableError: if use_available_zones: ctx.logger.warn( "The Availability Zone chosen {0} " "is not available".format(params['AvailabilityZone'])) valid_zone = \ iface.get_available_zone({ 'Filters': [ {'Name': 'region-name', 'Values': [region_name]} ] }) if valid_zone: ctx.logger.info( "using {0} Availability Zone instead".format(valid_zone)) params['AvailabilityZone'] = valid_zone create_response = iface.create(params) else: raise NonRecoverableError( "no available Availability Zones " "in region {0}".format(region_name)) else: raise NonRecoverableError( "The Availability Zone chosen " "{0} is not available".format(params['AvailabilityZone'])) # Check if the resource created if create_response: ctx.instance.runtime_properties['eps_create'] =\ utils.JsonCleanuper(create_response).to_dict() # Update the esp_id (volume_id) esp_id = create_response.get(VOLUME_ID, '') utils.update_resource_id(ctx.instance, esp_id) iface.update_resource_id(esp_id) else: raise NonRecoverableError( '{0} ID# "{1}" reported an empty response' .format(RESOURCE_TYPE_VOLUME, iface.resource_id))
def create(ctx, iface, resource_config, **_): '''Creates an AWS EC2 Subnet''' params = utils.clean_params( dict() if not resource_config else resource_config.copy()) vpc_id = params.get(VPC_ID) cidr_block = params.get(CIDR_BLOCK) ipv6_cidr_block = params.get(IPV6_CIDR_BLOCK) # If either of these values is missing, # they must be filled from a connected VPC. if not vpc_id or not cidr_block: targ = \ utils.find_rel_by_node_type( ctx.instance, VPC_TYPE) or utils.find_rel_by_node_type( ctx.instance, VPC_TYPE_DEPRECATED) # Attempt to use the VPC ID from parameters. # Fallback to connected VPC. params[VPC_ID] = \ vpc_id or \ targ.target.instance.runtime_properties.get( EXTERNAL_RESOURCE_ID) # Attempt to use the CIDR Block from parameters. # Fallback to connected VPC. params[CIDR_BLOCK] = \ cidr_block or \ targ.instance.runtime_properties.get( 'resource_config', {}).get(CIDR_BLOCK) # If ipv6 cidr block is provided by user, then we need to make sure that # The subnet size must use a /64 prefix length if ipv6_cidr_block: ipv6_cidr_block = ipv6_cidr_block[:-2] + '64' params[IPV6_CIDR_BLOCK] = ipv6_cidr_block # Actually create the resource create_response = iface.create(params)[SUBNET] ctx.instance.runtime_properties['create_response'] = \ utils.JsonCleanuper(create_response).to_dict() subnet_id = create_response.get(SUBNET_ID) iface.update_resource_id(subnet_id) utils.update_resource_id(ctx.instance, subnet_id) modify_subnet_attribute_args = \ _.get('modify_subnet_attribute_args') if modify_subnet_attribute_args: modify_subnet_attribute_args[SUBNET_ID] = \ subnet_id iface.modify_subnet_attribute( modify_subnet_attribute_args)
def create(ctx, iface, resource_config, **_): '''Creates an AWS EC2 Subnet''' params = utils.clean_params( dict() if not resource_config else resource_config.copy()) vpc_id = params.get(VPC_ID) cidr_block = params.get(CIDR_BLOCK) ipv6_cidr_block = params.get(IPV6_CIDR_BLOCK) # If either of these values is missing, # they must be filled from a connected VPC. if not vpc_id or not cidr_block: targ = \ utils.find_rel_by_node_type( ctx.instance, VPC_TYPE) or utils.find_rel_by_node_type( ctx.instance, VPC_TYPE_DEPRECATED) # Attempt to use the VPC ID from parameters. # Fallback to connected VPC. params[VPC_ID] = \ vpc_id or \ targ.target.instance.runtime_properties.get( EXTERNAL_RESOURCE_ID) # Attempt to use the CIDR Block from parameters. # Fallback to connected VPC. params[CIDR_BLOCK] = \ cidr_block or \ targ.instance.runtime_properties.get( 'resource_config', {}).get(CIDR_BLOCK) # If ipv6 cidr block is provided by user, then we need to make sure that # The subnet size must use a /64 prefix length if ipv6_cidr_block: ipv6_cidr_block = ipv6_cidr_block[:-2] + '64' params[IPV6_CIDR_BLOCK] = ipv6_cidr_block # Actually create the resource create_response = iface.create(params)[SUBNET] ctx.instance.runtime_properties['create_response'] = \ utils.JsonCleanuper(create_response).to_dict() subnet_id = create_response.get(SUBNET_ID) iface.update_resource_id(subnet_id) utils.update_resource_id(ctx.instance, subnet_id) modify_subnet_attribute_args = \ _.get('modify_subnet_attribute_args') if modify_subnet_attribute_args: modify_subnet_attribute_args[SUBNET_ID] = \ subnet_id iface.modify_subnet_attribute(modify_subnet_attribute_args)
def create(ctx, iface, resource_config, **_): '''Creates an AWS Lambda Function''' # Build API params params = utils.clean_params( dict() if not resource_config else resource_config.copy()) if RESOURCE_ID not in params: params[RESOURCE_ID] = iface.resource_id vpc_config = params.get('VpcConfig', dict()) # Attach a Subnet Group if it exists subnet_ids = _get_subnets_to_attach(ctx, vpc_config) if subnet_ids: vpc_config['SubnetIds'] = subnet_ids # Attach any security groups if they exist security_groups = _get_security_groups_to_attach(ctx, vpc_config) if security_groups: vpc_config['SecurityGroupIds'] = security_groups params['VpcConfig'] = vpc_config # Attach an IAM Role if it exists iam_role = _get_iam_role_to_attach(ctx) if iam_role: params['Role'] = iam_role # Handle user-profided code ZIP file if params.get('Code', dict()).get('ZipFile'): codezip = params['Code']['ZipFile'] ctx.logger.debug('ZipFile: "%s" (%s)' % (codezip, type(codezip))) if not path_exists(codezip): codezip = ctx.download_resource(codezip) ctx.logger.debug('Downloaded resource: "%s"' % codezip) with open(codezip, mode='rb') as _file: params['Code']['ZipFile'] = _file.read() ctx.logger.debug('Deleting resource: "%s"' % codezip) os_remove(codezip) else: with open(codezip, mode='rb') as _file: params['Code']['ZipFile'] = _file.read() # Actually create the resource create_response = iface.create(params) resource_id = create_response['FunctionName'] utils.update_resource_id(ctx.instance, resource_id) utils.update_resource_arn(ctx.instance, create_response['FunctionArn']) # Save vpc_config to be used later on when remove eni created by invoke # function if vpc_config and create_response.get('VpcConfig'): ctx.instance.runtime_properties['vpc_config'] =\ create_response['VpcConfig']
def create(ctx, iface, resource_config, **_): """Creates an AWS ELB classic load balancer""" # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, params.get(RESOURCE_NAME), use_instance_id=True) params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) ctx.instance.runtime_properties[RESOURCE_NAME] = \ resource_id # Add Subnets subnets_list = params.get(SUBNETS, []) params[SUBNETS] = \ utils.add_resources_from_rels( ctx.instance, SUBNET_TYPE, subnets_list) or utils.add_resources_from_rels( ctx.instance, SUBNET_TYPE_DEPRECATED, subnets_list) # Add Security Groups secgroups_list = params.get(SECGROUPS, []) params[SECGROUPS] = \ utils.add_resources_from_rels( ctx.instance, SECGROUP_TYPE, secgroups_list) or \ utils.add_resources_from_rels( ctx.instance, SECGROUP_TYPE_DEPRECATED, secgroups_list) create_response = iface.create(params) # Actually create the resource ctx.instance.runtime_properties['DNSName'] = \ create_response['DNSName'] ctx.instance.runtime_properties['create_response'] = \ create_response
def create(ctx, iface, resource_config, **_): """Creates an AWS EC2 ElasticIP""" # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # Actually create the resource create_response = iface.create(params) ctx.instance.runtime_properties['create_response'] = \ utils.JsonCleanuper(create_response).to_dict() elasticip_id = create_response.get(ELASTICIP_ID, '') iface.update_resource_id(elasticip_id) utils.update_resource_id(ctx.instance, elasticip_id) ctx.instance.runtime_properties['allocation_id'] = \ create_response.get(ALLOCATION_ID)
def modify(ctx, iface, resource_config, **_): '''modify an AWS ELB load balancer attributes''' params = utils.clean_params( dict() if not resource_config else resource_config.copy()) if LB_ARN not in params.keys(): params.update( {LB_ARN: ctx.instance.runtime_properties.get( EXTERNAL_RESOURCE_ARN)}) modify_params_attributes = params.pop(LB_ATTR, {}) if modify_params_attributes: # Add the LB ARN modify_params = {} modify_params[LB_ARN] = params.get(LB_ARN) modify_params[LB_ATTR] = modify_params_attributes # Actually modify the resource attributes = iface.modify_attribute(modify_params) ctx.instance.runtime_properties['resource_config'][LB_ATTR] = \ attributes
def modify(ctx, iface, resource_config, **_): '''modify an AWS ELB load balancer attributes''' params = utils.clean_params( dict() if not resource_config else resource_config.copy()) if LB_ARN not in params: params.update( {LB_ARN: ctx.instance.runtime_properties.get( EXTERNAL_RESOURCE_ARN)}) modify_params_attributes = params.pop(LB_ATTR, {}) if modify_params_attributes: # Add the LB ARN modify_params = {} modify_params[LB_ARN] = params.get(LB_ARN) modify_params[LB_ATTR] = modify_params_attributes # Actually modify the resource attributes = iface.modify_attribute(modify_params) ctx.instance.runtime_properties['resource_config'][LB_ATTR] = \ attributes
def create(ctx, iface, resource_config, **_): '''Creates an AWS IAM Group''' # Build API params params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, params.get(RESOURCE_NAME), use_instance_id=True) params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) # Actually create the resource res_id, res_arn = iface.create(params) utils.update_resource_id(ctx.instance, res_id) utils.update_resource_arn(ctx.instance, res_arn)
def create(ctx, iface, resource_config, **_): '''Creates an AWS IAM Role''' # Build API params params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = \ utils.get_resource_id( ctx.node, ctx.instance, params.get(RESOURCE_NAME), use_instance_id=True ) or iface.resource_id params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) if 'AssumeRolePolicyDocument' in params and \ isinstance(params['AssumeRolePolicyDocument'], dict): params['AssumeRolePolicyDocument'] = \ json_dumps(params['AssumeRolePolicyDocument']) # Actually create the resource create_response = iface.create(params) resource_id = create_response['Role']['RoleName'] iface.update_resource_id(resource_id) utils.update_resource_id(ctx.instance, resource_id) utils.update_resource_arn( ctx.instance, create_response['Role']['Arn']) # attach policy role policies_arn = [] policies = _.get('modify_role_attribute_args', []) for policy in policies: payload = dict() payload['RoleName'] = resource_id payload['PolicyArn'] = policy['PolicyArn'] policies_arn.append(payload['PolicyArn']) iface.attach_policy(payload) # If there are policies added attached to role, then we need to make # sure that when uninstall triggers, all the attached policies arn are # available to detach if policies_arn: ctx.instance.runtime_properties['policies'] = policies_arn
def create(ctx, iface, resource_config, **_): '''Creates an AWS EC2 Vpc''' params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # Actually create the resource create_response = iface.create(params)[VPC] ctx.instance.runtime_properties['create_response'] = \ utils.JsonCleanuper(create_response).to_dict() vpc_id = create_response.get(VPC_ID, '') iface.update_resource_id(vpc_id) utils.update_resource_id(ctx.instance, vpc_id) modify_vpc_attribute_args = \ _.get('modify_vpc_attribute_args') if modify_vpc_attribute_args: modify_vpc_attribute_args[VPC_ID] = \ vpc_id iface.modify_vpc_attribute(modify_vpc_attribute_args)
def create(ctx, iface, resource_config, **_): """Creates an AWS S3 Bucket""" # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = params.get(RESOURCE_NAME) if not resource_id: resource_id = \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, use_instance_id=True) params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) # Actually create the resource bucket = iface.create(resource_config) ctx.instance.runtime_properties[LOCATION] = \ bucket.get(LOCATION)
def create(ctx, iface, resource_config, **_): '''Creates an AWS ELB rule''' # Build API params resource_config = \ resource_config or ctx.instance.runtime_properties['resource_config'] params = utils.clean_params( dict() if not resource_config else resource_config.copy()) if LISTENER_ARN not in params: targs = \ utils.find_rels_by_node_type( ctx.instance, LISTENER_TYPE) listener_arn = \ targs[0].target.instance.runtime_properties[EXTERNAL_RESOURCE_ARN] params.update({LISTENER_ARN: listener_arn}) del targs for action in params.get('Actions', []): target_grp = action.get(TARGET_ARN) if not ARN_MATCHER.match(action.get(target_grp, '')): targs = \ utils.find_rels_by_node_type( ctx.instance, TARGET_TYPE) for targ in targs: target_group_arn = \ targ.target.instance.runtime_properties[ EXTERNAL_RESOURCE_ARN] if targ.target.node.name == target_grp: action.update({TARGET_ARN: target_group_arn}) # Actually create the resource create_response = iface.create(params) iface.update_resource_id( create_response['Rules'][0][RULE_ARN]) utils.update_resource_id( ctx.instance, create_response['Rules'][0][RULE_ARN]) utils.update_resource_arn( ctx.instance, create_response['Rules'][0][RULE_ARN])
def create(ctx, iface, resource_config, **_): '''Creates an AWS EC2 Vpc''' params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # Actually create the resource create_response = iface.create(params)[VPC] ctx.instance.runtime_properties['create_response'] = \ utils.JsonCleanuper(create_response).to_dict() vpc_id = create_response.get(VPC_ID, '') iface.update_resource_id(vpc_id) utils.update_resource_id( ctx.instance, vpc_id) modify_vpc_attribute_args = \ _.get('modify_vpc_attribute_args') if modify_vpc_attribute_args: modify_vpc_attribute_args[VPC_ID] = \ vpc_id iface.modify_vpc_attribute( modify_vpc_attribute_args)
def create(ctx, iface, resource_config, **_): """Creates an AWS ELB classic listener""" # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) lb_name = params.get(LB_NAME) if not lb_name: targs = \ utils.find_rels_by_node_type( ctx.instance, LB_TYPE) lb_name = \ targs[0].target.instance.runtime_properties[ EXTERNAL_RESOURCE_ID] params.update({LB_NAME: lb_name}) ctx.instance.runtime_properties[LB_NAME] = lb_name # Actually create the resource iface.create(params)
def create(ctx, iface, resource_config, **_): '''Creates an AWS IAM User''' # Build API params params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, params.get(RESOURCE_NAME), use_instance_id=True) params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) # Actually create the resource create_response = iface.create(params) resource_id = create_response['User']['UserName'] iface.update_resource_id(resource_id) utils.update_resource_id(ctx.instance, resource_id) utils.update_resource_arn( ctx.instance, create_response['User']['Arn'])
def create(ctx, iface, resource_config, **_): '''Creates an AWS ELB rule''' # Build API params resource_config = \ resource_config or ctx.instance.runtime_properties['resource_config'] params = utils.clean_params( dict() if not resource_config else resource_config.copy()) if LISTENER_ARN not in params: targs = \ utils.find_rels_by_node_type( ctx.instance, LISTENER_TYPE) listener_arn = \ targs[0].target.instance.runtime_properties[EXTERNAL_RESOURCE_ARN] params.update({LISTENER_ARN: listener_arn}) del targs for action in params.get('Actions', []): target_grp = action.get(TARGET_ARN) if not ARN_MATCHER.match(action.get(target_grp, '')): targs = \ utils.find_rels_by_node_type( ctx.instance, TARGET_TYPE) for targ in targs: target_group_arn = \ targ.target.instance.runtime_properties[ EXTERNAL_RESOURCE_ARN] if targ.target.node.name == target_grp: action.update({TARGET_ARN: target_group_arn}) # Actually create the resource create_response = iface.create(params) iface.update_resource_id(create_response['Rules'][0][RULE_ARN]) utils.update_resource_id(ctx.instance, create_response['Rules'][0][RULE_ARN]) utils.update_resource_arn(ctx.instance, create_response['Rules'][0][RULE_ARN])
def create(ctx, iface, resource_config, **_): """Creates an AWS DynamoDB Table""" # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, params.get(RESOURCE_NAME), use_instance_id=True) params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) # Actually create the resource create_respose = iface.create(params) resource_id = create_respose['TableDescription']['TableName'] iface.update_resource_id(resource_id) utils.update_resource_id(ctx.instance, resource_id) utils.update_resource_arn(ctx.instance, create_respose['TableDescription']['TableArn'])
def create(ctx, iface, resource_config, **_): """Creates an AWS EC2 ElasticIP""" # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # Actually create the resource create_response = None if ctx.node.properties.get('use_unassociated_addresses', False): create_response = get_already_allocated_ip(iface.list()) if not create_response: create_response = iface.create(params) else: ctx.instance.runtime_properties['unassociated_address'] = \ create_response.get(ELASTICIP_ID) ctx.instance.runtime_properties['create_response'] = \ utils.JsonCleanuper(create_response).to_dict() elasticip_id = create_response.get(ELASTICIP_ID, '') iface.update_resource_id(elasticip_id) utils.update_resource_id(ctx.instance, elasticip_id) allocation_id = create_response.get(ALLOCATION_ID) iface.update_allocation_id(allocation_id) ctx.instance.runtime_properties['allocation_id'] = allocation_id
def create(ctx, iface, resource_config, **_): """Creates an AWS Autoscaling Group""" params = utils.clean_params( dict() if not resource_config else resource_config.copy()) resource_id = params.get(RESOURCE_NAME) if not resource_id: resource_id = \ iface.resource_id or \ utils.get_resource_id( ctx.node, ctx.instance, use_instance_id=True) params[RESOURCE_NAME] = resource_id utils.update_resource_id(ctx.instance, resource_id) # Try to populate the Launch Configuration field # with a relationship lc_name = params.get(LC_NAME) instance_id = params.get(INSTANCE_ID) if not lc_name and not instance_id: lc_name = \ utils.find_resource_id_by_type( ctx.instance, LC_TYPE) if lc_name: params.update({LC_NAME: lc_name}) # If no LC_NAME, try to populate the # InstanceId field with a relationship. if not lc_name: instance_id = \ utils.find_resource_id_by_type( ctx.instance, INSTANCE_TYPE) params[INSTANCE_ID] = instance_id subnet_list_string = params.get(SUBNET_LIST) subnet_list = \ sub("[^\w]", " ", subnet_list_string).split() if \ subnet_list_string else [] subnet_list = \ utils.add_resources_from_rels( ctx.instance, SUBNET_TYPE, subnet_list) subnet_list = \ utils.add_resources_from_rels( ctx.instance, SUBNET_TYPE_DEPRECATED, subnet_list) if subnet_list: # Remove any duplicate items from subnet list subnet_list = list(set(subnet_list)) params[SUBNET_LIST] = ', '.join(subnet_list) # Actually create the resource if not iface.resource_id: setattr(iface, 'resource_id', params.get(RESOURCE_NAME)) iface.create(params) iface.update_resource_id(iface.properties.get(RESOURCE_NAME)) utils.update_resource_id(ctx.instance, iface.properties.get(RESOURCE_NAME)) utils.update_resource_arn(ctx.instance, iface.properties.get(GROUP_ARN))
def configure(ctx, resource_config, **_): '''Configures an AWS IAM Login Profile''' # Save the parameters ctx.instance.runtime_properties['resource_config'] = \ utils.clean_params(resource_config)
def create(ctx, iface, resource_config, **_): '''Creates an AWS Lambda Function''' # Build API params params = utils.clean_params( dict() if not resource_config else resource_config.copy()) if RESOURCE_ID not in params: params[RESOURCE_ID] = iface.resource_id vpc_config = params.get('VpcConfig', dict()) # Attach a Subnet Group if it exists subnet_ids = vpc_config.get('SubnetIds', list()) subnet_rels = \ utils.find_rels_by_node_type( ctx.instance, SUBNET_TYPE) or \ utils.find_rels_by_node_type( ctx.instance, SUBNET_TYPE) for rel in subnet_rels: subnet_ids.append(utils.get_resource_id( node=rel.target.node, instance=rel.target.instance, raise_on_missing=True)) vpc_config['SubnetIds'] = subnet_ids # Attach any security groups if they exist security_groups = vpc_config.get('SecurityGroupIds', list()) sg_rels = \ utils.find_rels_by_node_type( ctx.instance, SECGROUP_TYPE) or \ utils.find_rels_by_node_type( ctx.instance, SECGROUP_TYPE_DEPRECATED) for rel in sg_rels: security_groups.append( utils.get_resource_id( node=rel.target.node, instance=rel.target.instance, raise_on_missing=True)) vpc_config['SecurityGroupIds'] = security_groups params['VpcConfig'] = vpc_config # Attach an IAM Role if it exists iam_role = utils.find_rel_by_node_type( ctx.instance, 'cloudify.nodes.aws.iam.Role') if iam_role: params['Role'] = utils.get_resource_arn( node=iam_role.target.node, instance=iam_role.target.instance, raise_on_missing=True) # Handle user-profided code ZIP file if params.get('Code', dict()).get('ZipFile'): codezip = params['Code']['ZipFile'] ctx.logger.debug('ZipFile: "%s" (%s)' % (codezip, type(codezip))) if not path_exists(codezip): codezip = ctx.download_resource(codezip) ctx.logger.debug('Downloaded resource: "%s"' % codezip) with open(codezip, mode='rb') as _file: params['Code']['ZipFile'] = _file.read() ctx.logger.debug('Deleting resource: "%s"' % codezip) os_remove(codezip) else: with open(codezip, mode='rb') as _file: params['Code']['ZipFile'] = _file.read() # Actually create the resource create_response = iface.create(params) resource_id = create_response['FunctionName'] utils.update_resource_id(ctx.instance, resource_id) utils.update_resource_arn( ctx.instance, create_response['FunctionArn']) # Save vpc_config to be used later on when remove eni created by invoke # function if vpc_config and create_response.get('VpcConfig'): ctx.instance.runtime_properties['vpc_config'] =\ create_response['VpcConfig']
def create(ctx, iface, resource_config, **_): """Creates an AWS S3 Bucket Object""" # Create a copy of the resource config for clean manipulation. params = utils.clean_params( dict() if not resource_config else resource_config.copy()) # Get the bucket object key from params object_key = params.get(OBJECT_KEY) if not object_key: raise NonRecoverableError('{0} param is required'.format(OBJECT_KEY)) utils.update_resource_id(ctx.instance, object_key) source_type = ctx.node.properties.get(OBJECT_SOURCE_TYPE) cloudify_path = None object_body = None # If "source_type" is either local or remote then we need to download # the file from remote or local directory and then parse the data as # bytes and prepared it to be sent on the "Body" param for "put_object" # method if source_type in [OBJECT_LOCAL_SOURCE, OBJECT_REMOTE_SOURCE]: path = ctx.node.properties.get(OBJECT_PATH) if not path: raise NonRecoverableError( 'path param must be provided when ' 'source_type is selected as remote or local') if source_type == OBJECT_LOCAL_SOURCE: cloudify_path = _download_local_file(path) elif source_type == OBJECT_REMOTE_SOURCE: cloudify_path = _download_remote_file(path) try: object_body = open(cloudify_path, 'rb') except IOError as error: _, _, tb = sys.exc_info() raise NonRecoverableError( 'Failed to open file {0},' ' with error message {1}' ''.format(path, error.strerror, causes=[exception_to_error_cause(error, tb)])) # Set the updated path url so that it can # be uploaded to the AWS S3 bucket params[BUCKET_OBJECT_BODY] = object_body # If the "source_type" is "bytes" then the body should provided from the # blueprint and follow the boto3 API documents elif source_type == OBJECT_BYTES_SOURCE: if not params.get(BUCKET_OBJECT_BODY): raise NonRecoverableError('Body param must be provided when ' 'source_type is selected as bytes') # Get the bucket name from either params or a relationship. bucket_name = params.get(BUCKET) if not bucket_name: targ = utils.find_rel_by_node_type(ctx.instance, BUCKET_TYPE) bucket_name = \ targ.target.instance.runtime_properties.get( EXTERNAL_RESOURCE_ID ) params[BUCKET] = bucket_name iface.bucket_name = bucket_name ctx.instance.runtime_properties[BUCKET] = bucket_name # Actually create the resource iface.create(params)
def configure(ctx, resource_config, **_): '''Configures an AWS IAM Access Key''' # Save the parameters ctx.instance.runtime_properties['resource_config'] = \ utils.clean_params(resource_config)