예제 #1
0
    def report_msg(self, msg, docs, diagnostic, error, level):
        """Add a validation message to the result list.

        :param msg: String - msg, will be prepended with validator long name
        :param docs: List - List of document references related to this validation message
        :param diagnostic: String - Diagnostic information for t/s this error
        :param error: Bool - Whether this message indicates an error
        :param level: String - More detailed of the severity level of this message
        """
        fmt_msg = "%s: %s" % (self.long_name, msg)
        msg_obj = objects.ValidationMessage(fmt_msg,
                                            self.name,
                                            error=error,
                                            level=level,
                                            docs=docs,
                                            diagnostic=diagnostic)
        self.messages.append(msg_obj)
예제 #2
0
    def parse_docs(self, doc_blob):
        """Translate a YAML string into the internal Drydock model.

        Returns a tuple of a objects.TaskStatus instance to summarize all
        document processing and a list of models yielded by successful processing

        :param doc_blob: bytes representing a utf-8 encoded YAML string
        """
        models = []
        yaml_string = doc_blob.decode()
        self.logger.debug("yamlingester:parse_docs - Parsing YAML string.")
        try:
            parsed_data = yaml.safe_load_all(yaml_string)
        except yaml.YAMLError as err:
            if hasattr(err, 'problem_mark'):
                mark = err.problem_mark
                raise errors.IngesterError(
                    "Error parsing YAML at (l:%s, c:%s): %s" %
                    (mark.line + 1, mark.column + 1, err))
            else:
                raise errors.IngesterError("Error parsing YAML: %s" % (err))

        # tracking processing status to provide a complete summary of issues
        ps = objects.Validation()
        ps.set_status(hd_fields.ValidationResult.Success)
        for d in parsed_data:
            try:
                (schema_ns, doc_kind, doc_version) = d.get('schema',
                                                           '').split('/')
            except ValueError as ex:
                self.logger.error("Error with document structure.",
                                  exc_info=ex)
                self.logger.debug("Error document\n%s" % yaml.dump(d))
                continue
            if schema_ns == 'drydock':
                try:
                    doc_ref = objects.DocumentReference(
                        doc_type=hd_fields.DocumentType.Deckhand,
                        doc_schema=d.get('schema'),
                        doc_name=d.get('metadata', {}).get('name', 'Unknown'))
                    doc_errors = self.validate_drydock_document(d)
                    if len(doc_errors) > 0:
                        for e in doc_errors:
                            ps.add_detail_msg(
                                objects.ValidationMessage(
                                    msg="%s:%s schema validation error: %s" %
                                    (doc_kind, doc_version, e),
                                    name="DD001",
                                    docs=[doc_ref],
                                    error=True,
                                    level=hd_fields.MessageLevels.ERROR,
                                    diagnostic=
                                    "Invalid input file - see Drydock Troubleshooting Guide for DD001"
                                ))
                        ps.set_status(hd_fields.ActionResult.Failure)
                        continue
                    model = self.process_drydock_document(d)
                    model.doc_ref = doc_ref
                    models.append(model)
                except errors.IngesterError as ie:
                    msg = "Error processing document: %s" % str(ie)
                    self.logger.warning(msg)
                    ps.add_detail_msg(
                        objects.ValidationMessage(
                            msg=msg,
                            name="DD000",
                            error=True,
                            level=hd_fields.MessageLevels.ERROR,
                            docs=[doc_ref],
                            diagnostic="Exception during document processing "
                            "- see Drydock Troubleshooting Guide "
                            "for DD000"))
                    ps.set_status(hd_fields.ActionResult.Failure)
                except Exception as ex:
                    msg = "Unexpected error processing document: %s" % str(ex)
                    self.logger.error(msg, exc_info=True)
                    ps.add_detail_msg(
                        objects.ValidationMessage(
                            msg=msg,
                            name="DD000",
                            error=True,
                            level=hd_fields.MessageLevels.ERROR,
                            docs=[doc_ref],
                            diagnostic="Unexpected exception during document "
                            "processing - see Drydock Troubleshooting "
                            "Guide for DD000"))
                    ps.set_status(hd_fields.ActionResult.Failure)
        return (ps, models)