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())))