CatalogResolver.java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * The ASF licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.apache.commons.configuration2.resolver;

  19. import java.io.IOException;
  20. import java.io.InputStream;
  21. import java.net.FileNameMap;
  22. import java.net.URL;
  23. import java.net.URLConnection;
  24. import java.util.Vector;

  26. import org.apache.commons.configuration2.ex.ConfigurationException;
  27. import org.apache.commons.configuration2.interpol.ConfigurationInterpolator;
  28. import org.apache.commons.configuration2.io.ConfigurationLogger;
  29. import org.apache.commons.configuration2.io.FileLocatorUtils;
  30. import org.apache.commons.configuration2.io.FileSystem;
  31. import org.apache.commons.lang3.SystemProperties;
  32. import org.apache.xml.resolver.CatalogException;
  33. import org.apache.xml.resolver.readers.CatalogReader;
  34. import org.xml.sax.EntityResolver;
  35. import org.xml.sax.InputSource;
  36. import org.xml.sax.SAXException;

  38. /**
  39.  * Thin wrapper around xml commons CatalogResolver to allow list of catalogs to be provided.
  40.  *
  41.  * @since 1.7
  42.  */
  43. public class CatalogResolver implements EntityResolver {
  44.     /**
  45.      * Overrides the Catalog implementation to use the underlying FileSystem.
  46.      */
  47.     public static class Catalog extends org.apache.xml.resolver.Catalog {
  48.         /** The FileSystem */
  49.         private FileSystem fs;

  51.         /** FileNameMap to determine the mime type */
  52.         private final FileNameMap fileNameMap = URLConnection.getFileNameMap();

  54.         /**
  55.          * Load the catalogs.
  56.          *
  57.          * @throws IOException if an error occurs.
  58.          */
  59.         @Override
  60.         public void loadSystemCatalogs() throws IOException {
  61.             fs = ((CatalogManager) catalogManager).getFileSystem();
  62.             final String base = ((CatalogManager) catalogManager).getBaseDir();

  64.             // This is safe because the catalog manager returns a vector of strings.
  65.             final Vector<String> catalogs = catalogManager.getCatalogFiles();
  66.             if (catalogs != null) {
  67.                 for (int count = 0; count < catalogs.size(); count++) {
  68.                     final String fileName = catalogs.elementAt(count);

  70.                     URL url = null;
  71.                     InputStream inputStream = null;

  73.                     try {
  74.                         url = locate(fs, base, fileName);
  75.                         if (url != null) {
  76.                             inputStream = fs.getInputStream(url);
  77.                         }
  78.                     } catch (final ConfigurationException ce) {
  79.                         final String name = url.toString();
  80.                         // Ignore the exception.
  81.                         catalogManager.debug.message(DEBUG_ALL, "Unable to get input stream for " + name + ". " + ce.getMessage());
  82.                     }
  83.                     if (inputStream != null) {
  84.                         final String mimeType = fileNameMap.getContentTypeFor(fileName);
  85.                         try {
  86.                             if (mimeType != null) {
  87.                                 parseCatalog(mimeType, inputStream);
  88.                                 continue;
  89.                             }
  90.                         } catch (final Exception ex) {
  91.                             // Ignore the exception.
  92.                             catalogManager.debug.message(DEBUG_ALL, "Exception caught parsing input stream for " + fileName + ". " + ex.getMessage());
  93.                         } finally {
  94.                             inputStream.close();
  95.                         }
  96.                     }
  97.                     parseCatalog(base, fileName);
  98.                 }
  99.             }

  101.         }

  103.         /**
  104.          * Performs character normalization on a URI reference.
  105.          *
  106.          * @param uriref The URI reference
  107.          * @return The normalized URI reference.
  108.          */
  109.         @Override
  110.         protected String normalizeURI(final String uriref) {
  111.             final ConfigurationInterpolator ci = ((CatalogManager) catalogManager).getInterpolator();
  112.             final String resolved = ci != null ? String.valueOf(ci.interpolate(uriref)) : uriref;
  113.             return super.normalizeURI(resolved);
  114.         }

  116.         /**
  117.          * Parses the specified catalog file.
  118.          *
  119.          * @param baseDir The base directory, if not included in the file name.
  120.          * @param fileName The catalog file. May be a full URI String.
  121.          * @throws IOException If an error occurs.
  122.          */
  123.         public void parseCatalog(final String baseDir, final String fileName) throws IOException {
  124.             base = locate(fs, baseDir, fileName);
  125.             catalogCwd = base;
  126.             default_override = catalogManager.getPreferPublic();
  127.             catalogManager.debug.message(DEBUG_NORMAL, "Parse catalog: " + fileName);

  129.             boolean parsed = false;

  131.             for (int count = 0; !parsed && count < readerArr.size(); count++) {
  132.                 final CatalogReader reader = (CatalogReader) readerArr.get(count);
  133.                 InputStream inputStream;

  135.                 try {
  136.                     inputStream = fs.getInputStream(base);
  137.                 } catch (final Exception ex) {
  138.                     catalogManager.debug.message(DEBUG_NORMAL, "Unable to access " + base + ex.getMessage());
  139.                     break;
  140.                 }

  142.                 try {
  143.                     reader.readCatalog(this, inputStream);
  144.                     parsed = true;
  145.                 } catch (final CatalogException ce) {
  146.                     catalogManager.debug.message(DEBUG_NORMAL, "Parse failed for " + fileName + ce.getMessage());
  147.                     if (ce.getExceptionType() == CatalogException.PARSE_FAILED) {
  148.                         break;
  149.                     }
  150.                     // try again!
  151.                     continue;
  152.                 } finally {
  153.                     try {
  154.                         inputStream.close();
  155.                     } catch (final IOException ioe) {
  156.                         // Ignore the exception.
  157.                         inputStream = null;
  158.                     }
  159.                 }
  160.             }

  162.             if (parsed) {
  163.                 parsePendingCatalogs();
  164.             }
  165.         }
  166.     }

  168.     /**
  169.      * Extends the CatalogManager to make the FileSystem and base directory accessible.
  170.      */
  171.     public static class CatalogManager extends org.apache.xml.resolver.CatalogManager {
  172.         /** The static catalog used by this manager. */
  173.         private static org.apache.xml.resolver.Catalog staticCatalog;

  175.         /** The FileSystem */
  176.         private FileSystem fs;

  178.         /** The base directory */
  179.         private String baseDir = SystemProperties.getUserDir();

  181.         /** The object for handling interpolation. */
  182.         private ConfigurationInterpolator interpolator;

  184.         /**
  185.          * Gets the base directory.
  186.          *
  187.          * @return The base directory.
  188.          */
  189.         public String getBaseDir() {
  190.             return this.baseDir;
  191.         }

  193.         /**
  194.          * Gets a catalog instance.
  195.          *
  196.          * If this manager uses static catalogs, the same static catalog will always be returned. Otherwise a new catalog will
  197.          * be returned.
  198.          *
  199.          * @return The Catalog.
  200.          */
  201.         @Override
  202.         public org.apache.xml.resolver.Catalog getCatalog() {
  203.             return getPrivateCatalog();
  204.         }

  206.         /**
  207.          * Gets the FileSystem.
  208.          *
  209.          * @return The FileSystem.
  210.          */
  211.         public FileSystem getFileSystem() {
  212.             return this.fs;
  213.         }

  215.         /**
  216.          * Gets the ConfigurationInterpolator.
  217.          *
  218.          * @return the ConfigurationInterpolator.
  219.          */
  220.         public ConfigurationInterpolator getInterpolator() {
  221.             return interpolator;
  222.         }

  224.         /**
  225.          * Gets a new catalog instance. This method is only overridden because xml-resolver might be in a parent ClassLoader and
  226.          * will be incapable of loading our Catalog implementation.
  227.          *
  228.          * This method always returns a new instance of the underlying catalog class.
  229.          *
  230.          * @return the Catalog.
  231.          */
  232.         @Override
  233.         public org.apache.xml.resolver.Catalog getPrivateCatalog() {
  234.             org.apache.xml.resolver.Catalog catalog = staticCatalog;

  236.             if (catalog == null || !getUseStaticCatalog()) {
  237.                 try {
  238.                     catalog = new Catalog();
  239.                     catalog.setCatalogManager(this);
  240.                     catalog.setupReaders();
  241.                     catalog.loadSystemCatalogs();
  242.                 } catch (final Exception ex) {
  243.                     ex.printStackTrace();
  244.                 }

  246.                 if (getUseStaticCatalog()) {
  247.                     staticCatalog = catalog;
  248.                 }
  249.             }

  251.             return catalog;
  252.         }

  254.         /**
  255.          * Sets the base directory.
  256.          *
  257.          * @param baseDir The base directory.
  258.          */
  259.         public void setBaseDir(final String baseDir) {
  260.             if (baseDir != null) {
  261.                 this.baseDir = baseDir;
  262.             }
  263.         }

  265.         /**
  266.          * Sets the FileSystem
  267.          *
  268.          * @param fileSystem The FileSystem in use.
  269.          */
  270.         public void setFileSystem(final FileSystem fileSystem) {
  271.             this.fs = fileSystem;
  272.         }

  274.         /**
  275.          * Sets the ConfigurationInterpolator.
  276.          *
  277.          * @param configurationInterpolator the ConfigurationInterpolator.
  278.          */
  279.         public void setInterpolator(final ConfigurationInterpolator configurationInterpolator) {
  280.             interpolator = configurationInterpolator;
  281.         }
  282.     }

  284.     /**
  285.      * Debug everything.
  286.      */
  287.     private static final int DEBUG_ALL = 9;

  289.     /**
  290.      * Normal debug setting.
  291.      */
  292.     private static final int DEBUG_NORMAL = 4;

  294.     /**
  295.      * Debug nothing.
  296.      */
  297.     private static final int DEBUG_NONE = 0;

  299.     /**
  300.      * Locates a given file. This implementation delegates to the corresponding method in {@link FileLocatorUtils}.
  301.      *
  302.      * @param fs the {@code FileSystem}
  303.      * @param basePath the base path
  304.      * @param name the file name
  305.      * @return the URL pointing to the file
  306.      */
  307.     private static URL locate(final FileSystem fs, final String basePath, final String name) {
  308.         return FileLocatorUtils.locate(FileLocatorUtils.fileLocator().fileSystem(fs).basePath(basePath).fileName(name).create());
  309.     }

  311.     /**
  312.      * The CatalogManager
  313.      */
  314.     private final CatalogManager manager = new CatalogManager();

  316.     /**
  317.      * The FileSystem in use.
  318.      */
  319.     private FileSystem fs = FileLocatorUtils.DEFAULT_FILE_SYSTEM;

  321.     /**
  322.      * The CatalogResolver
  323.      */
  324.     private org.apache.xml.resolver.tools.CatalogResolver resolver;

  326.     /**
  327.      * Stores the logger.
  328.      */
  329.     private ConfigurationLogger log;

  331.     /**
  332.      * Constructs the CatalogResolver
  333.      */
  334.     public CatalogResolver() {
  335.         manager.setIgnoreMissingProperties(true);
  336.         manager.setUseStaticCatalog(false);
  337.         manager.setFileSystem(fs);
  338.         initLogger(null);
  339.     }

  341.     /**
  342.      * Gets the logger used by this configuration object.
  343.      *
  344.      * @return the logger
  345.      */
  346.     public ConfigurationLogger getLogger() {
  347.         return log;
  348.     }

  350.     private synchronized org.apache.xml.resolver.tools.CatalogResolver getResolver() {
  351.         if (resolver == null) {
  352.             resolver = new org.apache.xml.resolver.tools.CatalogResolver(manager);
  353.         }
  354.         return resolver;
  355.     }

  357.     /**
  358.      * Initializes the logger. Checks for null parameters.
  359.      *
  360.      * @param log the new logger
  361.      */
  362.     private void initLogger(final ConfigurationLogger log) {
  363.         this.log = log != null ? log : ConfigurationLogger.newDummyLogger();
  364.     }

  366.     /**
  367.      * <p>
  368.      * Implements the {@code resolveEntity} method for the SAX interface.
  369.      * </p>
  370.      * <p>
  371.      * Presented with an optional public identifier and a system identifier, this function attempts to locate a mapping in
  372.      * the catalogs.
  373.      * </p>
  374.      * <p>
  375.      * If such a mapping is found, the resolver attempts to open the mapped value as an InputSource and return it.
  376.      * Exceptions are ignored and null is returned if the mapped value cannot be opened as an input source.
  377.      * </p>
  378.      * <p>
  379.      * If no mapping is found (or an error occurs attempting to open the mapped value as an input source), null is returned
  380.      * and the system will use the specified system identifier as if no entityResolver was specified.
  381.      * </p>
  382.      *
  383.      * @param publicId The public identifier for the entity in question. This may be null.
  384.      * @param systemId The system identifier for the entity in question. XML requires a system identifier on all external
  385.      *        entities, so this value is always specified.
  386.      * @return An InputSource for the mapped identifier, or null.
  387.      * @throws SAXException if an error occurs.
  388.      */
  389.     @SuppressWarnings("resource") // InputSource wraps an InputStream.
  390.     @Override
  391.     public InputSource resolveEntity(final String publicId, final String systemId) throws SAXException {
  392.         String resolved = getResolver().getResolvedEntity(publicId, systemId);

  394.         if (resolved != null) {
  395.             final String badFilePrefix = "file://";
  396.             final String correctFilePrefix = "file:///";

  398.             // Java 5 has a bug when constructing file URLs
  399.             if (resolved.startsWith(badFilePrefix) && !resolved.startsWith(correctFilePrefix)) {
  400.                 resolved = correctFilePrefix + resolved.substring(badFilePrefix.length());
  401.             }

  403.             try {
  404.                 final URL url = locate(fs, null, resolved);
  405.                 if (url == null) {
  406.                     throw new ConfigurationException("Could not locate " + resolved);
  407.                 }
  408.                 final InputStream inputStream = fs.getInputStream(url);
  409.                 final InputSource inputSource = new InputSource(resolved);
  410.                 inputSource.setPublicId(publicId);
  411.                 inputSource.setByteStream(inputStream);
  412.                 return inputSource;
  413.             } catch (final Exception e) {
  414.                 log.warn("Failed to create InputSource for " + resolved, e);
  415.             }
  416.         }

  418.         return null;
  419.     }

  421.     /**
  422.      * Sets the base path.
  423.      *
  424.      * @param baseDir The base path String.
  425.      */
  426.     public void setBaseDir(final String baseDir) {
  427.         manager.setBaseDir(baseDir);
  428.     }

  430.     /**
  431.      * Sets the list of catalog file names
  432.      *
  433.      * @param catalogs The delimited list of catalog files.
  434.      */
  435.     public void setCatalogFiles(final String catalogs) {
  436.         manager.setCatalogFiles(catalogs);
  437.     }

  439.     /**
  440.      * Enables debug logging of xml-commons Catalog processing.
  441.      *
  442.      * @param debug True if debugging should be enabled, false otherwise.
  443.      */
  444.     public void setDebug(final boolean debug) {
  445.         manager.setVerbosity(debug ? DEBUG_ALL : DEBUG_NONE);
  446.     }

  448.     /**
  449.      * Sets the FileSystem.
  450.      *
  451.      * @param fileSystem The FileSystem.
  452.      */
  453.     public void setFileSystem(final FileSystem fileSystem) {
  454.         this.fs = fileSystem;
  455.         manager.setFileSystem(fileSystem);
  456.     }

  458.     /**
  459.      * Sets the {@code ConfigurationInterpolator}.
  460.      *
  461.      * @param ci the {@code ConfigurationInterpolator}
  462.      */
  463.     public void setInterpolator(final ConfigurationInterpolator ci) {
  464.         manager.setInterpolator(ci);
  465.     }

  467.     /**
  468.      * Allows setting the logger to be used by this object. This method makes it possible for clients to exactly control
  469.      * logging behavior. Per default a logger is set that will ignore all log messages. Derived classes that want to enable
  470.      * logging should call this method during their initialization with the logger to be used. Passing in <strong>null</strong> as
  471.      * argument disables logging.
  472.      *
  473.      * @param log the new logger
  474.      */
  475.     public void setLogger(final ConfigurationLogger log) {
  476.         initLogger(log);
  477.     }
  478. }
Created with JaCoCo 0.8.12.202403310830