diff --git a/java/org/slub/rosetta/dps/repository/plugin/SLUBXmlErrorHandler.java b/java/org/slub/rosetta/dps/repository/plugin/SLUBXmlErrorHandler.java index 03886e03d2a04e36d0ecb2efb5adb6e96ce1ca92..a6d4b0fb5dba16357c3841d2d99c49598b4cfe3f 100644 --- a/java/org/slub/rosetta/dps/repository/plugin/SLUBXmlErrorHandler.java +++ b/java/org/slub/rosetta/dps/repository/plugin/SLUBXmlErrorHandler.java @@ -3,33 +3,27 @@ package org.slub.rosetta.dps.repository.plugin; import org.xml.sax.ErrorHandler; import org.xml.sax.SAXParseException; -import java.util.ArrayList; -import java.util.List; - public class SLUBXmlErrorHandler implements ErrorHandler { - private boolean validationResult = true; - private final List<String> errors = new ArrayList<>(); + + + private final SLUBXmlValidationLogger logger; + public SLUBXmlErrorHandler( SLUBXmlValidationLogger logger) { + this.logger = logger; + } + @Override public void warning(SAXParseException e) { - errors.add("[WW] " + e.getMessage()); + logger.warning( e.getMessage()); } @Override public void error(SAXParseException e) { - validationResult = false; - errors.add("[EE] " + e.getMessage() + " line=" + e.getLineNumber() + " col=" + e.getColumnNumber()); + logger.error(e.getMessage() + " line=" + e.getLineNumber() + " col=" + e.getColumnNumber()); } @Override public void fatalError(SAXParseException e) { - validationResult = false; - errors.add("[EE] Fatal, " + e.getMessage() + " line=" + e.getLineNumber() + " col=" + e.getColumnNumber()); - } - public String get_log () { - for (int i=1; i<errors.size();i++) { - System.out.println( errors.get(i) ); - } - return errors.toString(); + logger.fatal(e.getMessage() + " line=" + e.getLineNumber() + " col=" + e.getColumnNumber()); } public boolean is_Valid() { - return validationResult; + return logger.getResult(); } } diff --git a/java/org/slub/rosetta/dps/repository/plugin/SLUBXmlFormatValidationPlugin.java b/java/org/slub/rosetta/dps/repository/plugin/SLUBXmlFormatValidationPlugin.java index a53ed065c1bc85f19647e4a25618eff256e2c355..e3728d74529e975f108f949f5f259aa48308e1a2 100644 --- a/java/org/slub/rosetta/dps/repository/plugin/SLUBXmlFormatValidationPlugin.java +++ b/java/org/slub/rosetta/dps/repository/plugin/SLUBXmlFormatValidationPlugin.java @@ -36,9 +36,6 @@ import java.io.File; import java.io.IOException; import java.net.URI; import java.net.URISyntaxException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -54,12 +51,11 @@ import java.util.Set; */ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { private static final ExLogger log = ExLogger.getExLogger(SLUBXmlFormatValidationPlugin.class); + private SLUBXmlValidationLogger validationLogger; private boolean debug; private boolean valid; private boolean wellformed; private final DocumentBuilderFactory dbf = DocumentBuilderFactory.newDefaultInstance(); - private final List<String> errors = new ArrayList<>(); - private final List<String> details = new ArrayList<>(); private static final Set<ValidationSchema> namespaceSchemaMap = new HashSet<>(); private ValidationCatalogResolver validationCatalogResolver; /* for DTDs */ private ValidationResourceResolver validationResourceResolver; /* for schema/relaxNG/... */ @@ -75,9 +71,7 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { Document doc = db.parse(fh); Element de = doc.getDocumentElement(); NodeList nodes = de.getElementsByTagName("entry"); - if (debug) { - System.out.println("CATALOG =" + namespaceSchemaMapFile); - } + validationLogger.debug("CATALOG =" + namespaceSchemaMapFile); List<String> attr_strings = List.of(new String[]{"schematype", "namespace", "schemauri"}); int nodesCount = nodes.getLength(); for (int i = 0; i <nodesCount ; i++) { @@ -90,12 +84,11 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { String sUri = attr_list.get(2); addtoNamespaceSchemaMap(namespaceSchemaMapFile, attr_type, namespace, sUri); } else { - log.error("invalid entry(" + i + ") in namespace schema map file " + namespaceSchemaMapFile); + validationLogger.error("invalid entry(" + i + ") in namespace schema map file " + namespaceSchemaMapFile); } } } catch (ParserConfigurationException | SAXException | IOException | URISyntaxException e) { - System.out.println(" ERROR in loadnamespaceSchemaMap " + Arrays.toString(e.getStackTrace())); - log.error("parsing expection parsing namespace schema map file " + namespaceSchemaMapFile + " ," + e.getMessage()); + validationLogger.error("parsing expection parsing namespace schema map file " + namespaceSchemaMapFile + " ," + e.getMessage()); } } @@ -105,7 +98,7 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { case "schema" -> schematype = ValidationSchemaType.schema; case "schematron" -> schematype = ValidationSchemaType.schematron; case "relaxng" -> schematype = ValidationSchemaType.relaxng; - default -> log.error("attribute schematype needs to be type of schema, schematron or relaxng, but is " + attr_type); + default -> validationLogger.error("attribute schematype needs to be type of schema, schematron or relaxng, but is " + attr_type); } URI uri; if ( @@ -117,7 +110,7 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { uri = new URI(sUri); } else { uri = remapUri(namespaceSchemaMapFile, sUri); - if (debug) System.out.println( "SCHEMACATALOG, remap to URI: " + uri); + validationLogger.debug( "SCHEMACATALOG, remap to URI: " + uri); } ValidationSchema v = new ValidationSchema(namespace, schematype, uri); namespaceSchemaMap.add(v); @@ -148,7 +141,8 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { dbf.setNamespaceAware(true); dbf.setValidating(false); dbf.setExpandEntityReferences(false); - validationErrorHandler = new SLUBXmlErrorHandler(); + validationLogger = new SLUBXmlValidationLogger(); + validationErrorHandler = new SLUBXmlErrorHandler( validationLogger); } /** init params to configure the plugin via xml forms @@ -157,13 +151,11 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { public void initParams(Map<String, String> initp) { var debugstr = initp.get("debug"); debug= (null != debugstr && debugstr.equals("true")); - if (debug) { - System.out.println(initp); - } + String[] catalogs = new String[] { initp.get("catalog").trim() }; - validationCatalogResolver = new ValidationCatalogResolver(catalogs, errors, debug); + validationCatalogResolver = new ValidationCatalogResolver(catalogs,validationLogger); loadNamespaceSchemaMap( initp.get("schemacatalog").trim() ); validationResourceResolver = new ValidationResourceResolver(namespaceSchemaMap, debug); } @@ -187,9 +179,7 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { } private Optional<ValidationSchema> assignSchema(Document doc) { XmlInfoRecord info = getXMLinfo(doc); - if (debug) { - System.out.println("check info.nameSpaceUri=" + info.nameSpaceUri); - } + validationLogger.debug("check info.nameSpaceUri=" + info.nameSpaceUri); Optional<ValidationSchema> optValidationSchema; /* try if a DTD is assignable */ var type = checkIfDtdIsApplicable(doc); /* returns ValidationSchemaType.dtd or ValidationSchemaType.nothing */ @@ -199,7 +189,6 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { /* try to apply schemas */ optValidationSchema = applyOtherSchemata(info); } - print_optValidationSchema_if_debug(optValidationSchema); return optValidationSchema; } @@ -215,17 +204,12 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { //@NotNull private Optional<ValidationSchema> applyDtd(XmlInfoRecord info, ValidationSchemaType type) { - if (debug) { - System.out.println("found schema " + type); - } + validationLogger.debug("found schema " + type); ValidationSchema validationSchema = null; try { validationSchema = new ValidationSchema(null, type, new URI(info.systemID)); } catch (SAXException | URISyntaxException e) { - if (debug) { - System.out.println(e.getMessage()); - } - log.error(e.getMessage()); + validationLogger.error(e.getMessage()); } if (null != validationSchema) { return Optional.of(validationSchema); @@ -233,33 +217,7 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { return Optional.empty(); } - private void print_optValidationSchema_if_debug(Optional<ValidationSchema> optEle) { - if (debug) { - if (optEle.isPresent()) { - System.out.println("found namespace " + optEle.get().nameSpace); - System.out.println("found schematype " + optEle.get().schemaType); - System.out.println("found schemaURI " + optEle.get().schemaURI); - } else { - System.out.println("no element found"); - } - } - } - - private void print_namespaceSchemaMap_if_debug() { - if (debug) { - var it = namespaceSchemaMap.iterator(); - System.out.println("map size=" + namespaceSchemaMap.size()); - while (it.hasNext()) { - ValidationSchema v = it.next(); - System.out.println(v.schemaURI); - System.out.println(v.nameSpace); - System.out.println(v.schemaType); - } - } - } - - - @Override + @Override public boolean validateFormat(String filePath) { try { //System.out.println("##########" + filePath.toString()); @@ -268,13 +226,13 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { if (checkIfWellformed(doc)) { //System.out.println("## is wellformed"); wellformed = true; - errors.clear(); - validationErrorHandler = new SLUBXmlErrorHandler(); // reset errorhandler + validationLogger.clear(); + validationLogger.info("File " + filePath + " is well formed."); Optional<ValidationSchema> optSchema = assignSchema(doc); //System.out.println("## schema assigned..."); if (optSchema.isEmpty()) { //System.out.println("-- empty"); - reportError("there is no related schema found in *our* catalog of allowed XML types.", filePath); + validationLogger.error("there is no related schema found in *our* catalog of allowed XML types for file " + filePath); valid = false; } else { ValidationSchema validationSchema = optSchema.get(); @@ -282,90 +240,44 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { } } } catch (ParserConfigurationException e) { - reportError("ParserconfExc file=" + filePath + " Exc:" + e.getMessage()); + validationLogger.error("ParserconfExc file=" + filePath + " Exc:" + e.getMessage()); } catch (IOException e) { - reportError("IOExc file=" + filePath + " Exc:"+ e.getMessage()); + validationLogger.error("IOExc file=" + filePath + " Exc:" + e.getMessage()); } catch (SAXException e) { - reportError("SaxExc not a XML file, " + e.getMessage(), filePath); + validationLogger.error("SaxExc file=" + filePath + " Exc:" + e.getMessage()); e.printStackTrace(); } catch (IllegalArgumentException e ) { - reportError( e.getMessage()); - } - if (debug) { - // debug - System.out.println("errors:"); - System.out.println("----"); - for (var line : errors) { - System.out.println("\t" + line); - } - System.out.println("----"); + validationLogger.fatal( e.getMessage()); } return valid; } - private void check_ns_of_childs(Node root) throws IOException, SAXException { - String root_ns = root.getNamespaceURI(); - NodeList childNodes = root.getChildNodes(); - for (int i=0; i<childNodes.getLength(); i++) { - var child = childNodes.item(i); - var child_ns = child.getNamespaceURI(); - if (child_ns != null && !child_ns.equals(root_ns)) { - if (debug) { - System.out.println("RECURSIVE SCHEMA VALIDATOR: root ns = " + root_ns + " child ns = " + child_ns); - } - var res = validationResourceResolver.find_by_ns( child_ns); - if (res.isEmpty()) { - this.valid=false; - throw new SAXException("RECURSIVE SCHEMA VALIDATOR: No entry for child namespace found: " + child_ns); - } else { - assert(res.get().schemaType == ValidationSchemaType.schema); - var schema = res.get(); - validateFormatAgainstSchemaRecursively(childNodes.item(i), schema); - } - } - } - for (int i=0; i<childNodes.getLength(); i++) { - check_ns_of_childs( childNodes.item(i) ); - } - } - - private void validateFormatAgainstSchemaRecursively(Node root, ValidationSchema validationSchema) throws IOException, SAXException { - var schemaType = validationSchema.schemaType; - if (schemaType == ValidationSchemaType.schema) { - SLUBValidateSchema validator = new SLUBValidateSchema( validationResourceResolver ); - // Select validation roots from DOM - check_ns_of_childs(root); - valid = validator.validateAgainst(root, validationSchema.schemaURI); - } - else { - reportError("RECURSIVE SCHEMA VALIDATOR: unsupported schema uri="+ validationSchema.schemaURI + " of type: " + validationSchema.schemaType); - valid = false; - } - } - private void validateFormatAgainstAnySchema(String filePath, ValidationSchema validationSchema) throws IOException, ParserConfigurationException, SAXException { - reportDetail("assigned schema of type: " + validationSchema.schemaType); - reportDetail("assigned schema uri: " + validationSchema.schemaURI); + validationLogger.info("assigned schema of type: " + validationSchema.schemaType); + validationLogger.info("assigned schema uri: " + validationSchema.schemaURI); var schemaType = validationSchema.schemaType; Document doc = getDocument(filePath); switch (schemaType) { case dtd -> { - SLUBValidateDTD validator = new SLUBValidateDTD(validationCatalogResolver, validationErrorHandler); + SLUBValidateDTD validator = new SLUBValidateDTD(validationCatalogResolver, validationErrorHandler, validationLogger); valid = validator.validateAgainst(filePath); } - case schema -> validateFormatAgainstSchemaRecursively(doc, validationSchema); + case schema -> { + SLUBValidateSchema validator = new SLUBValidateSchema(validationResourceResolver, validationLogger); + valid = validator.validateFormatAgainstSchemaRecursively(doc, validationSchema); + } case relaxng -> { - SLUBValidateRelaxNG validator = new SLUBValidateRelaxNG(); + SLUBValidateRelaxNG validator = new SLUBValidateRelaxNG(validationErrorHandler, validationLogger); valid = validator.validateAgainst(doc, validationSchema.schemaURI); } case schematron -> { SLUBValidateSchematron validator = new SLUBValidateSchematron(); valid = validator.validateAgainst(doc, validationSchema.schemaURI); - reportError("unsupported schematron schema uri=" + validationSchema.schemaURI + " of type: " + validationSchema.schemaType); + validationLogger.error("unsupported schematron schema uri=" + validationSchema.schemaURI + " of type: " + validationSchema.schemaType); valid = false; } default -> { - reportError("unsupported schema uri=" + validationSchema.schemaURI + " of type: " + validationSchema.schemaType); + validationLogger.error("unsupported schema uri=" + validationSchema.schemaURI + " of type: " + validationSchema.schemaType); valid = false; } } @@ -379,9 +291,7 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { if (info.systemID.endsWith(".dtd")) { result = ValidationSchemaType.dtd; } - if (debug) { - System.out.println("no dtd applicable"); - } + validationLogger.debug("no dtd applicable"); } return result; } @@ -390,14 +300,14 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { /* detect XML type via NS */ boolean isWellformedXml = false; XmlInfoRecord info = getXMLinfo(doc); - reportDetail("detect XML type via NS:" + info.nameSpaceUri); + validationLogger.info("detect XML type via NS:" + info.nameSpaceUri); /* align corresponding Schema based on systemID */ //info.print(); if ("1.0".equals(info.xmlVersion)) { isWellformedXml = true; - reportDetail("checked XML is wellformed"); + validationLogger.info("checked XML is wellformed"); } else { - reportError("not an expected XML 1.0 document, found " + info.xmlVersion); + validationLogger.error("not an expected XML 1.0 document, found " + info.xmlVersion); } return isWellformedXml; } @@ -413,7 +323,7 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { DocumentBuilder db = dbf.newDocumentBuilder(); db.setErrorHandler( validationErrorHandler ); //db.setEntityResolver(validationCatalogResolver); - if (debug) System.out.println( + validationLogger.debug( "DOCUMENT LOADER: ns aware=" + db.isNamespaceAware() + " include aware=" + db.isXIncludeAware() + " is validating=" + db.isValidating() @@ -423,24 +333,6 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { - - - private void reportError(String msg) { - errors.add(msg); - if (debug) { - System.out.println("ERROR: " + msg); - } - // TODO: log.warn(msg); - } - private void reportError(String msg, String filepath) { - reportError(msg + " (file=" + filepath + ")"); - } - - private void reportDetail(String msg) { - details.add(msg); -// System.out.println(msg); - } - @Override public String getAgent() { return "SLUBXmlFormatValidationPlugin"; @@ -458,12 +350,12 @@ public class SLUBXmlFormatValidationPlugin implements FormatValidationPlugin { @Override public List<String> getErrors() { - return Collections.unmodifiableList(errors); + return validationLogger.getErrors(); } @Override public String getValidationDetails() { - return details.stream().reduce("", (all, res) -> all.concat("\n") .concat(res) ); + return validationLogger.getLog(); } /** stand-alone check, main file to call local installed clamd diff --git a/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateDTD.java b/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateDTD.java index 9076f8bd2d88efc184412e3957c62f154d58e2d5..9f97a6d2997b627ba55ca4c03f5dfe9a80d9d227 100644 --- a/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateDTD.java +++ b/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateDTD.java @@ -1,6 +1,7 @@ package org.slub.rosetta.dps.repository.plugin.Validation; import org.slub.rosetta.dps.repository.plugin.SLUBXmlErrorHandler; +import org.slub.rosetta.dps.repository.plugin.SLUBXmlValidationLogger; import org.slub.rosetta.dps.repository.plugin.ValidationCatalogResolver; import javax.xml.XMLConstants; @@ -13,10 +14,12 @@ import java.io.IOException; public class SLUBValidateDTD { private final ValidationCatalogResolver validationCatalogResolver; private final SLUBXmlErrorHandler slubXmlErrorHandler; + private final SLUBXmlValidationLogger logger; - public SLUBValidateDTD(ValidationCatalogResolver catalogResolver, SLUBXmlErrorHandler slubXmlErrorHandler) { + public SLUBValidateDTD(ValidationCatalogResolver catalogResolver, SLUBXmlErrorHandler slubXmlErrorHandler, SLUBXmlValidationLogger logger) { this.validationCatalogResolver = catalogResolver; this.slubXmlErrorHandler = slubXmlErrorHandler; + this.logger = logger; } private final DocumentBuilderFactory dbf = DocumentBuilderFactory.newDefaultNSInstance(); public boolean validateAgainst(String filePath) throws IOException, ParserConfigurationException { @@ -37,8 +40,8 @@ public class SLUBValidateDTD { dbValidate.parse(new File(filePath)); //} catch (SAXException e) { } catch (Exception e) { - System.out.println("ERROR: " + e.getMessage()); + logger.error(e.getMessage() ); } - return slubXmlErrorHandler.is_Valid(); + return logger.getResult(); } } diff --git a/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateRelaxNG.java b/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateRelaxNG.java index 23ee118495741fae5a0968d63d9fb9a360acda09..f997b9ad6f0bf90b5536edf5d5416da12c20ef79 100644 --- a/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateRelaxNG.java +++ b/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateRelaxNG.java @@ -6,44 +6,24 @@ import com.thaiopensource.validate.SchemaReader; import com.thaiopensource.validate.ValidateProperty; import com.thaiopensource.validate.ValidationDriver; import com.thaiopensource.validate.auto.AutoSchemaReader; +import org.slub.rosetta.dps.repository.plugin.SLUBXmlErrorHandler; +import org.slub.rosetta.dps.repository.plugin.SLUBXmlValidationLogger; import org.w3c.dom.Document; -import org.xml.sax.ErrorHandler; import org.xml.sax.InputSource; import org.xml.sax.SAXException; -import org.xml.sax.SAXParseException; import java.io.IOException; import java.net.URI; -import java.util.ArrayList; -import java.util.List; public class SLUBValidateRelaxNG { - private boolean is_valid = true; - private final List<String> errors = new ArrayList<>(); - public SLUBValidateRelaxNG() { - } - public List<String> get_errors() { - return errors; + private final SLUBXmlValidationLogger logger; + private final SLUBXmlErrorHandler errorHandler; + public SLUBValidateRelaxNG(SLUBXmlErrorHandler errorHandler, SLUBXmlValidationLogger logger) { + this.logger = logger; + this.errorHandler = errorHandler; } - protected class RelaxNGErrorhandler implements ErrorHandler { - @Override - public void warning(SAXParseException e) { - errors.add( "[WW] "+ e.getMessage() ); - } - @Override - public void error(SAXParseException e) { - is_valid = false; - errors.add( "[EE] " + e.getMessage() + " line=" + e.getLineNumber() + " col=" + e.getColumnNumber()); - } - @Override - public void fatalError(SAXParseException e) { - is_valid = false; - errors.add( "[EE] Fatal, " + e.getMessage() + " line=" + e.getLineNumber() + " col=" + e.getColumnNumber()); - } - - } public boolean validateAgainst(Document doc, URI relaxNgUri) throws IOException, SAXException { try { /* @@ -58,47 +38,23 @@ public class SLUBValidateRelaxNG { DOMSource src = new DOMSource(docvalidate); v.validate(src); */ - - SchemaReader sr = new AutoSchemaReader(); - // create a new ValidationDriver and override default PropertyMap controlling validation to add our custom ErrorHandler // for more details, see: https://github.com/relaxng/jing-trang/blob/master/mod/validate/src/main/com/thaiopensource/validate/ValidationDriver.java#L36-L113 PropertyMapBuilder builder = new PropertyMapBuilder(); - RelaxNGErrorhandler eh = new RelaxNGErrorhandler(); - builder.put(ValidateProperty.ERROR_HANDLER, eh); + builder.put(ValidateProperty.ERROR_HANDLER, errorHandler); PropertyMap schemaProperties = PropertyMap.EMPTY; PropertyMap instanceProperties = builder.toPropertyMap(); ValidationDriver driver = new ValidationDriver(schemaProperties, instanceProperties, sr); - InputSource inRng = ValidationDriver.uriOrFileInputSource(relaxNgUri.toString()); inRng.setEncoding("UTF-8"); - // System.out.println("XXX A"); driver.loadSchema(inRng); - // System.out.println("XXX B"); InputSource inXml = ValidationDriver.uriOrFileInputSource(doc.getDocumentURI()); - // System.out.println("XXX C"); inXml.setEncoding("UTF-8"); - // System.out.println("XXX D"); - is_valid = driver.validate(inXml); - // System.out.println("XXX E"); - + driver.validate(inXml); } catch (Exception e ) { - errors.add( "res5 = " + e.getMessage()); - System.out.println("ERROR5: " + e.getMessage()); - } /*catch (IllegalArgumentException e) { - errors.add( "res3 = " + e.getMessage()); - System.out.println("ERROR3: " + e.getMessage()); - } catch (SAXException e) { - errors.add( "res = " + e.getMessage()); - System.out.println("ERROR1: " + e.getMessage()); - } catch (IOException e) { - errors.add( "res2 = " + e.getMessage()); - System.out.println("ERROR2: " + e.getMessage()); - } catch (NullPointerException e ) { - errors.add( "res4 = " + e.getMessage()); - System.out.println("ERROR4: " + e.getMessage()); - }*/ - return is_valid; + logger.error( e.getMessage() ); + } + return logger.getResult(); } } diff --git a/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateSchema.java b/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateSchema.java index 1adb7bb2e831f47c31fd4078f22270f53abfbda1..34b972feff3adabd4b00ec6dfa587db1dbe987ca 100644 --- a/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateSchema.java +++ b/java/org/slub/rosetta/dps/repository/plugin/Validation/SLUBValidateSchema.java @@ -1,8 +1,12 @@ package org.slub.rosetta.dps.repository.plugin.Validation; import org.apache.xerces.jaxp.validation.XMLSchemaFactory; +import org.slub.rosetta.dps.repository.plugin.SLUBXmlValidationLogger; import org.slub.rosetta.dps.repository.plugin.ValidationResourceResolver; +import org.slub.rosetta.dps.repository.plugin.ValidationSchema; +import org.slub.rosetta.dps.repository.plugin.ValidationSchemaType; import org.w3c.dom.Node; +import org.w3c.dom.NodeList; import org.xml.sax.SAXException; import javax.xml.XMLConstants; @@ -13,11 +17,71 @@ import javax.xml.validation.Validator; import java.io.IOException; import java.net.URI; + + public class SLUBValidateSchema { private final ValidationResourceResolver validationResourceResolver; - public SLUBValidateSchema(ValidationResourceResolver validationResourceResolver) { + private final SLUBXmlValidationLogger logger; + + private boolean validationResult=true; + public SLUBValidateSchema(ValidationResourceResolver validationResourceResolver, SLUBXmlValidationLogger validationLogger) { this.validationResourceResolver = validationResourceResolver; + this.logger = validationLogger; + } + + private void check_ns_of_childs(Node root) throws IOException, SAXException { + String root_ns = root.getNamespaceURI(); + NodeList childNodes = root.getChildNodes(); + if (root_ns != null) { + for (int i = 0; i < childNodes.getLength(); i++) { + var child = childNodes.item(i); + var child_ns = child.getNamespaceURI(); + if (child_ns != null && !child_ns.equals(root_ns)) { + logger.debug("RECURSIVE SCHEMA VALIDATOR: root ns = " + root_ns + " child ns = " + child_ns); + var res = validationResourceResolver.find_by_ns(child_ns); + if (res.isEmpty()) { + this.validationResult = false; + throw new SAXException("RECURSIVE SCHEMA VALIDATOR: No entry for child namespace found: " + child_ns); + } else { + assert (res.get().schemaType == ValidationSchemaType.schema); + var schema = res.get(); + internValidateFormatAgainstSchemaRecursively(childNodes.item(i), schema); + } + } + } + } + for (int i=0; i<childNodes.getLength(); i++) { + check_ns_of_childs( childNodes.item(i) ); + } + } + + private boolean internValidateFormatAgainstSchemaRecursively(Node root, ValidationSchema validationSchema) throws IOException, SAXException { + var schemaType = validationSchema.schemaType; + if (schemaType == ValidationSchemaType.schema) { + SLUBValidateSchema validator = new SLUBValidateSchema( validationResourceResolver, logger ); + // Select validation roots from DOM + validationResult = validator.validateAgainst(root, validationSchema.schemaURI); + logger.debug("RECURSIVE SCHEMA VALIDATOR: validation against Schema "+ validationSchema.schemaURI.toString() + " results in " + validationResult); + if (validationResult) { + check_ns_of_childs(root); + } + } + else { + throw new SAXException("RECURSIVE SCHEMA VALIDATOR: unsupported schema uri="+ validationSchema.schemaURI + " of type: " + validationSchema.schemaType); + } + return validationResult; + } + + public boolean validateFormatAgainstSchemaRecursively(Node root, ValidationSchema validationSchema) { + try { + validationResult = internValidateFormatAgainstSchemaRecursively(root, validationSchema); + } catch (IOException | SAXException e) { + validationResult = false; + //TODO: add errors + logger.error(e.getMessage()); + } + return validationResult; } public boolean validateAgainst(Node docvalidate, URI xsdUri) throws IOException { @@ -34,7 +98,7 @@ public class SLUBValidateSchema { v.validate(src); isValidXml = true; } catch (SAXException e) { - System.out.println( e.getMessage() ); + logger.error( e.getMessage() ); /* errors.add( e.getMessage() ); if (e.getMessage().contains("Premature end of file")) { @@ -45,7 +109,8 @@ public class SLUBValidateSchema { */ e.printStackTrace(); } - return isValidXml; + return logger.getResult(); } + static boolean debug = true; } diff --git a/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateDTD.java b/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateDTD.java index 5279f0b5b987c9de8781304b1c18c277e0769325..12824bf0439250645b86c4c69465c1ef96b026c9 100644 --- a/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateDTD.java +++ b/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateDTD.java @@ -4,16 +4,14 @@ import org.junit.Before; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import org.slub.rosetta.dps.repository.plugin.SLUBXmlErrorHandler; +import org.slub.rosetta.dps.repository.plugin.SLUBXmlValidationLogger; import org.slub.rosetta.dps.repository.plugin.ValidationCatalogResolver; +import org.slub.rosetta.dps.repository.plugin.ValidationLevel; -import java.util.ArrayList; import java.util.HashMap; -import java.util.List; import java.util.Map; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.*; /** * Tests for {@link SLUBValidateDTD}. @@ -36,10 +34,10 @@ public class TestSLUBValidateDTD { String[] catalogs = new String[] { initp.get("catalog") }; - List<String> errors = new ArrayList<>(); - ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, errors, true); - SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(); - var v = new SLUBValidateDTD( validationCatalogResolver, errorHandler ); + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); + ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, logger); + SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(logger); + var v = new SLUBValidateDTD( validationCatalogResolver, errorHandler, logger ); assertNotNull( "validator DTD sucessfully instantiated", v); var has_exception = false; boolean res = false; @@ -58,10 +56,10 @@ public class TestSLUBValidateDTD { String[] catalogs = new String[] { initp.get("catalog") }; - List<String> errors = new ArrayList<>(); - ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, errors, true); - SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(); - var v = new SLUBValidateDTD( validationCatalogResolver, errorHandler ); + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); + ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, logger); + SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler( logger ); + var v = new SLUBValidateDTD( validationCatalogResolver, errorHandler, logger ); assertNotNull( "validator DTD sucessfully instantiated", v); var has_exception = false; boolean res = false; @@ -84,10 +82,10 @@ public class TestSLUBValidateDTD { initp.get("catalog") }; - List<String> errors = new ArrayList<>(); - ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, errors, true); - SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(); - var v = new SLUBValidateDTD( validationCatalogResolver, errorHandler ); + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); + ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, logger); + SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(logger); + var v = new SLUBValidateDTD( validationCatalogResolver, errorHandler, logger ); assertNotNull( "validator DTD sucessfully instantiated", v); var has_exception = false; boolean res = false; @@ -110,10 +108,10 @@ public class TestSLUBValidateDTD { String[] catalogs = new String[] { initp.get("catalog") }; - List<String> errors = new ArrayList<>(); - ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, errors, true); - SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(); - var v = new SLUBValidateDTD( validationCatalogResolver , errorHandler); + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); + ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, logger); + SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(logger); + var v = new SLUBValidateDTD( validationCatalogResolver , errorHandler, logger); assertNotNull( "validator DTD sucessfully instantiated", v); var has_exception = false; boolean res = false; @@ -121,8 +119,7 @@ public class TestSLUBValidateDTD { var doc = "resources/test/valid/mathml/mathml2.example1.xml"; res = v.validateAgainst(doc); System.out.println("validating " + doc + " resulting in " + res); - System.out.println("RES: " + errorHandler.get_log() ); - + logger.print( ValidationLevel.debug ); } catch ( Exception e) { e.printStackTrace(); has_exception = true; @@ -136,10 +133,10 @@ public class TestSLUBValidateDTD { /** regression: check if no catalog entry the validation fails as expected */ public void check_whitelist_regression() { String[] catalogs = new String[0]; - List<String> errors = new ArrayList<>(); - ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, errors, true); - SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(); - var v = new SLUBValidateDTD( validationCatalogResolver, errorHandler ); + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); + ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, logger); + SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(logger); + var v = new SLUBValidateDTD( validationCatalogResolver, errorHandler, logger ); assertNotNull( "validator DTD sucessfully instantiated", v); var has_exception = false; boolean res = false; @@ -161,10 +158,10 @@ public class TestSLUBValidateDTD { String[] catalogs = new String[] { "resources/test/catalog/import_regression.catalog" }; - List<String> errors = new ArrayList<>(); - ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, errors, true); - SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(); - var v = new SLUBValidateDTD( validationCatalogResolver, errorHandler ); + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); + ValidationCatalogResolver validationCatalogResolver = new ValidationCatalogResolver(catalogs, logger); + SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(logger); + var v = new SLUBValidateDTD( validationCatalogResolver, errorHandler , logger); assertNotNull( "validator DTD sucessfully instantiated", v); var has_exception = false; boolean res = false; diff --git a/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateRelaxNG.java b/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateRelaxNG.java index 85ef1920fe4c30ed5ddaad841f9c6bd07dc931fc..2d95e38be38097e5aecf31f65de7c750d55cd4df 100644 --- a/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateRelaxNG.java +++ b/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateRelaxNG.java @@ -3,7 +3,9 @@ package org.slub.rosetta.dps.repository.plugin.Validation; import org.junit.Before; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; +import org.slub.rosetta.dps.repository.plugin.SLUBXmlErrorHandler; import org.slub.rosetta.dps.repository.plugin.SLUBXmlFormatValidationPlugin; +import org.slub.rosetta.dps.repository.plugin.SLUBXmlValidationLogger; import org.w3c.dom.Document; import java.io.File; @@ -48,7 +50,9 @@ public class TestSLUBValidateRelaxNG { @org.junit.Test public void relaxNG_valid() { - var v = new SLUBValidateRelaxNG(); + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); + SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(logger); + var v = new SLUBValidateRelaxNG(errorHandler, logger); assertNotNull( "validator relaxNG sucessfully instantiated", v); var has_exception = false; var res = false; @@ -64,7 +68,9 @@ public class TestSLUBValidateRelaxNG { } @org.junit.Test public void relaxNG_invalid() { - var v = new SLUBValidateRelaxNG(); + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); + SLUBXmlErrorHandler errorHandler = new SLUBXmlErrorHandler(logger); + var v = new SLUBValidateRelaxNG(errorHandler, logger); assertNotNull( "validator relaxNG sucessfully instantiated", v); var has_exception = false; var res = false; diff --git a/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateSchema.java b/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateSchema.java index 77d0f588b5aabd5f1f55afd9309d0e9c67db21e1..389ef67175e26fcf524d30096ee6327e91f11dbe 100644 --- a/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateSchema.java +++ b/java/org/slub/rosetta/dps/repository/plugin/Validation/TestSLUBValidateSchema.java @@ -4,6 +4,7 @@ import org.junit.Before; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import org.slub.rosetta.dps.repository.plugin.SLUBXmlFormatValidationPlugin; +import org.slub.rosetta.dps.repository.plugin.SLUBXmlValidationLogger; import org.slub.rosetta.dps.repository.plugin.ValidationResourceResolver; import org.slub.rosetta.dps.repository.plugin.ValidationSchema; @@ -53,7 +54,8 @@ public class TestSLUBValidateSchema { public void schema_valid() { ValidationResourceResolver validationResourceResolver = new ValidationResourceResolver(mock.getNamespaceSchemaMap(), true); - var v = new SLUBValidateSchema(validationResourceResolver); + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); + var v = new SLUBValidateSchema(validationResourceResolver, logger); assertNotNull( "validator schema sucessfully instantiated", v); var has_exception = false; var res = false; @@ -71,7 +73,8 @@ public class TestSLUBValidateSchema { @org.junit.Test public void schema_invalid() { ValidationResourceResolver validationResourceResolver = new ValidationResourceResolver(mock.getNamespaceSchemaMap(), true); - var v = new SLUBValidateSchema(validationResourceResolver); + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); + var v = new SLUBValidateSchema(validationResourceResolver, logger); assertNotNull( "validator schema sucessfully instantiated", v); var has_exception = false; var res = false; @@ -97,8 +100,9 @@ public class TestSLUBValidateSchema { nssm.add(val); } } + SLUBXmlValidationLogger logger = new SLUBXmlValidationLogger(); ValidationResourceResolver validationResourceResolver = new ValidationResourceResolver(nssm, true); - var v = new SLUBValidateSchema(validationResourceResolver); + var v = new SLUBValidateSchema(validationResourceResolver, logger); assertNotNull( "validator schema sucessfully instantiated", v); var has_exception = false; var res = false; diff --git a/java/org/slub/rosetta/dps/repository/plugin/ValidationCatalogResolver.java b/java/org/slub/rosetta/dps/repository/plugin/ValidationCatalogResolver.java index 1a3d13298504ab153c7435e55d36137d2e67a6cc..28b4cd4b3cbed33e97ae23ca59d09d4e89b828c6 100644 --- a/java/org/slub/rosetta/dps/repository/plugin/ValidationCatalogResolver.java +++ b/java/org/slub/rosetta/dps/repository/plugin/ValidationCatalogResolver.java @@ -12,27 +12,23 @@ import java.io.IOException; import java.io.InputStream; import java.io.Reader; import java.util.Arrays; -import java.util.List; public class ValidationCatalogResolver implements CatalogResolver { private final String[] catalogs; - private final List<String> errors; - private final boolean debug; - public ValidationCatalogResolver(String[] catalogs, List<String> errors, boolean debug) { + private final SLUBXmlValidationLogger validationLogger; + public ValidationCatalogResolver(String[] catalogs, SLUBXmlValidationLogger validationLogger) { this.catalogs = catalogs; - this.errors = errors; - this.debug = debug; + this.validationLogger = validationLogger; } @Override public InputSource resolveEntity(String publicId, String systemId) { - if (debug) { - System.out.println("CATALOG RESOLVER: ======"); - System.out.println("CATALOG RESOLVER: resolveEntity publicId=" + publicId + " systemId=" + systemId); - System.out.println("CATALOG RESOLVER: catalogs:" + Arrays.stream(catalogs).toList()); - } + + validationLogger.debug("CATALOG RESOLVER: ======"); + validationLogger.debug("CATALOG RESOLVER: resolveEntity publicId=" + publicId + " systemId=" + systemId); + validationLogger.debug("CATALOG RESOLVER: catalogs:" + Arrays.stream(catalogs).toList()); + if (catalogs.length == 0) { - System.out.println("CATALOG RESOLVER: No catalog given!"); - errors.add("No catalog given!"); + validationLogger.error("CATALOG RESOLVER: No catalog given!"); return new InputSource(Reader.nullReader() ); // disabled further catalog checking to enable whitelist behaviour, see https://docs.oracle.com/en/java/javase/17/docs/api/java.xml/javax/xml/catalog/CatalogResolver.html } InputSource result; @@ -41,55 +37,39 @@ public class ValidationCatalogResolver implements CatalogResolver { cr.setPreferPublic(true); cr.setCatalogList(catalogs); cr.setUseLiteralSystemId(true); // TODO: Prüfen, ob wenn auf false, sytemid analog zu dem in Datei aussieht (file:/// statt file:/) - if (debug) { - System.out.println("CATALOG RESOLVER: try to resolve for publicId=" + publicId + ", systemId=" + systemId + ", "); - } + validationLogger.debug("CATALOG RESOLVER: try to resolve for publicId=" + publicId + ", systemId=" + systemId + ", "); result = cr.resolveEntity(publicId, systemId); } catch (IOException | CatalogException | SAXException e) { - if (debug) { - System.out.println("CATALOG RESOLVER: No mapping found for publicId=" + publicId + ", systemId=" + systemId + ", " + e.getMessage()); - } - errors.add("No mapping found for publicId=" + publicId + ", systemId=" + systemId + ", " + e.getMessage()); + validationLogger.error("CATALOG RESOLVER: No mapping found for publicId=" + publicId + ", systemId=" + systemId + ", " + e.getMessage()); return new InputSource(Reader.nullReader() ); // disabled further catalog checking to enable whitelist behaviour, see https://docs.oracle.com/en/java/javase/17/docs/api/java.xml/javax/xml/catalog/CatalogResolver.html } if (result == null) { - if (debug) { - System.out.println("No mapping found for publicId=" + publicId + ", systemId=" + systemId); - } - errors.add("No mapping found for publicId=" + publicId + ", systemId=" + systemId); + validationLogger.error("No mapping found for publicId=" + publicId + ", systemId=" + systemId); return new InputSource(Reader.nullReader() ); // disabled further catalog checking to enable whitelist behaviour, see https://docs.oracle.com/en/java/javase/17/docs/api/java.xml/javax/xml/catalog/CatalogResolver.html } else { - if (debug) { - System.out.println("CATALOG RESOLVER: ---> result: systemid=" + result.getSystemId() + " publicid=" + result.getPublicId() ); - } + validationLogger.info("CATALOG RESOLVER: ---> result: systemid=" + result.getSystemId() + " publicid=" + result.getPublicId() ); } return result; } @Override public Source resolve(String href, String base) { - if (debug) { - System.out.println("CATALOG RESOLVER: ======"); - System.out.println("CATALOG RESOLVER: resolve href=" + href + " base=" + base); - } + validationLogger.debug("CATALOG RESOLVER: ======"); + validationLogger.debug("CATALOG RESOLVER: resolve href=" + href + " base=" + base); return null; } @Override public InputStream resolveEntity(String publicId, String systemId, String baseUri, String nameSpace) { - if (debug) { - System.out.println("CATALOG RESOLVER: ======"); - System.out.println("CATALOG RESOLVER: resolveEntity2 publicId=" + publicId + " systemId=" + systemId); - } + validationLogger.debug("CATALOG RESOLVER: ======"); + validationLogger.debug("CATALOG RESOLVER: resolveEntity2 publicId=" + publicId + " systemId=" + systemId); return null; } @Override public LSInput resolveResource(String type, String namespaceURI, String publicId, String systemId, String baseUri) { - if (debug) { - System.out.println("CATALOG RESOLVER: ======"); - System.out.println("CATALOG RESOLVER: resolveResource publicId=" + publicId + " systemId=" + systemId); - } + validationLogger.debug("CATALOG RESOLVER: ======"); + validationLogger.debug("CATALOG RESOLVER: resolveResource publicId=" + publicId + " systemId=" + systemId); return null; } }