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)
