def build_ordered_imports_recursive(_current_parsed_dsl_holder, _current_import, context_namespace=None): imports_key_holder, imports_value_holder = _current_parsed_dsl_holder.\ get_item(constants.IMPORTS) if not imports_value_holder: return for another_import in imports_value_holder.restore(): namespace, import_url = _extract_import_parts( another_import, resources_base_path, _current_import) validate_namespace(namespace) if context_namespace: if namespace: namespace = utils.generate_namespaced_value( context_namespace, namespace) else: # In case a namespace was added earlier in the import # chain. namespace = context_namespace if import_url is None: ex = exceptions.DSLParsingLogicException( 13, "Import failed: no suitable location found for " "import '{0}'".format(another_import)) ex.failed_import = another_import raise ex if utils.is_blueprint_import(import_url): validate_blueprint_import_namespace(namespace, import_url) blueprint_id = utils.remove_blueprint_import_prefix(import_url) blueprint_imports.add(blueprint_id) add_namespace_to_mapping(blueprint_id, namespace) import_key = resolve_import_graph_key(import_url, namespace) import_context = (location(_current_import), context_namespace) if import_key in imports_graph: is_cloudify_types = imports_graph[import_key]['cloudify_types'] validate_import_namespace(namespace, is_cloudify_types, context_namespace) imports_graph.add_graph_dependency(import_url, import_context, namespace) else: imported_dsl = resolver.fetch_import(import_url) if not is_parsed_resource(imported_dsl): imported_dsl = utils.load_yaml( raw_yaml=imported_dsl, error_message="Failed to parse import '{0}'" "(via '{1}')".format(another_import, import_url), filename=import_url) cloudify_basic_types = is_cloudify_basic_types(imported_dsl) validate_import_namespace(namespace, cloudify_basic_types, context_namespace) if cloudify_basic_types: # Remove namespace data from import namespace = None imports_graph.add(import_url, imported_dsl, cloudify_basic_types, import_context, namespace) build_ordered_imports_recursive(imported_dsl, import_url, namespace)
def handle_intrinsic_function_namespace(holder_element, element): """ This will traverse the element in search of the key, and will run the set namespace function on the key's values only for the relevant intrinsic functions. """ def traverse_list(holder_item, item): for holder_value, value in zip(holder_item.value, item): handle_intrinsic_function_namespace(holder_value, value) if isinstance(element, list): traverse_list(holder_element, element) return elif not isinstance(element, dict): # There is no need to search for intrinsic functions, if # there is no namespace or if the element can not contain # them. return for k, v in element.items(): holder_key, holder_value = holder_element.get_item(k) if hasattr(holder_value, SKIP_NAMESPACE_FLAG): return if k == 'get_input' and not isinstance(v, list): namespaced_value =\ utils.generate_namespaced_value(namespace, v) element[k] = namespaced_value holder_element.value[holder_key].value = namespaced_value holder_value.skip_namespace = True if k == 'get_input' and isinstance(v, list): if isinstance(v[0], text_type): element[k][0] =\ utils.generate_namespaced_value(namespace, v[0]) elif k == 'get_property' or k == 'get_attribute': set_namespace_node_intrinsic_functions( namespace, v, holder_element.value[holder_key].value) holder_value.skip_namespace = True if isinstance(v, dict) or k == 'concat': handle_intrinsic_function_namespace( holder_element.value[holder_key], v) elif isinstance(v, list): traverse_list(holder_element.value[holder_key], v)
def parse(self, **kwargs): """ This is a patch due to a problem in the infrastructure, the internal targets values do not get a namespace while they should. So in order to allow namespacing, this patch enforces namespace assignment. """ if self.namespace: for i in xrange(len(self._initial_value)): self._initial_value[i] = utils.generate_namespaced_value( self.namespace, self.initial_value[i]) return self.initial_value
def _prepare_namespaced_elements(key_holder, namespace, value_holder): if isinstance(value_holder.value, dict): _mark_key_value_holder_items(value_holder, 'namespace', namespace) elif isinstance(value_holder.value, text_type): # In case of primitive type we a need a different way to mark # the sub elements with the namespace, but leaving the option # for the DSL element to not receive the namespace. value_holder.only_children_namespace = True value_holder.namespace = namespace if not utils.check_if_overridable_cloudify_type(key_holder.value): key_holder.value = utils.generate_namespaced_value( namespace, key_holder.value)
def set_namespace_node_intrinsic_functions(namespace_value, func_parameters, holder_func_parameters): """ This will add namespace to get_property and get_attribute functions. """ value = func_parameters[0] if value not in functions.AVAILABLE_NODE_TARGETS: namespaced_value = utils.generate_namespaced_value( namespace_value, value) func_parameters[0] = namespaced_value holder_func_parameters[0].value = namespaced_value
def set_leaf_namespace(element): """ Will update, if necessary, leaf element namespace. Also will update it's holder, for also resolving the namespace in the holder object. """ if should_add_namespace_to_string_leaf(element): namespaced_value = utils.generate_namespaced_value( namespace, element._initial_value) element._initial_value = namespaced_value element.initial_value_holder.value = namespaced_value elif isinstance(element._initial_value, dict): handle_intrinsic_function_namespace( element.initial_value_holder, element._initial_value) # We need to use this flag, only for yaml level linking. element.initial_value_holder.skip_namespace = True
def build_ordered_imports_recursive(_current_parsed_dsl_holder, _current_import, context_namespace=None, dsl_version=None): imports_key_holder, imports_value_holder = _current_parsed_dsl_holder.\ get_item(constants.IMPORTS) if not imports_value_holder: return for another_import in imports_value_holder.restore(): namespace, import_url = _extract_import_parts( another_import, resources_base_path, _current_import, dsl_version) validate_namespace(namespace) if context_namespace: if namespace: namespace = utils.generate_namespaced_value( context_namespace, namespace) else: # In case a namespace was added earlier in the import # chain. namespace = context_namespace if import_url is None: ex = exceptions.DSLParsingLogicException( 13, "Import failed: no suitable location found for " "import '{0}'".format(another_import)) ex.failed_import = another_import raise ex if utils.is_blueprint_import(import_url): validate_blueprint_import_namespace(namespace, import_url) blueprint_id = utils.remove_blueprint_import_prefix(import_url) blueprint_imports.add(blueprint_id) add_namespace_to_mapping(blueprint_id, namespace) import_key = resolve_import_graph_key(import_url, namespace) import_context = (location(_current_import), context_namespace) if import_key in imports_graph: is_cloudify_types = imports_graph[import_key]['cloudify_types'] validate_import_namespace(namespace, is_cloudify_types, context_namespace) imports_graph.add_graph_dependency(import_url, import_context, namespace) else: imported_dsl = resolver.fetch_import(import_url, dsl_version=dsl_version) if not is_parsed_resource(imported_dsl): imported_dsl = utils.load_yaml( raw_yaml=imported_dsl, error_message="Failed to parse import '{0}'" "(via '{1}')".format(another_import, import_url), filename=import_url) try: plugin = resolver.retrieve_plugin(import_url) except InvalidBlueprintImport: plugin = None if plugin: # If it is a plugin, then use labels and tags from the DB utils.remove_dsl_keys( imported_dsl, constants.PLUGIN_DSL_KEYS_NOT_FROM_YAML) for key in constants.PLUGIN_DSL_KEYS_READ_FROM_DB: if not plugin.get(key): continue value = plugin[key] if key in constants.PLUGIN_DSL_KEYS_ADD_VALUES_NODE: value = utils.add_values_node_description(value) _merge_into_dict_or_throw_on_duplicate( Holder.of({key: value}), imported_dsl, key, namespace) cloudify_basic_types = is_cloudify_basic_types(imported_dsl) validate_import_namespace(namespace, cloudify_basic_types, context_namespace) if cloudify_basic_types: # Remove namespace data from import namespace = None imports_graph.add(import_url, imported_dsl, cloudify_basic_types, import_context, namespace) build_ordered_imports_recursive(imported_dsl, import_url, namespace, dsl_version)
def set_element_namespace(element_namespace, element_holder): if (not element_namespace or not should_add_element_namespace(element_holder)): return element_holder.value = utils.generate_namespaced_value( element_namespace, element_holder.value)