def _create_activity_from_meta(self, name, meta):
arn = self.build_activity_arn(name=name)
response = self.sf_conn.describe_activity(arn)
if response:
_LOG.warn('Activity %s exists.', name)
return {arn: build_description_obj(response, name, meta)}
response = self.sf_conn.create_activity(name=name)
_LOG.info('Activity %s is created.', name)
return {arn: build_description_obj(response, name, meta)}
def create_lambda_layer_from_meta(self, name, meta, context=None):
"""
:param name:
:param meta:
:param context: because of usage in 'update' flow
:return:
"""
req_params = ['runtimes', 'deployment_package']
validate_params(name, meta, req_params)
key = meta[S3_PATH_NAME]
file_name = key.split('/')[-1]
self.s3_conn.download_file(self.deploy_target_bucket, key, file_name)
with open(file_name, 'rb') as file_data:
file_body = file_data.read()
import hashlib
hash_object = hashlib.sha256()
hash_object.update(file_body)
existing_version = self._is_equal_lambda_layer(hash_object.digest(),
name)
if existing_version:
existing_layer_arn = existing_version['LayerVersionArn']
_LOG.info('Layer {} with same content already '
'exists in layer version {}.'.format(
name, existing_layer_arn))
return {
existing_layer_arn:
build_description_obj(response=existing_version,
name=name,
meta=meta)
}
_LOG.debug('Creating lambda layer %s', name)
args = {
'layer_name': name,
'runtimes': meta['runtimes'],
's3_bucket': self.deploy_target_bucket,
's3_key': meta[S3_PATH_NAME]
}
if meta.get('description'):
args['description'] = meta['description']
if meta.get('license'):
args['layer_license'] = meta['license']
response = self.lambda_conn.create_layer(**args)
_LOG.info(
'Lambda Layer {0} version {1} was successfully created'.format(
name, response['Version']))
layer_arn = response['LayerArn'] + ':' + str(response['Version'])
del response['LayerArn']
return {layer_arn: build_description_obj(response, name, meta)}
def describe_lambda(self, name, meta, response=None):
if not response:
response = self.lambda_conn.get_function(lambda_name=name)
arn = self.build_lambda_arn_with_alias(response, meta.get('alias'))
del response['Configuration']['FunctionArn']
return {arn: build_description_obj(response, name, meta)}
def describe_sns_application_from_meta(self, name, meta):
new_region_args = create_args_for_multi_region(
[
{
'name': name,
'meta': meta
}
],
ALL_REGIONS)
responses = []
for arg in new_region_args:
region = arg['region']
app_arn = self.connection_provider.sns(
region).get_platform_application(
name)
if not app_arn:
continue
response = self.connection_provider.sns(
region).get_platform_application_attributes(
app_arn)
if response:
responses.append({'arn': app_arn, 'response': response})
description = []
for topic in responses:
description.append({
topic['arn']: build_description_obj(
topic['response'], name, meta)
})
return description
def describe_stream(self, name, meta):
response = self.dynamodb_conn.describe_table(meta['table'])
res_obj = {
'StreamSpecification': response['StreamSpecification'],
'LatestStreamLabel': response['LatestStreamLabel']
}
arn = response['LatestStreamArn']
return {arn: build_description_obj(res_obj, name, meta)}
def describe_stream(name, meta):
response = _DYNAMO_DB_CONN.describe_table(meta['table'])
res_obj = {
'StreamSpecification': response['StreamSpecification'],
'LatestStreamLabel': response['LatestStreamLabel']
}
arn = response['LatestStreamArn']
return {arn: build_description_obj(res_obj, name, meta)}
def describe_sns(self, name, meta, region, arn=None):
if not arn:
arn = self.connection_provider.sns(region).get_topic_arn(name)
response = self.connection_provider.sns(region).get_topic_attributes(
arn)
return {
arn: build_description_obj(response, name, meta)
}
def describe_job_definition(self, name, meta):
response = self.batch_conn.describe_job_definition(job_definition=name)
try:
arn = response['jobDefinitions'][-1]['jobDefinitionArn']
return {arn: build_description_obj(response, name, meta)}
except (KeyError, IndexError):
_LOG.warn("Batch Job Definition %s not found", name)
return {}
def describe_job_queue(self, name, meta):
response = self.batch_conn.describe_job_queue(name)
try:
arn = response['jobQueues'][0]['jobQueueArn']
return {arn: build_description_obj(response, name, meta)}
except (KeyError, IndexError):
_LOG.warn("Batch Job Queue %s not found", name)
return {}
def describe_role(self, name, meta, response=None):
if not response:
response = self.iam_conn.get_role(role_name=name)
arn = response['Arn']
del response['Arn']
return {
arn: build_description_obj(response, name, meta)
}
def describe_cognito_pool(name, meta, pool_id=None):
if not pool_id:
pool_id = _COGNITO_IDENTITY_CONN.if_pool_exists_by_name(name)
if not pool_id:
return
response = _COGNITO_IDENTITY_CONN.describe_identity_pool(pool_id)
arn = 'arn:aws:cognito-identity:{0}:{1}:identitypool/{2}'.format(
CONFIG.region, CONFIG.account_id, pool_id)
return {arn: build_description_obj(response, name, meta)}
def describe_compute_environment(self, name, meta):
response = self.batch_conn.describe_compute_environments(name)
try:
arn = response['computeEnvironments'][0]['computeEnvironmentArn']
return {arn: build_description_obj(response, name, meta)}
except (KeyError, IndexError):
_LOG.warn("Batch Compute Environment %s not found", name)
return {}
def _create_state_machine_from_meta(self, name, meta):
arn = self._build_sm_arn(name, self.region)
response = self.sf_conn.describe_state_machine(arn)
if response:
_LOG.warn('State machine %s exists', name)
return {arn: build_description_obj(response, name, meta)}
iam_role = meta['iam_role']
role_arn = self.iam_conn.check_if_role_exists(iam_role)
if not role_arn:
raise AssertionError(
'IAM role {0} does not exist.'.format(iam_role))
# check resource exists and get arn
definition = meta['definition']
definition_copy = definition.copy()
for key in definition['States']:
definition_meta = definition['States'][key]
if definition_meta.get('Lambda'):
lambda_name = definition_meta['Lambda']
# alias has a higher priority than version in arn resolving
lambda_version = definition_meta.get('Lambda_version')
lambda_alias = definition_meta.get('Lambda_alias')
lambda_arn = self.resolve_lambda_arn_by_version_and_alias(
lambda_name, lambda_version, lambda_alias)
self.__remove_key_from_dict(definition_copy['States'][key],
'Lambda')
self.__remove_key_from_dict(definition_copy['States'][key],
'Lambda_version')
self.__remove_key_from_dict(definition_copy['States'][key],
'Lambda_alias')
definition_copy['States'][key]['Resource'] = lambda_arn
if definition_meta.get('Activity'):
activity_name = definition_meta['Activity']
activity_arn = 'arn:aws:states:{0}:{1}:activity:{2}'.format(
self.region, self.account_id, activity_name)
activity_info = self.sf_conn.describe_activity(
arn=activity_arn)
if not activity_info:
raise AssertionError('Activity does not exists: %s',
activity_name)
activity_arn = activity_info['activityArn']
del definition_copy['States'][key]['Activity']
definition_copy['States'][key]['Resource'] = activity_arn
machine_info = self.sf_conn.create_state_machine(
machine_name=name, role_arn=role_arn, definition=definition_copy)
event_sources = meta.get('event_sources')
if event_sources:
for trigger_meta in event_sources:
trigger_type = trigger_meta['resource_type']
func = self.CREATE_TRIGGER[trigger_type]
func(name, trigger_meta)
_LOG.info('Created state machine %s.', machine_info['stateMachineArn'])
return self.describe_step_function(name=name, meta=meta, arn=arn)
def describe_policy(self, name, meta, response=None):
arn = self._build_policy_arn(name)
if not response:
response = self.iam_conn.get_policy(arn)
if response:
del response['Arn']
return {
arn: build_description_obj(response, name, meta)
}
def describe_cognito_pool(self, name, meta, pool_id=None):
if not pool_id:
pool_id = self.connection.if_pool_exists_by_name(name)
if not pool_id:
return
response = self.connection.describe_identity_pool(pool_id)
arn = 'arn:aws:cognito-identity:{0}:{1}:identitypool/{2}'.format(
self.region, self.account_id, pool_id)
return {
arn: build_description_obj(response, name, meta)
}
def describe_bucket(name, meta):
arn = 'arn:aws:s3:::{0}'.format(name)
acl_response = _S3_CONN.get_bucket_acl(name)
location_response = _S3_CONN.get_bucket_location(name)
bucket_policy = _S3_CONN.get_bucket_policy(name)
response = {
'bucket_acl': acl_response,
'location': location_response,
}
if bucket_policy:
response['policy'] = bucket_policy
return {arn: build_description_obj(response, name, meta)}
def describe_queue_from_meta(name, meta):
region = meta.get('region', CONFIG.region)
is_fifo = meta.get('fifo_queue', False)
resource_name = _build_resource_name(is_fifo, name)
queue_url = CONN.sqs(region).get_queue_url(resource_name,
CONFIG.account_id)
if not queue_url:
return {}
response = CONN.sqs(region).get_queue_attributes(queue_url)
return {
_build_queue_arn(resource_name, region):
build_description_obj(response, name, meta)
}
def describe_ec2(name, meta, response=None):
if not response:
response = _EC2_CONN.describe_instances()
arn = 'arn:aws:ec2:{0}:{1}:instance/{2}'.format(CONFIG.region,
CONFIG.account_id,
response['InstanceId'])
describe_response = _EC2_CONN.describe_instances([{
'Name':
'instance-id',
'Values': [response['InstanceId']]
}])
response['NetworkInterfaces'] = describe_response
return {arn: build_description_obj(response, name, meta)}
def describe_queue_from_meta(self, name, meta):
region = meta.get('region', self.region)
is_fifo = meta.get('fifo_queue', False)
resource_name = self._build_resource_name(is_fifo, name)
queue_url = self.sqs_conn_builder(region).get_queue_url(
resource_name, self.account_id)
if not queue_url:
return {}
response = self.sqs_conn_builder(region).get_queue_attributes(
queue_url)
return {
self._build_queue_arn(resource_name, region):
build_description_obj(response, name, meta)
}
def describe_api_resources(name, meta, api_id=None):
if not api_id:
api = _API_GATEWAY_CONN.get_api_by_name(name)
if not api:
return
api_id = api['id']
response = _API_GATEWAY_CONN.get_api(api_id)
if not response:
return
response['resources'] = _API_GATEWAY_CONN.get_resources(api_id)
_LOG.info('Created %s API Gateway.', name)
arn = 'arn:aws:apigateway:{0}::/restapis/{1}'.format(CONFIG.region, api_id)
return {arn: build_description_obj(response, name, meta)}
def _create_kinesis_stream_from_meta(self, name, meta):
response = self.kin_conn.get_stream(name)
if response:
stream_status = response['StreamDescription']['StreamStatus']
if stream_status == 'DELETING':
_LOG.debug('Waiting for deletion kinesis stream %s...', name)
time.sleep(120)
else:
_LOG.warn('%s kinesis stream exists', name)
return {
response['StreamARN']:
build_description_obj(response, name, meta)
}
self.kin_conn.create_stream(stream_name=name,
shard_count=meta['shard_count'])
_LOG.info('Created kinesis stream %s.', name)
return self.describe_kinesis_stream(name=name, meta=meta)
def describe_rule_from_meta(self, name, meta):
new_region_args = create_args_for_multi_region(
[
{'name': name,
'meta': meta}
], ALL_REGIONS)
responses = []
for arg in new_region_args:
rule = self._cw_events_conn_builder(arg['region']).get_rule(name)
if rule:
responses.append(rule)
description = []
for rule in responses:
arn = rule[ARN_KEY]
del rule[ARN_KEY]
description.append({arn: build_description_obj(rule, name, meta)})
return description
def describe_sns_from_meta(name, meta):
new_region_args = create_args_for_multi_region([{
'name': name,
'meta': meta
}], ALL_REGIONS)
responses = []
for arg in new_region_args:
region = arg['region']
topic_arn = CONN.sns(region).get_topic_arn(name)
if not topic_arn:
continue
response = CONN.sns(region).get_topic_attributes(topic_arn)
if response:
responses.append({'arn': topic_arn, 'response': response})
description = []
for topic in responses:
description.append({
topic['arn']:
build_description_obj(topic['response'], name, meta)
})
return description
def describe_queue(self, queue_url, name, meta, resource_name, region):
response = self.sqs_conn_builder(region).get_queue_attributes(
queue_url)
arn = self._build_queue_arn(resource_name=resource_name, region=region)
return {arn: build_description_obj(response, name, meta)}
def describe_ebs(name, meta, response=None):
arn = 'arn:aws:elasticbeanstalk:{0}:{1}:application/{2}'.format(
CONFIG.region, CONFIG.account_id, name)
if not response:
response = _EBS_CONN.describe_applications([name])
return {arn: build_description_obj(response, name, meta)}
def describe_activity(self, name, meta):
arn = self.build_activity_arn(name=name)
response = self.sf_conn.describe_activity(arn=arn)
return {arn: build_description_obj(response, name, meta)}
def describe_step_function(self, name, meta, arn=None):
if not arn:
arn = self._build_sm_arn(name, self.region)
response = self.sf_conn.describe_state_machine(arn)
return {arn: build_description_obj(response, name, meta)}
def describe_policy(name, meta, response=None):
arn = _build_policy_arn(name)
if not response:
response = _IAM_CONN.get_policy(arn)
del response['Arn']
return {arn: build_description_obj(response, name, meta)}
def describe_role(name, meta, response=None):
if not response:
response = _IAM_CONN.get_role(role_name=name)
arn = response['Arn']
del response['Arn']
return {arn: build_description_obj(response, name, meta)}
def describe_table(name, meta, response=None):
if not response:
response = _DYNAMO_DB_CONN.describe_table(table_name=name)
arn = response['TableArn']
del response['TableArn']
return {arn: build_description_obj(response, name, meta)}
