Пример #1
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(),
                )
Пример #2
0
    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(),
                    )
Пример #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 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
Пример #5
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)
Пример #6
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)
Пример #7
0
    def validate(self):
        """Validate the provided CSAR file."""

        self.is_validated = True

        # validate that the file or URL exists
        missing_err_msg = (_('"%s" does not exist.') % self.path)
        if self.a_file:
            if not os.path.isfile(self.path):
                ExceptionCollector.appendException(
                    ValidationError(message=missing_err_msg))
                return False
            else:
                self.csar = self.path
        else:  # a URL
            if not UrlUtils.validate_url(self.path):
                ExceptionCollector.appendException(
                    ValidationError(message=missing_err_msg))
                return False
            else:
                response = requests.get(self.path)
                self.csar = BytesIO(response.content)

        # validate that it is a valid zip file
        if not zipfile.is_zipfile(self.csar):
            err_msg = (_('"%s" is not a valid zip file.') % self.path)
            ExceptionCollector.appendException(
                ValidationError(message=err_msg))
            return False

        # validate that it contains the metadata file in the correct location
        self.zfile = zipfile.ZipFile(self.csar, 'r')
        filelist = self.zfile.namelist()
        if TOSCA_META in filelist:
            self.is_tosca_metadata = True
            # validate that 'Entry-Definitions' property exists in TOSCA.meta
            is_validated = self._validate_tosca_meta(filelist)
        else:
            self.is_tosca_metadata = False
            is_validated = self._validate_root_level_yaml(filelist)

        if is_validated:
            # validate that external references and imports in the main
            # template actually exist and are accessible
            main_tpl = self._read_template_yaml(self.main_template_file_name)
            self._validate_external_references(main_tpl)
        return not ExceptionCollector.exceptionsCaught()
Пример #8
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
Пример #9
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
Пример #10
0
 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
    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)