예제 #1
0
    def verify_template(self):
        if ExceptionCollector.exceptionsCaught():
            if self.input_path:

                msg = (_('\nThe input "%(path)s" failed validation with '
                         'the following error(s): \n\n\t') % {
                             'path': self.input_path
                         }) + '\n\t'.join(
                             ExceptionCollector.getExceptionsReport())
            else:

                msg = _('\nThe pre-parsed input failed validation with '
                        'the following error(s): \n\n\t') + '\n\t'.join(
                            ExceptionCollector.getExceptionsReport())
        else:
            if self.input_path:
                msg = (_('The input "%(path)s" successfully passed '
                         'validation.') % {
                             'path': self.input_path
                         })
            else:
                msg = _('The pre-parsed input successfully passed validation.')

            log.info(msg)
        return msg
예제 #2
0
    def __init__(
        self,
        toscaDef,
        spec=None,
        path=None,
        resolver=None,
    ):
        self.discovered = None
        if spec:
            inputs = spec.get("inputs")
        else:
            inputs = None

        if isinstance(toscaDef, ToscaTemplate):
            self.template = toscaDef
        else:
            topology_tpl = toscaDef.get("topology_template")
            if not topology_tpl:
                toscaDef["topology_template"] = dict(node_templates={},
                                                     relationship_templates={})

            if spec:
                self.loadInstances(toscaDef, spec)

            logger.info("Validating TOSCA template at %s", path)
            self._parseTemplate(path, inputs, toscaDef, resolver)
            decorators = self.loadDecorators()
            if decorators:
                # copy errors before we clear them in _overlay
                errorsSoFar = ExceptionCollector.exceptions[:]
                self._overlay(decorators)
                if ExceptionCollector.exceptionsCaught():
                    # abort if overlay caused errors
                    # report previously collected errors too
                    ExceptionCollector.exceptions[:0] = errorsSoFar
                    message = "\n".join(
                        ExceptionCollector.getExceptionsReport(
                            getLogLevel() < logging.INFO))
                    raise UnfurlValidationError(
                        "TOSCA validation failed for %s: \n%s" %
                        (path, message),
                        ExceptionCollector.getExceptions(),
                    )
                # overlay modifies tosaDef in-place, try reparsing it
                self._parseTemplate(path, inputs, toscaDef, resolver)

            if ExceptionCollector.exceptionsCaught():
                message = "\n".join(
                    ExceptionCollector.getExceptionsReport(
                        getLogLevel() < logging.INFO))
                raise UnfurlValidationError(
                    "TOSCA validation failed for %s: \n%s" % (path, message),
                    ExceptionCollector.getExceptions(),
                )
예제 #3
0
    def __init__(self, tosca_parser_template, provider, cluster_name):

        self.provider = provider
        self.provider_config = ProviderConfiguration(self.provider)
        self.cluster_name = cluster_name
        ExceptionCollector.start()
        for sec in self.REQUIRED_CONFIG_PARAMS:
            if not self.provider_config.config[self.provider_config.MAIN_SECTION].get(sec):
                ExceptionCollector.appendException(ProviderConfigurationParameterError(
                    what=sec
                ))
        ExceptionCollector.stop()
        if ExceptionCollector.exceptionsCaught():
            raise ValidationError(
                message='\nTranslating to provider failed: '
                    .join(ExceptionCollector.getExceptionsReport())
            )

        # toscaparser.tosca_template:ToscaTemplate
        self.tosca_parser_template = tosca_parser_template
        # toscaparser.topology_template:TopologyTemplate
        self.tosca_topology_template = self.full_type_definitions(self.tosca_parser_template.topology_template)

        import_definition_file = ImportsLoader([self.definition_file()], None, list(SERVICE_TEMPLATE_KEYS),
                                               self.tosca_topology_template.tpl)
        self.full_provider_defs = copy.copy(self.tosca_topology_template.custom_defs)
        self.provider_defs = import_definition_file.get_custom_defs()
        self.full_provider_defs.update(self.provider_defs)

        self.artifacts = []
        self.used_conditions_set = set()
        self.extra_configuration_tool_params = dict()
        self.inputs = self.tosca_topology_template.inputs
        self.outputs = self.tosca_topology_template.outputs
        node_templates = self.resolve_get_property_functions(self.tosca_topology_template.nodetemplates)

        self.topology_template = self.translate_to_provider()

        self.node_templates = self.topology_template.nodetemplates
        self.relationship_templates = self.topology_template.relationship_templates

        self.template_dependencies = dict()  # list of lists
        # After this step self.node_templates has requirements with node_filter parameter
        self.resolve_in_template_dependencies()
        self.resolve_in_template_get_functions()

        self.configuration_content = None
        self.configuration_ready = None

        # Create the list of ProviderResource instances
        self.software_component_names = []
        for node in self.node_templates:
            if self._is_software_component(node):
                self.software_component_names.append(node.name)
        self.provider_nodes = self._provider_nodes()
        self.provider_nodes_by_name = self._provider_nodes_by_name()
        self.relationship_templates_by_name = self._relationship_templates_by_name()

        self.provider_node_names_by_priority = self._sort_nodes_by_priority()
        self.provider_nodes_queue = self.sort_nodes_by_dependency()
예제 #4
0
    def __init__(self,
                 toscaDef,
                 inputs=None,
                 instances=None,
                 path=None,
                 resolver=None):
        self.discovered = None
        if isinstance(toscaDef, ToscaTemplate):
            self.template = toscaDef
        else:
            topology_tpl = toscaDef.get("topology_template")
            if not topology_tpl:
                toscaDef["topology_template"] = dict(node_templates={},
                                                     relationship_templates={})

            if instances:
                self.loadInstances(toscaDef, instances)

            logger.info("Validating TOSCA template at %s", path)
            try:
                # need to set a path for the import loader
                self.template = ToscaTemplate(
                    path=path,
                    parsed_params=inputs,
                    yaml_dict_tpl=toscaDef,
                    import_resolver=resolver,
                )
            except ValidationError:
                message = "\n".join(
                    ExceptionCollector.getExceptionsReport(False))
                raise UnfurlValidationError(
                    "TOSCA validation failed for %s: \n%s" % (path, message),
                    ExceptionCollector.getExceptions(),
                )

        self.nodeTemplates = {}
        self.installers = {}
        self.relationshipTemplates = {}
        for template in self.template.nodetemplates:
            nodeTemplate = NodeSpec(template, self)
            if template.is_derived_from(self.InstallerType):
                self.installers[template.name] = nodeTemplate
            self.nodeTemplates[template.name] = nodeTemplate

        if hasattr(self.template, "relationship_templates"):
            # user-declared RelationshipTemplates, source and target will be None
            for template in self.template.relationship_templates:
                relTemplate = RelationshipSpec(template, self)
                self.relationshipTemplates[template.name] = relTemplate

        self.topology = TopologySpec(self, inputs)
        self.load_workflows()
        self.groups = {
            g.name: GroupSpec(g, self)
            for g in self.template.topology_template.groups
        }
        self.policies = {
            p.name: PolicySpec(p, self)
            for p in self.template.topology_template.policies
        }
예제 #5
0
    def verify_template(self):
        if ExceptionCollector.exceptionsCaught():
            if self.input_path:

                msg=(_('\nThe input "%(path)s" failed validation with '
                           'the following error(s): \n\n\t')
                         % {'path': self.input_path}) + '\n\t'.join(ExceptionCollector.getExceptionsReport())
            else:

                msg=_('\nThe pre-parsed input failed validation with '
                          'the following error(s): \n\n\t') + '\n\t'.join(ExceptionCollector.getExceptionsReport())
        else:
            if self.input_path:
                msg = (_('The input "%(path)s" successfully passed '
                         'validation.') % {'path': self.input_path})
            else:
                msg = _('The pre-parsed input successfully passed validation.')

            log.info(msg)
        return msg
예제 #6
0
파일: tosca.py 프로젝트: onecommons/unfurl
    def __init__(self,
                 toscaDef,
                 spec=None,
                 path=None,
                 resolver=None,
                 skip_validation=False):
        self.discovered = None
        if spec:
            inputs = spec.get("inputs")
        else:
            inputs = None

        if isinstance(toscaDef, ToscaTemplate):
            self.template = toscaDef
        else:
            self.template = None
            topology_tpl = toscaDef.get("topology_template")
            if not topology_tpl:
                toscaDef["topology_template"] = dict(node_templates={},
                                                     relationship_templates={})

            if spec:
                self.load_instances(toscaDef, spec)

            logger.info("Validating TOSCA template at %s", path)
            try:
                self._parse_template(path, inputs, toscaDef, resolver)
            except:
                if not ExceptionCollector.exceptionsCaught(
                ) or not self.template or not self.topology:
                    raise  # unexpected error

            # copy errors because self._patch() might clear them
            errorsSoFar = ExceptionCollector.exceptions[:]
            patched = self._patch(toscaDef, path, errorsSoFar)
            if patched:
                # overlay and evaluate_imports modifies tosaDef in-place, try reparsing it
                self._parse_template(path, inputs, toscaDef, resolver)
            else:  # restore previously errors
                ExceptionCollector.exceptions[:0] = errorsSoFar

            if ExceptionCollector.exceptionsCaught():
                message = "\n".join(
                    ExceptionCollector.getExceptionsReport(
                        full=(get_console_log_level() < logging.INFO)))
                if skip_validation:
                    logger.warning("Found TOSCA validation failures: %s",
                                   message)
                else:
                    raise UnfurlValidationError(
                        f"TOSCA validation failed for {path}: \n{message}",
                        ExceptionCollector.getExceptions(),
                    )
예제 #7
0
 def verify_template(self):
     if ExceptionCollector.exceptionsCaught():
         raise ValidationError(
             message=(_('\nThe input "%(path)s" failed validation with the '
                        'following error(s): \n\n\t')
                      % {'path': self.input_path}) +
             '\n\t'.join(ExceptionCollector.getExceptionsReport()))
     else:
         msg = (_('The input "%(path)s" successfully passed validation.') %
                {'path': self.input_path})
         log.info(msg)
         print(msg)
    def verify_template(self):
        if self.no_required_paras_check:
            ExceptionCollector.removeException(MissingRequiredParameterError)
            ExceptionCollector.removeException(MissingRequiredInputError)
            ExceptionCollector.removeException(MissingRequiredOutputError)
        if ExceptionCollector.exceptionsCaught():
            if self.input_path:
                exceptions = ValidationError(
                    message=(_('\nThe input "%(path)s" failed validation with '
                               'the following error(s): \n\n\t') % {
                                   'path': self.input_path
                               }) +
                    '\n\t'.join(ExceptionCollector.getExceptionsReport()))
            else:
                exceptions = ValidationError(
                    message=_('\nThe pre-parsed input failed validation with '
                              'the following error(s): \n\n\t') +
                    '\n\t'.join(ExceptionCollector.getExceptionsReport()))
            if not self.debug_mode:
                raise exceptions
            else:
                if self.sub_mapped_node_template:
                    msg = _('======== nested service template ======== ')

                else:
                    msg = _('======== main service template ======== ')
                print(msg)
                print(exceptions.message)
                log.error(msg)
                log.error(exceptions.message)
        else:
            if self.input_path:
                msg = (_('The input "%(path)s" successfully passed '
                         'validation.') % {
                             'path': self.input_path
                         })
            else:
                msg = _('The pre-parsed input successfully passed validation.')

            log.info(msg)
예제 #9
0
 def verify_template(self):
     if ExceptionCollector.exceptionsCaught():
         raise ValidationError(
             message=(_('\nThe input "%(path)s" failed validation with the '
                        'following error(s): \n\n\t') % {
                            'path': self.input_path
                        }) +
             '\n\t'.join(ExceptionCollector.getExceptionsReport()))
     else:
         msg = (_('The input "%(path)s" successfully passed validation.') %
                {
                    'path': self.input_path
                })
         log.info(msg)
         print(msg)
예제 #10
0
def translate_node_from_tosca(restructured_mapping, tpl_name, self):
    """
    Translator from TOSCA definitions in provider definitions using rules from element_map_to_provider
    :param restructured_mapping: list of dicts(parameter, map, value)
    :param tpl_name: str
    :return: entity_tpl as dict
    """
    resulted_structure = {}

    for item in restructured_mapping:
        ExceptionCollector.start()
        self[PARAMETER] = item[PARAMETER]
        self[VALUE] = item[VALUE]
        mapped_param = restructure_value(mapping_value=item[MAP_KEY],
                                         self=self)
        ExceptionCollector.stop()
        if ExceptionCollector.exceptionsCaught():
            raise ValidationError(
                message='\nTranslating to provider failed: '.join(
                    ExceptionCollector.getExceptionsReport()))
        structures, keyname = get_structure_of_mapped_param(
            mapped_param, item[VALUE])

        for structure in structures:
            r = retrieve_node_templates(structure)
            for node_type, tpl in r.items():
                if not keyname:
                    (_, _, type_name) = tosca_type.parse(node_type)
                    if not type_name:
                        ExceptionCollector.appendException()
                    keyname = self[KEYNAME] + "_" + snake_case.convert(
                        type_name)
                node_tpl_with_name = {keyname: {node_type: tpl}}
                resulted_structure = deep_update_dict(resulted_structure,
                                                      node_tpl_with_name)

    for keyname, node in resulted_structure.items():
        for node_type, tpl in node.items():
            if tpl.get(REQUIREMENTS):
                reqs = []
                for req_name, req in tpl[REQUIREMENTS].items():
                    reqs.append({req_name: req})
                resulted_structure[keyname][node_type][REQUIREMENTS] = reqs
    return resulted_structure
예제 #11
0
파일: tosca.py 프로젝트: onecommons/unfurl
 def _patch(self, toscaDef, path, errorsSoFar):
     matches = None
     decorators = self.load_decorators()
     if decorators:
         logger.debug("applying decorators %s", decorators)
         matches = self._overlay(decorators)
         # overlay uses ExceptionCollector
         if ExceptionCollector.exceptionsCaught():
             # abort if overlay caused errors
             # report previously collected errors too
             ExceptionCollector.exceptions[:0] = errorsSoFar
             message = "\n".join(
                 ExceptionCollector.getExceptionsReport(
                     full=(get_console_log_level() < logging.INFO)))
             raise UnfurlValidationError(
                 f"TOSCA validation failed for {path}: \n{message}",
                 ExceptionCollector.getExceptions(),
             )
     modified_imports = self.evaluate_imports(toscaDef)
     annotated = self.enforce_filters()
     return matches or modified_imports or annotated