XSDSchemaCollection.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.utils.xml;

  23. import java.io.ByteArrayInputStream;
  24. import java.io.ByteArrayOutputStream;
  25. import java.io.File;
  26. import java.io.FileOutputStream;
  27. import java.io.OutputStream;
  28. import java.nio.file.Files;
  29. import java.nio.file.attribute.FileAttribute;
  30. import java.nio.file.attribute.PosixFilePermission;
  31. import java.nio.file.attribute.PosixFilePermissions;
  32. import java.text.SimpleDateFormat;
  33. import java.util.List;
  34. import java.util.Map;
  35. import java.util.Set;
  36. import java.util.zip.ZipEntry;
  37. import java.util.zip.ZipOutputStream;

  39. import javax.xml.validation.Schema;

  41. import org.openspcoop2.utils.date.DateManager;
  42. import org.openspcoop2.utils.date.DateUtils;
  43. import org.openspcoop2.utils.resources.FileSystemUtilities;
  44. import org.slf4j.Logger;

  46. /**
  47. * XSDSchemaCollection
  48. *
  49. * @author Andrea Poli (apoli@link.it)
  50.  * @author $Author$
  51.  * @version $Rev$, $Date$
  52. */
  53. public class XSDSchemaCollection {

  55.     private static boolean serializeXSDSchemiBuildSchemaSuccessDefault = false;
  56.     private static boolean serializeXSDSchemiBuildSchemaErrorDefault = true;
  57.     private static File serializeXSDSchemiBuildSchemaDefaultDir = null; 
  58.     public static boolean isSerializeXSDSchemiBuildSchemaSuccessDefault() {
  59.         return serializeXSDSchemiBuildSchemaSuccessDefault;
  60.     }
  61.     public static void setSerializeXSDSchemiBuildSchemaSuccessDefault(boolean serializeXSDSchemiBuildSchemaSuccessDefault) {
  62.         XSDSchemaCollection.serializeXSDSchemiBuildSchemaSuccessDefault = serializeXSDSchemiBuildSchemaSuccessDefault;
  63.     }
  64.     public static boolean isSerializeXSDSchemiBuildSchemaErrorDefault() {
  65.         return serializeXSDSchemiBuildSchemaErrorDefault;
  66.     }
  67.     public static void setSerializeXSDSchemiBuildSchemaErrorDefault(boolean serializeXSDSchemiBuildSchemaErrorDefault) {
  68.         XSDSchemaCollection.serializeXSDSchemiBuildSchemaErrorDefault = serializeXSDSchemiBuildSchemaErrorDefault;
  69.     }
  70.     public static File getSerializeXSDSchemiBuildSchemaDefaultDir() {
  71.         return serializeXSDSchemiBuildSchemaDefaultDir;
  72.     }
  73.     public static void setSerializeXSDSchemiBuildSchemaDefaultDir(File serializeXSDSchemiBuildSchemaDefaultDir) {
  74.         XSDSchemaCollection.serializeXSDSchemiBuildSchemaDefaultDir = serializeXSDSchemiBuildSchemaDefaultDir;
  75.     }
  76.     
  77.     private byte[] schemaRoot;
  78.     private Map<String, byte[]> resources;
  79.     private Map<String, List<String>> mappingNamespaceLocations;
  80.         
  81.     private boolean serializeXSDSchemiBuildSchemaSuccess = false;
  82.     private boolean serializeXSDSchemiBuildSchemaError = true;
  83.     private File serializeXSDSchemiBuildSchemaDir = null; 
  84.     
  85.     public XSDSchemaCollection() {
  86.         this.serializeXSDSchemiBuildSchemaSuccess = isSerializeXSDSchemiBuildSchemaSuccessDefault();
  87.         this.serializeXSDSchemiBuildSchemaError = isSerializeXSDSchemiBuildSchemaErrorDefault();
  88.         this.serializeXSDSchemiBuildSchemaDir = getSerializeXSDSchemiBuildSchemaDefaultDir();
  89.     }
  90.     
  91.     public boolean isSerializeXSDSchemiBuildSchemaSuccess() {
  92.         return this.serializeXSDSchemiBuildSchemaSuccess;
  93.     }
  94.     public void setSerializeXSDSchemiBuildSchemaSuccess(boolean serializeXSDSchemiBuildSchemaSuccess) {
  95.         this.serializeXSDSchemiBuildSchemaSuccess = serializeXSDSchemiBuildSchemaSuccess;
  96.     }
  97.     public boolean isSerializeXSDSchemiBuildSchemaError() {
  98.         return this.serializeXSDSchemiBuildSchemaError;
  99.     }
  100.     public void setSerializeXSDSchemiBuildSchemaError(boolean serializeXSDSchemiBuildSchemaErrror) {
  101.         this.serializeXSDSchemiBuildSchemaError = serializeXSDSchemiBuildSchemaErrror;
  102.     }
  103.     public File getSerializeXSDSchemiBuildSchemaDir() {
  104.         return this.serializeXSDSchemiBuildSchemaDir;
  105.     }
  106.     public void setSerializeXSDSchemiBuildSchemaDir(File serializeXSDSchemiBuildSchemaDir) {
  107.         this.serializeXSDSchemiBuildSchemaDir = serializeXSDSchemiBuildSchemaDir;
  108.     }
  109.     
  110.     public byte[] getSchemaRoot() {
  111.         return this.schemaRoot;
  112.     }
  113.     public void setSchemaRoot(byte[] schemaRoot) {
  114.         this.schemaRoot = schemaRoot;
  115.     }
  116.     public Map<String, byte[]> getResources() {
  117.         return this.resources;
  118.     }
  119.     public void setResources(Map<String, byte[]> resources) {
  120.         this.resources = resources;
  121.     }
  122.     public Map<String, List<String>> getMappingNamespaceLocations() {
  123.         return this.mappingNamespaceLocations;
  124.     }
  125.     public void setMappingNamespaceLocations(Map<String, List<String>> mappingNamespaceLocations) {
  126.         this.mappingNamespaceLocations = mappingNamespaceLocations;
  127.     }
  128.     
  129.     public void serialize(Logger log,File file) throws XMLException{
  130.         try (FileOutputStream fout = new FileOutputStream(file);){
  131.             serialize(log,fout);
  132.             fout.flush();
  133.         }catch(Exception e){
  134.             throw new XMLException(e.getMessage(),e);
  135.         }
  136.     }
  137.     
  138.     public void serialize(Logger log,String fileName) throws XMLException{
  139.         try (FileOutputStream fout = new FileOutputStream(fileName);){
  140.             serialize(log,fout);
  141.             fout.flush();
  142.         }catch(Exception e){
  143.             throw new XMLException(e.getMessage(),e);
  144.         }
  145.     }
  146.     
  147.     public byte[] serialize(Logger log) throws XMLException{
  148.         try{
  149.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  150.             serialize(log,bout);
  151.             bout.flush();
  152.             bout.close();
  153.             return bout.toByteArray();
  154.         }catch(Exception e){
  155.             throw new XMLException(e.getMessage(),e);
  156.         }
  157.     }


  160.     public void serialize(Logger log,OutputStream out) throws XMLException{
  161.     
  162.         try (ZipOutputStream zipOut = new ZipOutputStream(out);){
  163.             this.zipSerialize(log,zipOut);
  164.             
  165.             zipOut.flush();

  167.         }catch(Exception e){
  168.             throw new XMLException(e.getMessage(),e);
  169.         }
  170.     }
  171.     
  172.     public void zipSerialize(Logger log,ZipOutputStream zipOut) throws XMLException{
  173.         
  174.         try{
  175.             String rootPackageDir = "";
  176.             // Il codice dopo fissa il problema di inserire una directory nel package.
  177.             // Commentare la riga sotto per ripristinare il vecchio comportamento.
  178.             rootPackageDir = "schemi"+File.separatorChar;
  179.             
  180.             String nomeFile = "RootSchema.xsd";
  181.             zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  182.             zipOut.write(this.schemaRoot);
  183.             
  184.             if(this.resources!=null && this.resources.size()>0){
  185.                 for (String name : this.resources.keySet()) {
  186.                     
  187.                     nomeFile = name;
  188.                     zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  189.                     zipOut.write(this.resources.get(name));
  190.                     
  191.                     String namespaceFound = null;
  192.                     String locationFound = null;
  193.                     for (String namespace : this.mappingNamespaceLocations.keySet()) {
  194.                         List<String> split = this.mappingNamespaceLocations.get(namespace);
  195.                         if(split!=null){
  196.                         for (int i = 0; i < split.size(); i++) {
  197.                             if(split.get(i) != null && split.get(i).equals(nomeFile)){
  198.                                 namespaceFound = namespace;
  199.                                 locationFound = split.get(i);
  200.                                 break;
  201.                             }
  202.                         }
  203.                         if(namespaceFound!=null){
  204.                             break;}
  205.                         }
  206.                     }
  207.                         
  208.                     if(namespaceFound!=null){
  209.                         nomeFile = name+".namespace.txt";
  210.                         zipOut.putNextEntry(new ZipEntry(rootPackageDir+nomeFile));
  211.                         String valore = namespaceFound;
  212.                         if(locationFound!=null){
  213.                             valore = locationFound + "\n" + valore;
  214.                         }
  215.                         zipOut.write(valore.getBytes());
  216.                     }
  217.                     
  218.                 }
  219.             }
  220.             
  221.             try{
  222.                 this.buildSchemaEngine(log,false,false,null);
  223.             }catch(Throwable e){
  224.                 log.error("Costruzione Struttura degli Schemi XSD fallita: "+e.getMessage(),e);
  225.                 nomeFile = "BuildSchemaFailed.txt";
  226.                 zipOut.putNextEntry(new ZipEntry(nomeFile));
  227.                 String msg = e.getMessage();
  228.                 if(msg==null || msg.equals("")){
  229.                     if(e instanceof NullPointerException){
  230.                         msg = "Internal Error (NP)";
  231.                     }
  232.                     else{
  233.                         msg = e.toString();
  234.                         if(msg==null || msg.equals("")){
  235.                             msg = "Internal Error";
  236.                         }
  237.                     }
  238.                 }
  239.                 zipOut.write(msg.getBytes());
  240.             }
  241.         }catch(Exception e){
  242.             throw new XMLException(e.getMessage(),e);
  243.         }
  244.     }
  245.     
  246.     /**
  247.      * Costruisce un unico schema unendo tutti gli schemi importati
  248.      * 
  249.      * @param logger logger
  250.      * @return Schema
  251.      * @throws XMLException
  252.      */
  253.     public Schema buildSchema(Logger logger) throws XMLException {
  254.         return this.buildSchemaEngine(logger, this.serializeXSDSchemiBuildSchemaSuccess, this.serializeXSDSchemiBuildSchemaError, this.serializeXSDSchemiBuildSchemaDir);
  255.     }
  256.     private Schema buildSchemaEngine(Logger logger, boolean serializeXSDSchemiBuildSchemaSuccess, boolean serializeXSDSchemiBuildSchemaError, File serializeXSDSchemiBuildSchemaDir) throws XMLException {
  257.         
  258.         // Creo XSDResolver con le risorse localizzate e procedo con la validazione
  259.         XSDResourceResolver resourceResolver = new XSDResourceResolver(this.resources);
  260.         try{
  261.             // UndeclaredPrefix: Cannot resolve 'example:xxxxType' as a QName: the prefix 'example' is not declared.
  262.             // After some debugging, I've found out that this is a bug of the JAXP api's built in to the JDK.
  263.             // You can fix it by making sure that you use the Xerces version of the SchemaFactory, and not the JDK internal one. 
  264.             // The algorithm for choosing a SchemaFactory is explained at http://java.sun.com/j2se/1.5.0/docs/api/javax/xml/validation/SchemaFactory.html#newInstance(java.lang.String).
  265.             // It comes down to setting the System property "javax.xml.validation.SchemaFactory:http://www.w3.org/2001/XMLSchema" to the value "org.apache.xerces.jaxp.validation.XMLSchemaFactory".
  266.             // Note that just adding Xerces to your classpath won't fix this, for reasons explained at http://xerces.apache.org/xerces2-j/faq-general.html#faq-4
  267.             /**return new ValidatoreXSD(org.apache.xerces.jaxp.validation.XMLSchemaFactory.class.getName(),xsdResourceResolver,is);*/
  268.             ValidatoreXSD validatoreXSD = new ValidatoreXSD(logger,"org.apache.xerces.jaxp.validation.XMLSchemaFactory",resourceResolver,
  269.                     new ByteArrayInputStream(this.schemaRoot));
  270.             /**ValidatoreXSD validatoreXSD = new ValidatoreXSD(this.logger,resourceResolver,new ByteArrayInputStream(schemaPerValidazione));*/

  272.             if(serializeXSDSchemiBuildSchemaSuccess){
  273.                 debugPrintXSDSchemi(this.schemaRoot, resourceResolver, logger, true, serializeXSDSchemiBuildSchemaDir);
  274.             }

  276.             return validatoreXSD.getSchema();

  278.         }catch (Exception e) {

  280.             if(serializeXSDSchemiBuildSchemaError){
  281.                 debugPrintXSDSchemi(this.schemaRoot, resourceResolver, logger, false, serializeXSDSchemiBuildSchemaDir);
  282.             }

  284.             throw new XMLException("Riscontrato errore durante l'inizializzazione dello schema: "+e.getMessage(),e);
  285.         }
  286.         
  287.     }
  288.     
  289.     private void debugPrintXSDSchemi(byte[]schemaPerValidazione,XSDResourceResolver resourceResolver,Logger logger, boolean success, File serializeXSDSchemiBuildSchemaDir){
  290.         try{
  291.             FileAttribute<Set<PosixFilePermission>> attr = PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rwx------"));
  292.             File dir = null;
  293.             if(serializeXSDSchemiBuildSchemaDir!=null) {
  294.                 dir = Files.createTempDirectory(serializeXSDSchemiBuildSchemaDir.toPath(), "xsd_dir_", attr).toFile();
  295.             }
  296.             else {
  297.                 dir = Files.createTempDirectory("xsd_dir_", attr).toFile();
  298.             }
  299.             boolean dirCreate = dir.exists();
  300.             /**System.out.println("FILE?["+dir.getAbsolutePath()+"] ["+dirCreate+"] ["+dir.isDirectory()+"]");*/
  301.             dirCreate = dirCreate && dir.isDirectory();
  302.             /**System.out.println("DIR CREATE ["+dirCreate+"]");*/
  303.             
  304.             // Provo a registrare lo schema principale
  305.             String uniqueID = XSDSchemaCollection.getIdForDebug();
  306.             File f = null;
  307.             if(dirCreate)
  308.                 f = File.createTempFile("root_"+uniqueID+"_", ".xsd",dir);
  309.             else
  310.                 f = FileSystemUtilities.createTempFile("root_"+uniqueID+"_", ".xsd");
  311.             FileSystemUtilities.writeFile(f, schemaPerValidazione);
  312.             
  313.             // Provo a registrare gli schemi utilizzati
  314.             if(resourceResolver!=null){
  315.                 XSDResourceResolver xsdResolver = resourceResolver;
  316.                 for (String systemId : xsdResolver.getResources().keySet()) {
  317.                     byte[] contenuto = xsdResolver.getResources().get(systemId);
  318.                     File schemaTmpLog = null;
  319.                     if(dirCreate)
  320.                         schemaTmpLog = File.createTempFile("import_"+uniqueID+"_"+systemId+"_", ".xsd", dir);
  321.                     else
  322.                         schemaTmpLog = FileSystemUtilities.createTempFile("import_"+uniqueID+"_"+systemId+"_", ".xsd");
  323.                     FileSystemUtilities.writeFile(schemaTmpLog, contenuto);
  324.                 }
  325.             }
  326.             
  327.             String motivo = null;
  328.             if(success){
  329.                 motivo = "completata con successo";
  330.             }
  331.             else{
  332.                 motivo = "completata con errore";
  333.             }
  334.             
  335.             String msg = null;
  336.             if(dirCreate)
  337.                 msg = "Inizializzazione dello schema "+motivo+", gli schemi sono stati registrati nella directory "+dir.getAbsolutePath();
  338.             else
  339.                 msg = "Inizializzazione dello schema "+motivo+", gli schemi sono stati registrati nella area temporanea (root schema: "+f.getAbsolutePath()+")";
  340.             
  341.             if(success){
  342.                 logger.info(msg);
  343.             }
  344.             else{
  345.                 logger.error(msg);
  346.             }
  347.                             
  348.         }catch(Exception eDebug){
  349.             logger.error("Registrazione xsd per debug non riuscita: "+eDebug.getMessage(),eDebug);
  350.         }
  351.     }
  352.     
  353.     private static long counter = 0;
  354.     private static synchronized String getIdForDebug(){
  355.         SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  356.         XSDSchemaCollection.counter++;
  357.         return "ID_"+XSDSchemaCollection.counter+"_"+dateformat.format(DateManager.getDate());
  358.     }
  359. }
Created with JaCoCo 0.8.8.202204050719