def create_deployment_resources(deploy_name, bundle_name,
deploy_only_resources=None,
deploy_only_types=None,
excluded_resources=None,
excluded_types=None,
replace_output=False):
resources = load_meta_resources(bundle_name)
# validate_deployment_packages(resources)
_LOG.info('{0} file was loaded successfully'.format(BUILD_META_FILE_NAME))
# TODO make filter chain
if deploy_only_resources:
resources = dict((k, v) for (k, v) in resources.items() if
k in deploy_only_resources)
if excluded_resources:
resources = dict((k, v) for (k, v) in resources.items() if
k not in excluded_resources)
if deploy_only_types:
resources = dict((k, v) for (k, v) in resources.items() if
v['resource_type'] in deploy_only_types)
if excluded_types:
resources = dict((k, v) for (k, v) in resources.items() if
v['resource_type'] not in excluded_types)
resources = resolve_meta(resources)
_LOG.debug('Names were resolved')
_LOG.debug(prettify_json(resources))
_LOG.debug('Going to create: {0}'.format(prettify_json(resources)))
# sort resources with priority
resources_list = list(resources.items())
resources_list.sort(key=cmp_to_key(_compare_deploy_resources))
_LOG.info('Going to deploy AWS resources')
success, output = deploy_resources(resources_list)
if success:
_LOG.info('AWS resources were deployed successfully')
# apply dynamic changes that uses ARNs
_LOG.info('Going to apply dynamic changes')
_apply_dynamic_changes(resources, output)
_LOG.info('Dynamic changes were applied successfully')
_LOG.info('Going to create deploy output')
create_deploy_output(bundle_name=bundle_name,
deploy_name=deploy_name,
output=output,
success=success,
replace_output=replace_output)
_LOG.info('Deploy output for {0} was created.'.format(deploy_name))
return success
def _populate_s3_path_lambda(meta, bundle_name):
runtime = meta.get('runtime')
if not runtime:
raise AssertionError('Lambda config must contain runtime. '
'Existing configuration: {0}'.format(
prettify_json(meta)))
resolver_func = RUNTIME_PATH_RESOLVER.get(runtime.lower())
if resolver_func:
resolver_func(meta, bundle_name)
else:
raise AssertionError('Lambda config must contain runtime. '
'Existing configuration: {0}'.format(
prettify_json(meta)))
def continue_deployment_resources(deploy_name,
bundle_name,
deploy_only_resources=None,
deploy_only_types=None,
excluded_resources=None,
excluded_types=None):
output = load_failed_deploy_output(bundle_name, deploy_name)
_LOG.info('Failed output file was loaded successfully')
resources = resolve_meta(load_meta_resources(bundle_name))
_LOG.debug('Names were resolved')
_LOG.debug(prettify_json(resources))
# TODO make filter chain
if deploy_only_resources:
resources = dict((k, v) for (k, v) in resources.items()
if k in deploy_only_resources)
if excluded_resources:
resources = dict((k, v) for (k, v) in resources.items()
if k not in excluded_resources)
if deploy_only_types:
resources = dict((k, v) for (k, v) in resources.items()
if v['resource_type'] in deploy_only_types)
if excluded_types:
resources = dict((k, v) for (k, v) in resources.items()
if v['resource_type'] not in excluded_types)
# sort resources with priority
resources_list = list(resources.items())
resources_list.sort(key=cmp_to_key(_compare_deploy_resources))
success, updated_output = continue_deploy_resources(resources_list, output)
_LOG.info('AWS resources were deployed successfully')
if success:
# apply dynamic changes that uses ARNs
_LOG.info('Going to apply dynamic changes')
_apply_dynamic_changes(resources, updated_output)
_LOG.info('Dynamic changes were applied successfully')
# remove failed output from bucket
remove_failed_deploy_output(bundle_name, deploy_name)
_LOG.info('Going to create deploy output')
create_deploy_output(bundle_name,
deploy_name,
prettify_json(updated_output),
success=success)
return success
def apply_trusted_to_role(self, name, value, apply_config):
trusted = apply_config['trusted_relationships']
role_name = apply_config['dependency_name']
resolved_trusted = resolve_dynamic_identifier(name, value, trusted)
self.iam_conn.update_assume_role_policy_document(
role_name=role_name,
document=prettify_json(resolved_trusted))
def resolve_meta(overall_meta):
iam_suffix = _resolve_iam_suffix(iam_suffix=CONFIG.iam_suffix)
if CONFIG.aliases:
for key, value in CONFIG.aliases.items():
name = '${' + key + '}'
overall_meta = resolve_dynamic_identifier(name, value,
overall_meta)
_LOG.debug('Resolved meta was created')
_LOG.debug(prettify_json(overall_meta))
# get dict with resolved prefix and suffix in meta resources
# key: current_name, value: resolved_name
resolved_names = {}
for name, res_meta in overall_meta.items():
resource_type = res_meta['resource_type']
if resource_type in GLOBAL_AWS_SERVICES:
resolved_name = resolve_resource_name(name)
# add iam_suffix to IAM role only if it is specified in config file
if resource_type == IAM_ROLE and iam_suffix:
resolved_name = resolved_name + iam_suffix
if name != resolved_name:
resolved_names[name] = resolved_name
_LOG.debug('Going to resolve names in meta')
_LOG.debug('Resolved names mapping: {0}'.format(str(resolved_names)))
for current_name, resolved_name in resolved_names.items():
overall_meta[resolved_name] = overall_meta.pop(current_name)
_resolve_names_in_meta(overall_meta, current_name, resolved_name)
return overall_meta
def _install_local_req(artifact_path, local_req_path, project_base_folder,
project_path):
with open(local_req_path) as f:
local_req_list = f.readlines()
local_req_list = [path_resolver(r.strip()) for r in local_req_list]
_LOG.debug('Local dependencies: {0}'.format(prettify_json(local_req_list)))
# copy folders
for lrp in local_req_list:
_LOG.debug('Processing dependency: {0}'.format(lrp))
folder_path = build_path(artifact_path, project_base_folder, lrp)
if not os.path.exists(folder_path):
os.makedirs(folder_path)
dir_util.copy_tree(build_path(CONFIG.project_path, project_path, lrp),
folder_path)
_LOG.debug('Dependency was copied successfully')
folders = [r for r in lrp.split(DEFAULT_SEP) if r]
# process folder from root python project
folders.insert(0, '')
i = 0
temp_path = ''
while i < len(folders):
temp_path += DEFAULT_SEP + folders[i]
src_path = build_path(CONFIG.project_path, project_path, temp_path)
dst_path = build_path(artifact_path, project_base_folder,
temp_path)
_copy_py_files(src_path, dst_path)
i += 1
_LOG.debug('Python files from packages were copied successfully')
def _populate_s3_path_ebs(meta, bundle_name):
deployment_package = meta.get('deployment_package')
if not deployment_package:
raise AssertionError('Beanstalk_app config must contain '
'deployment_package. Existing configuration'
': {0}'.format(prettify_json(meta)))
else:
meta[S3_PATH_NAME] = build_path(bundle_name, deployment_package)
def _populate_s3_path_lambda_layer(meta, bundle_name):
deployment_package = meta.get('deployment_package')
if not deployment_package:
raise AssertionError('Lambda Layer config must contain deployment_package. '
'Existing configuration'
': {0}'.format(prettify_json(meta)))
else:
meta[S3_PATH_NAME] = build_path(bundle_name, deployment_package)
def _populate_s3_path_python_node(meta, bundle_name):
name = meta.get('name')
version = meta.get('version')
if not name or not version:
raise AssertionError('Lambda config must contain name and version. '
'Existing configuration'
': {0}'.format(prettify_json(meta)))
else:
meta[S3_PATH_NAME] = build_path(bundle_name,
build_py_package_name(name, version))
def apply_policy_content(name, value, apply_config):
policy_content = apply_config['policy_content']
policy_name = apply_config['dependency_name']
resolved_policy_content = resolve_dynamic_identifier(
name, value, policy_content)
policy_arn = 'arn:aws:iam::{0}:policy/{1}'.format(CONFIG.account_id,
policy_name)
_IAM_CONN.create_policy_version(
policy_arn=policy_arn,
policy_document=prettify_json(resolved_policy_content),
set_as_default=True)
def validate_deployment_packages(bundle_path, meta_resources):
package_paths = artifact_paths(meta_resources)
nonexistent_packages = []
for package in package_paths:
package_path = build_path(bundle_path, package)
if not os.path.exists(package_path):
nonexistent_packages.append(package_path)
if nonexistent_packages:
raise AssertionError('Bundle is not properly configured.'
' Nonexistent deployment packages: '
'{0}'.format(prettify_json(nonexistent_packages)))
def update_deployment_resources(bundle_name,
deploy_name,
replace_output=False,
update_only_types=None,
update_only_resources=None):
from syndicate.core import PROCESSOR_FACADE
resources = resolve_meta(load_meta_resources(bundle_name))
_LOG.debug(prettify_json(resources))
_LOG.warn('Please pay attention that only the '
'following resources types are supported for update: {}'.format(
list(PROCESSOR_FACADE.update_handlers().keys())))
# TODO make filter chain
resources = dict(
(k, v) for (k, v) in resources.items()
if v['resource_type'] in PROCESSOR_FACADE.update_handlers().keys())
if update_only_types:
resources = dict((k, v) for (k, v) in resources.items()
if v['resource_type'] in update_only_types)
if update_only_resources:
resources = dict((k, v) for (k, v) in resources.items()
if k in update_only_resources)
_LOG.debug('Going to update the following resources: {0}'.format(
prettify_json(resources)))
resources_list = list(resources.items())
resources_list.sort(key=cmp_to_key(_compare_update_resources))
success, output = _process_resources(
resources=resources_list,
handlers_mapping=PROCESSOR_FACADE.update_handlers(),
pass_context=True)
create_deploy_output(bundle_name=bundle_name,
deploy_name=deploy_name,
output=output,
success=success,
replace_output=replace_output)
return success
def update_lambdas(bundle_name, publish_only_lambdas,
excluded_lambdas_resources):
resources = resolve_meta(load_meta_resources(bundle_name))
_LOG.debug('Names were resolved')
_LOG.debug(prettify_json(resources))
# TODO make filter chain
resources = dict((k, v) for (k, v) in resources.items()
if v['resource_type'] == LAMBDA_TYPE)
if publish_only_lambdas:
resources = dict((k, v) for (k, v) in resources.items()
if k in publish_only_lambdas)
if excluded_lambdas_resources:
resources = dict((k, v) for (k, v) in resources.items()
if k not in excluded_lambdas_resources)
_LOG.debug('Going to update the following lambdas: {0}'.format(
prettify_json(resources)))
resources = list(resources.items())
update_resources(resources=resources)
def _populate_s3_path_lambda(meta, bundle_name):
runtime = meta.get('runtime')
if not runtime:
raise AssertionError('Lambda config must contain runtime. '
'Existing configuration: {0}'.format(
prettify_json(meta)))
resolver_func = RUNTIME_PATH_RESOLVER.get(runtime.lower())
if resolver_func:
resolver_func(meta, bundle_name)
else:
raise AssertionError('Specified runtime {0} in {1} is not supported. '
'Supported runtimes: {2}'.format(
runtime.lower(), meta.get('name'),
list(RUNTIME_PATH_RESOLVER.keys())))
