def test_lambda_function_name_invalid(self):
with pytest.raises(InvalidArnException):
assert lambda_function_name(
"arn:aws:lambda:aws-region:acct-id") is None
with pytest.raises(ValueError):
assert lambda_function_name(
"arn:aws:sqs:aws-region:acct-id:foo") is None
def send_log_event(*args, **kwargs):
if backend.get_function(args[0]):
return send_log_event_orig(*args, **kwargs)
filter_name = args[1]
log_group_name = args[2]
log_stream_name = args[3]
log_events = args[4]
data = {
'messageType': 'DATA_MESSAGE',
'owner': aws_stack.get_account_id(),
'logGroup': log_group_name,
'logStream': log_stream_name,
'subscriptionFilters': [filter_name],
'logEvents': log_events,
}
payload = base64.b64encode(
json.dumps(data,
separators=(',',
':')).encode('utf-8')).decode('utf-8')
event = {'awslogs': {'data': payload}}
client = aws_stack.connect_to_service('lambda')
lambda_name = aws_stack.lambda_function_name(args[0])
client.invoke(FunctionName=lambda_name, Payload=event)
def send_log_event(*args, **kwargs):
filter_name = args[1]
log_group_name = args[2]
log_stream_name = args[3]
log_events = args[4]
data = {
'messageType': 'DATA_MESSAGE',
'owner': aws_stack.get_account_id(),
'logGroup': log_group_name,
'logStream': log_stream_name,
'subscriptionFilters': [filter_name],
'logEvents': log_events,
}
output = io.BytesIO()
with GzipFile(fileobj=output, mode='w') as f:
f.write(
json.dumps(data, separators=(',', ':')).encode('utf-8'))
payload_gz_encoded = base64.b64encode(
output.getvalue()).decode('utf-8')
event = {'awslogs': {'data': payload_gz_encoded}}
client = aws_stack.connect_to_service('lambda')
lambda_name = aws_stack.lambda_function_name(args[0])
client.invoke(FunctionName=lambda_name, Payload=json.dumps(event))
def fetch_state(self, stack_name, resources):
name = self.resolve_refs_recursively(stack_name, self.props.get('FunctionName'), resources)
if not name:
return None
func_name = aws_stack.lambda_function_name(name)
func_version = name.split(':')[7] if len(name.split(':')) > 7 else '$LATEST'
versions = aws_stack.connect_to_service('lambda').list_versions_by_function(FunctionName=func_name)
return ([v for v in versions['Versions'] if v['Version'] == func_version] or [None])[0]
def put_log_events_model(self, log_group_name, log_stream_name, log_events,
sequence_token):
# TODO: call/patch upstream method here, instead of duplicating the code!
self.last_ingestion_time = int(unix_time_millis())
self.stored_bytes += sum(
[len(log_event["message"]) for log_event in log_events])
events = [
logs_models.LogEvent(self.last_ingestion_time, log_event)
for log_event in log_events
]
self.events += events
self.upload_sequence_token += 1
log_events = [{
"id": event.event_id,
"timestamp": event.timestamp,
"message": event.message,
} for event in events]
data = {
"messageType": "DATA_MESSAGE",
"owner": aws_stack.get_account_id(),
"logGroup": log_group_name,
"logStream": log_stream_name,
"subscriptionFilters": [self.filter_name],
"logEvents": log_events,
}
output = io.BytesIO()
with GzipFile(fileobj=output, mode="w") as f:
f.write(json.dumps(data, separators=(",", ":")).encode("utf-8"))
payload_gz_encoded = base64.b64encode(
output.getvalue()).decode("utf-8")
event = {"awslogs": {"data": payload_gz_encoded}}
if self.destination_arn:
if ":lambda:" in self.destination_arn:
client = aws_stack.connect_to_service("lambda")
lambda_name = aws_stack.lambda_function_name(
self.destination_arn)
client.invoke(FunctionName=lambda_name,
Payload=json.dumps(event))
if ":kinesis:" in self.destination_arn:
client = aws_stack.connect_to_service("kinesis")
stream_name = aws_stack.kinesis_stream_name(
self.destination_arn)
client.put_record(
StreamName=stream_name,
Data=json.dumps(payload_gz_encoded),
PartitionKey=log_group_name,
)
if ":firehose:" in self.destination_arn:
client = aws_stack.connect_to_service("firehose")
firehose_name = aws_stack.firehose_name(self.destination_arn)
client.put_record(
DeliveryStreamName=firehose_name,
Record={"Data": json.dumps(payload_gz_encoded)},
)
def Mapping_create_from_cloudformation_json(cls, resource_name,
cloudformation_json,
region_name):
props = cloudformation_json.get('Properties', {})
func_name = props.get('FunctionName') or ''
if ':lambda:' in func_name:
props['FunctionName'] = aws_stack.lambda_function_name(func_name)
return Mapping_create_from_cloudformation_json_orig(
resource_name, cloudformation_json, region_name)
def get_function(*args, **kwargs):
result = get_function_orig(*args, **kwargs)
if result:
return result
# in case if lambda is not present in moto fall back to
# fetching Lambda details from LocalStack API directly
client = aws_stack.connect_to_service('lambda')
lambda_name = aws_stack.lambda_function_name(args[0])
response = client.get_function(FunctionName=lambda_name)
return response
def fetch_state(self, stack_name, resources):
name = self.resolve_refs_recursively(stack_name, self.props.get("FunctionName"), resources)
if not name:
return None
func_name = aws_stack.lambda_function_name(name)
func_version = name.split(":")[7] if len(name.split(":")) > 7 else "$LATEST"
versions = aws_stack.connect_to_service("lambda").list_versions_by_function(
FunctionName=func_name
)
return ([v for v in versions["Versions"] if v["Version"] == func_version] or [None])[0]
def put_subscription_filter(*args, **kwargs):
log_group_name = args[0]
filter_name = args[1]
filter_pattern = args[2]
destination_arn = args[3]
role_arn = args[4]
log_group = logs_models.logs_backends[
aws_stack.get_region()].groups.get(log_group_name)
if not log_group:
raise ResourceNotFoundException(
'The specified log group does not exist.')
if ':lambda:' in destination_arn:
client = aws_stack.connect_to_service('lambda')
lambda_name = aws_stack.lambda_function_name(destination_arn)
try:
client.get_function(FunctionName=lambda_name)
except Exception:
raise InvalidParameterException(
'destinationArn for vendor lambda cannot be used with roleArn'
)
elif ':kinesis:' in destination_arn:
client = aws_stack.connect_to_service('kinesis')
stream_name = aws_stack.kinesis_stream_name(destination_arn)
try:
client.describe_stream(StreamName=stream_name)
except Exception:
raise InvalidParameterException(
'Could not deliver test message to specified Kinesis stream. '
'Check if the given kinesis stream is in ACTIVE state. '
)
elif ':firehose:' in destination_arn:
client = aws_stack.connect_to_service('firehose')
firehose_name = aws_stack.firehose_name(destination_arn)
try:
client.describe_delivery_stream(
DeliveryStreamName=firehose_name)
except Exception:
raise InvalidParameterException(
'Could not deliver test message to specified Firehose stream. '
'Check if the given Firehose stream is in ACTIVE state.'
)
else:
service = aws_stack.extract_service_from_arn(destination_arn)
raise InvalidParameterException(
'PutSubscriptionFilter operation cannot work with destinationArn for vendor %s'
% service)
log_group.put_subscription_filter(filter_name, filter_pattern,
destination_arn, role_arn)
def moto_put_subscription_filter(fn, self, *args, **kwargs):
log_group_name = args[0]
filter_name = args[1]
filter_pattern = args[2]
destination_arn = args[3]
role_arn = args[4]
log_group = self.groups.get(log_group_name)
if not log_group:
raise ResourceNotFoundException("The specified log group does not exist.")
if ":lambda:" in destination_arn:
client = aws_stack.connect_to_service("lambda")
lambda_name = aws_stack.lambda_function_name(destination_arn)
try:
client.get_function(FunctionName=lambda_name)
except Exception:
raise InvalidParameterException(
"destinationArn for vendor lambda cannot be used with roleArn"
)
elif ":kinesis:" in destination_arn:
client = aws_stack.connect_to_service("kinesis")
stream_name = aws_stack.kinesis_stream_name(destination_arn)
try:
client.describe_stream(StreamName=stream_name)
except Exception:
raise InvalidParameterException(
"Could not deliver test message to specified Kinesis stream. "
"Check if the given kinesis stream is in ACTIVE state. "
)
elif ":firehose:" in destination_arn:
client = aws_stack.connect_to_service("firehose")
firehose_name = aws_stack.firehose_name(destination_arn)
try:
client.describe_delivery_stream(DeliveryStreamName=firehose_name)
except Exception:
raise InvalidParameterException(
"Could not deliver test message to specified Firehose stream. "
"Check if the given Firehose stream is in ACTIVE state."
)
else:
service = aws_stack.extract_service_from_arn(destination_arn)
raise InvalidParameterException(
f"PutSubscriptionFilter operation cannot work with destinationArn for vendor {service}"
)
if filter_pattern:
for stream in log_group.streams.values():
stream.filter_pattern = filter_pattern
log_group.put_subscription_filter(filter_name, filter_pattern, destination_arn, role_arn)
def put_log_events_model(self, log_group_name, log_stream_name, log_events,
sequence_token):
self.lastIngestionTime = int(unix_time_millis())
self.storedBytes += sum(
[len(log_event['message']) for log_event in log_events])
events = [
logs_models.LogEvent(self.lastIngestionTime, log_event)
for log_event in log_events
]
self.events += events
self.uploadSequenceToken += 1
log_events = [{
'id': event.eventId,
'timestamp': event.timestamp,
'message': event.message,
} for event in events]
data = {
'messageType': 'DATA_MESSAGE',
'owner': aws_stack.get_account_id(),
'logGroup': log_group_name,
'logStream': log_stream_name,
'subscriptionFilters': [self.filter_name],
'logEvents': log_events,
}
output = io.BytesIO()
with GzipFile(fileobj=output, mode='w') as f:
f.write(json.dumps(data, separators=(',', ':')).encode('utf-8'))
payload_gz_encoded = base64.b64encode(
output.getvalue()).decode('utf-8')
event = {'awslogs': {'data': payload_gz_encoded}}
if self.destination_arn:
if ':lambda:' in self.destination_arn:
client = aws_stack.connect_to_service('lambda')
lambda_name = aws_stack.lambda_function_name(
self.destination_arn)
client.invoke(FunctionName=lambda_name,
Payload=json.dumps(event))
if ':kinesis:' in self.destination_arn:
client = aws_stack.connect_to_service('kinesis')
stream_name = aws_stack.kinesis_stream_name(
self.destination_arn)
client.put_record(StreamName=stream_name,
Data=json.dumps(payload_gz_encoded),
PartitionKey=log_group_name)
if ':firehose:' in self.destination_arn:
client = aws_stack.connect_to_service('firehose')
firehose_name = aws_stack.firehose_name(self.destination_arn)
client.put_record(
DeliveryStreamName=firehose_name,
Record={'Data': json.dumps(payload_gz_encoded)})
def Mapping_create_from_cloudformation_json(cls, resource_name, cloudformation_json, region_name):
props = cloudformation_json.get('Properties', {})
func_name = props.get('FunctionName') or ''
if ':lambda:' in func_name:
props['FunctionName'] = aws_stack.lambda_function_name(func_name)
try:
return Mapping_create_from_cloudformation_json_orig(resource_name, cloudformation_json, region_name)
except Exception:
LOG.info('Unable to add Lambda event mapping for source ARN "%s" in moto backend (ignoring)' %
props.get('EventSourceArn'))
# return an empty dummy instance, to avoid downstream None value issues
return service_models.BaseModel()
def get_function(fn, self, *args, **kwargs):
result = fn(self, *args, **kwargs)
if result:
return result
client = aws_stack.connect_to_service("lambda")
lambda_name = aws_stack.lambda_function_name(args[0])
response = client.get_function(FunctionName=lambda_name)
spec = response["Configuration"]
spec["Code"] = {"ZipFile": "ZW1wdHkgc3RyaW5n"}
region = aws_stack.extract_region_from_arn(spec["FunctionArn"])
new_function = moto_awslambda_models.LambdaFunction(spec, region)
return new_function
def retrieve_resource_details(resource_id, resource_status, resources,
stack_name):
resource = resources.get(resource_id)
resource_id = resource_status.get('PhysicalResourceId') or resource_id
if not resource:
resource = {}
resource_type = get_resource_type(resource)
resource_props = resource.get('Properties')
try:
if resource_type == 'Lambda::Function':
resource_id = resource_props[
'FunctionName'] if resource else resource_id
return aws_stack.connect_to_service('lambda').get_function(
FunctionName=resource_id)
elif resource_type == 'Lambda::Version':
name = resource_props['FunctionName']
func_name = aws_stack.lambda_function_name(name)
func_version = name.split(':')[7] if len(
name.split(':')) > 7 else '$LATEST'
versions = aws_stack.connect_to_service(
'lambda').list_versions_by_function(FunctionName=func_name)
return ([
v for v in versions['Versions'] if v['Version'] == func_version
] or [None])[0]
elif resource_type == 'Lambda::EventSourceMapping':
resource_id = resource_props[
'FunctionName'] if resource else resource_id
source_arn = resource_props.get('EventSourceArn')
resource_id = resolve_refs_recursively(stack_name, resource_id,
resources)
source_arn = resolve_refs_recursively(stack_name, source_arn,
resources)
if not resource_id or not source_arn:
raise Exception('ResourceNotFound')
mappings = aws_stack.connect_to_service(
'lambda').list_event_source_mappings(FunctionName=resource_id,
EventSourceArn=source_arn)
mapping = list(
filter(
lambda m: m['EventSourceArn'] == source_arn and m[
'FunctionArn'] == aws_stack.lambda_function_arn(
resource_id), mappings['EventSourceMappings']))
if not mapping:
raise Exception('ResourceNotFound')
return mapping[0]
elif resource_type == 'DynamoDB::Table':
resource_id = resource_props[
'TableName'] if resource else resource_id
return aws_stack.connect_to_service('dynamodb').describe_table(
TableName=resource_id)
elif resource_type == 'ApiGateway::RestApi':
apis = aws_stack.connect_to_service(
'apigateway').get_rest_apis()['items']
resource_id = resource_props['Name'] if resource else resource_id
result = list(filter(lambda api: api['name'] == resource_id, apis))
return result[0] if result else None
elif resource_type == 'ApiGateway::Resource':
api_id = resource_props['RestApiId'] if resource else resource_id
api_id = resolve_refs_recursively(stack_name, api_id, resources)
parent_id = resolve_refs_recursively(stack_name,
resource_props['ParentId'],
resources)
if not api_id or not parent_id:
return None
api_resources = aws_stack.connect_to_service(
'apigateway').get_resources(restApiId=api_id)['items']
target_resource = list(
filter(
lambda res: res.get('parentId') == parent_id and res[
'pathPart'] == resource_props['PathPart'],
api_resources))
if not target_resource:
return None
path = aws_stack.get_apigateway_path_for_resource(
api_id, target_resource[0]['id'], resources=api_resources)
result = list(
filter(lambda res: res['path'] == path, api_resources))
return result[0] if result else None
elif resource_type == 'ApiGateway::Deployment':
api_id = resource_props['RestApiId'] if resource else resource_id
api_id = resolve_refs_recursively(stack_name, api_id, resources)
if not api_id:
return None
result = aws_stack.connect_to_service(
'apigateway').get_deployments(restApiId=api_id)['items']
# TODO possibly filter results by stage name or other criteria
return result[0] if result else None
elif resource_type == 'ApiGateway::Method':
api_id = resolve_refs_recursively(stack_name,
resource_props['RestApiId'],
resources)
res_id = resolve_refs_recursively(stack_name,
resource_props['ResourceId'],
resources)
if not api_id or not res_id:
return None
res_obj = aws_stack.connect_to_service('apigateway').get_resource(
restApiId=api_id, resourceId=res_id)
match = [
v for (k, v) in res_obj['resourceMethods'].items()
if resource_props['HttpMethod'] in (v.get('httpMethod'), k)
]
return match or None
elif resource_type == 'SQS::Queue':
sqs_client = aws_stack.connect_to_service('sqs')
queues = sqs_client.list_queues()
result = list(
filter(
lambda item:
# TODO possibly find a better way to compare resource_id with queue URLs
item.endswith('/%s' % resource_id),
queues.get('QueueUrls', [])))
if not result:
return None
result = sqs_client.get_queue_attributes(
QueueUrl=result[0], AttributeNames=['All'])['Attributes']
result['Arn'] = result['QueueArn']
return result
elif resource_type == 'SNS::Topic':
topics = aws_stack.connect_to_service('sns').list_topics()
result = list(
filter(lambda item: item['TopicArn'] == resource_id,
topics.get('Topics', [])))
return result[0] if result else None
elif resource_type == 'S3::Bucket':
bucket_name = resource_props.get('BucketName') or resource_id
return aws_stack.connect_to_service('s3').get_bucket_location(
Bucket=bucket_name)
elif resource_type == 'Logs::LogGroup':
# TODO implement
raise Exception('ResourceNotFound')
elif resource_type == 'Kinesis::Stream':
stream_name = resolve_refs_recursively(stack_name,
resource_props['Name'],
resources)
result = aws_stack.connect_to_service('kinesis').describe_stream(
StreamName=stream_name)
return result
elif resource_type == 'StepFunctions::StateMachine':
sm_name = resource_props.get('StateMachineName') or resource_id
sm_name = resolve_refs_recursively(stack_name, sm_name, resources)
sfn_client = aws_stack.connect_to_service('stepfunctions')
state_machines = sfn_client.list_state_machines()['stateMachines']
sm_arn = [
m['stateMachineArn'] for m in state_machines
if m['name'] == sm_name
]
if not sm_arn:
return None
result = sfn_client.describe_state_machine(
stateMachineArn=sm_arn[0])
return result
if is_deployable_resource(resource):
LOG.warning(
'Unexpected resource type %s when resolving references of resource %s: %s'
% (resource_type, resource_id, resource))
except Exception as e:
# we expect this to be a "not found" exception
markers = ['NoSuchBucket', 'ResourceNotFound', '404']
if not list(filter(lambda marker, e=e: marker in str(e), markers)):
LOG.warning(
'Unexpected error retrieving details for resource %s: %s %s - %s %s'
% (resource_type, e, traceback.format_exc(), resource,
resource_status))
return None
def retrieve_resource_details(resource_id, resource_status, resources, stack_name):
resource = resources.get(resource_id)
resource_id = resource_status.get('PhysicalResourceId') or resource_id
if not resource:
resource = {}
resource_type = get_resource_type(resource)
resource_props = resource.get('Properties')
try:
if resource_type == 'Lambda::Function':
resource_props['FunctionName'] = (resource_props.get('FunctionName') or
'{}-lambda-{}'.format(stack_name[:45], common.short_uid()))
resource_id = resource_props['FunctionName'] if resource else resource_id
return aws_stack.connect_to_service('lambda').get_function(FunctionName=resource_id)
elif resource_type == 'Lambda::Version':
name = resource_props.get('FunctionName')
if not name:
return None
func_name = aws_stack.lambda_function_name(name)
func_version = name.split(':')[7] if len(name.split(':')) > 7 else '$LATEST'
versions = aws_stack.connect_to_service('lambda').list_versions_by_function(FunctionName=func_name)
return ([v for v in versions['Versions'] if v['Version'] == func_version] or [None])[0]
elif resource_type == 'Lambda::EventSourceMapping':
resource_id = resource_props['FunctionName'] if resource else resource_id
source_arn = resource_props.get('EventSourceArn')
resource_id = resolve_refs_recursively(stack_name, resource_id, resources)
source_arn = resolve_refs_recursively(stack_name, source_arn, resources)
if not resource_id or not source_arn:
raise Exception('ResourceNotFound')
mappings = aws_stack.connect_to_service('lambda').list_event_source_mappings(
FunctionName=resource_id, EventSourceArn=source_arn)
mapping = list(filter(lambda m:
m['EventSourceArn'] == source_arn and m['FunctionArn'] == aws_stack.lambda_function_arn(resource_id),
mappings['EventSourceMappings']))
if not mapping:
raise Exception('ResourceNotFound')
return mapping[0]
elif resource_type == 'IAM::Role':
role_name = resource_props.get('RoleName') or resource_id
role_name = resolve_refs_recursively(stack_name, role_name, resources)
return aws_stack.connect_to_service('iam').get_role(RoleName=role_name)['Role']
elif resource_type == 'DynamoDB::Table':
table_name = resource_props.get('TableName') or resource_id
table_name = resolve_refs_recursively(stack_name, table_name, resources)
return aws_stack.connect_to_service('dynamodb').describe_table(TableName=table_name)
elif resource_type == 'ApiGateway::RestApi':
apis = aws_stack.connect_to_service('apigateway').get_rest_apis()['items']
api_name = resource_props['Name'] if resource else resource_id
api_name = resolve_refs_recursively(stack_name, api_name, resources)
result = list(filter(lambda api: api['name'] == api_name, apis))
return result[0] if result else None
elif resource_type == 'ApiGateway::Resource':
api_id = resource_props['RestApiId'] if resource else resource_id
api_id = resolve_refs_recursively(stack_name, api_id, resources)
parent_id = resolve_refs_recursively(stack_name, resource_props['ParentId'], resources)
if not api_id or not parent_id:
return None
api_resources = aws_stack.connect_to_service('apigateway').get_resources(restApiId=api_id)['items']
target_resource = list(filter(lambda res:
res.get('parentId') == parent_id and res['pathPart'] == resource_props['PathPart'], api_resources))
if not target_resource:
return None
path = aws_stack.get_apigateway_path_for_resource(api_id,
target_resource[0]['id'], resources=api_resources)
result = list(filter(lambda res: res['path'] == path, api_resources))
return result[0] if result else None
elif resource_type == 'ApiGateway::Deployment':
api_id = resource_props['RestApiId'] if resource else resource_id
api_id = resolve_refs_recursively(stack_name, api_id, resources)
if not api_id:
return None
result = aws_stack.connect_to_service('apigateway').get_deployments(restApiId=api_id)['items']
# TODO possibly filter results by stage name or other criteria
return result[0] if result else None
elif resource_type == 'ApiGateway::Method':
api_id = resolve_refs_recursively(stack_name, resource_props['RestApiId'], resources)
res_id = resolve_refs_recursively(stack_name, resource_props['ResourceId'], resources)
if not api_id or not res_id:
return None
res_obj = aws_stack.connect_to_service('apigateway').get_resource(restApiId=api_id, resourceId=res_id)
match = [v for (k, v) in res_obj['resourceMethods'].items()
if resource_props['HttpMethod'] in (v.get('httpMethod'), k)]
int_props = resource_props.get('Integration')
if int_props:
match = [m for m in match if
m.get('methodIntegration', {}).get('type') == int_props.get('Type') and
m.get('methodIntegration', {}).get('httpMethod') == int_props.get('IntegrationHttpMethod')]
return any(match) or None
elif resource_type == 'ApiGateway::GatewayResponse':
api_id = resolve_refs_recursively(stack_name, resource_props['RestApiId'], resources)
client = aws_stack.connect_to_service('apigateway')
result = client.get_gateway_response(restApiId=api_id, responseType=resource_props['ResponseType'])
return result if 'responseType' in result else None
elif resource_type == 'SQS::Queue':
sqs_client = aws_stack.connect_to_service('sqs')
queues = sqs_client.list_queues()
result = list(filter(lambda item:
# TODO possibly find a better way to compare resource_id with queue URLs
item.endswith('/%s' % resource_id), queues.get('QueueUrls', [])))
if not result:
return None
result = sqs_client.get_queue_attributes(QueueUrl=result[0], AttributeNames=['All'])['Attributes']
result['Arn'] = result['QueueArn']
return result
elif resource_type == 'SNS::Topic':
topics = aws_stack.connect_to_service('sns').list_topics()
result = list(filter(lambda item: item['TopicArn'] == resource_id, topics.get('Topics', [])))
return result[0] if result else None
elif resource_type == 'S3::Bucket':
bucket_name = resource_props.get('BucketName') or resource_id
bucket_name = resolve_refs_recursively(stack_name, bucket_name, resources)
bucket_name = s3_listener.normalize_bucket_name(bucket_name)
s3_client = aws_stack.connect_to_service('s3')
response = s3_client.get_bucket_location(Bucket=bucket_name)
notifs = resource_props.get('NotificationConfiguration')
if not response or not notifs:
return response
configs = s3_client.get_bucket_notification_configuration(Bucket=bucket_name)
has_notifs = (configs.get('TopicConfigurations') or configs.get('QueueConfigurations') or
configs.get('LambdaFunctionConfigurations'))
if notifs and not has_notifs:
return None
return response
elif resource_type == 'S3::BucketPolicy':
bucket_name = resource_props.get('Bucket') or resource_id
bucket_name = resolve_refs_recursively(stack_name, bucket_name, resources)
return aws_stack.connect_to_service('s3').get_bucket_policy(Bucket=bucket_name)
elif resource_type == 'Logs::LogGroup':
# TODO implement
raise Exception('ResourceNotFound')
elif resource_type == 'Kinesis::Stream':
stream_name = resolve_refs_recursively(stack_name, resource_props['Name'], resources)
result = aws_stack.connect_to_service('kinesis').describe_stream(StreamName=stream_name)
return result
elif resource_type == 'StepFunctions::StateMachine':
sm_name = resource_props.get('StateMachineName') or resource_id
sm_name = resolve_refs_recursively(stack_name, sm_name, resources)
sfn_client = aws_stack.connect_to_service('stepfunctions')
state_machines = sfn_client.list_state_machines()['stateMachines']
sm_arn = [m['stateMachineArn'] for m in state_machines if m['name'] == sm_name]
if not sm_arn:
return None
result = sfn_client.describe_state_machine(stateMachineArn=sm_arn[0])
return result
elif resource_type == 'StepFunctions::Activity':
act_name = resource_props.get('Name') or resource_id
act_name = resolve_refs_recursively(stack_name, act_name, resources)
sfn_client = aws_stack.connect_to_service('stepfunctions')
activities = sfn_client.list_activities()['activities']
result = [a['activityArn'] for a in activities if a['name'] == act_name]
if not result:
return None
return result[0]
if is_deployable_resource(resource):
LOG.warning('Unexpected resource type %s when resolving references of resource %s: %s' %
(resource_type, resource_id, resource))
except Exception as e:
check_not_found_exception(e, resource_type, resource, resource_status)
return None
def test_lambda_function_name(self):
assert (lambda_function_name(
"arn:aws:lambda:aws-region:acct-id:function:helloworld:42") ==
"helloworld")
assert lambda_function_name("helloworld") == "helloworld"