ZipJarCrawler.java

  1. /* Copyright 2002-2018 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS 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.orekit.data;

  19. import java.io.Closeable;
  20. import java.io.File;
  21. import java.io.FileInputStream;
  22. import java.io.IOException;
  23. import java.io.InputStream;
  24. import java.net.URISyntaxException;
  25. import java.net.URL;
  26. import java.text.ParseException;
  27. import java.util.Iterator;
  28. import java.util.NoSuchElementException;
  29. import java.util.regex.Pattern;
  30. import java.util.zip.ZipEntry;
  31. import java.util.zip.ZipInputStream;

  33. import org.hipparchus.exception.DummyLocalizable;
  34. import org.hipparchus.exception.LocalizedCoreFormats;
  35. import org.orekit.errors.OrekitException;


  38. /** Helper class for loading data files from a zip/jar archive.

  40.  * <p>
  41.  * This class browses all entries in a zip/jar archive in filesystem or in classpath.
  42.  * </p>
  43.  * <p>
  44.  * The organization of entries within the archive is unspecified. All entries are
  45.  * checked in turn. If several entries of the archive are supported by the data
  46.  * loader, all of them will be loaded.
  47.  * </p>
  48.  * <p>
  49.  * Gzip-compressed files are supported.
  50.  * </p>
  51.  * <p>
  52.  * Zip archives entries are supported recursively.
  53.  * </p>
  54.  * <p>
  55.  * This is a simple application of the <code>visitor</code> design pattern for
  56.  * zip entries browsing.
  57.  * </p>
  58.  * @see DataProvidersManager
  59.  * @author Luc Maisonobe
  60.  */
  61. public class ZipJarCrawler implements DataProvider {

  63.     /** Zip archive on the filesystem. */
  64.     private final File file;

  66.     /** Zip archive in the classpath. */
  67.     private final String resource;

  69.     /** Class loader to use. */
  70.     private final ClassLoader classLoader;

  72.     /** Zip archive on network. */
  73.     private final URL url;

  75.     /** Prefix name of the zip. */
  76.     private final String name;

  78.     /** Build a zip crawler for an archive file on filesystem.
  79.      * @param file zip file to browse
  80.      */
  81.     public ZipJarCrawler(final File file) {
  82.         this.file        = file;
  83.         this.resource    = null;
  84.         this.classLoader = null;
  85.         this.url         = null;
  86.         this.name        = file.getAbsolutePath();
  87.     }

  89.     /** Build a zip crawler for an archive file in classpath.
  90.      * <p>
  91.      * Calling this constructor has the same effect as calling
  92.      * {@link #ZipJarCrawler(ClassLoader, String)} with
  93.      * {@code ZipJarCrawler.class.getClassLoader()} as first
  94.      * argument.
  95.      * </p>
  96.      * @param resource name of the zip file to browse
  97.      * @exception OrekitException if resource name is malformed
  98.      */
  99.     public ZipJarCrawler(final String resource) throws OrekitException {
  100.         this(ZipJarCrawler.class.getClassLoader(), resource);
  101.     }

  103.     /** Build a zip crawler for an archive file in classpath.
  104.      * @param classLoader class loader to use to retrieve the resources
  105.      * @param resource name of the zip file to browse
  106.      * @exception OrekitException if resource name is malformed
  107.      */
  108.     public ZipJarCrawler(final ClassLoader classLoader, final String resource)
  109.         throws OrekitException {
  110.         try {
  111.             this.file        = null;
  112.             this.resource    = resource;
  113.             this.classLoader = classLoader;
  114.             this.url         = null;
  115.             this.name        = classLoader.getResource(resource).toURI().toString();
  116.         } catch (URISyntaxException use) {
  117.             throw new OrekitException(use, LocalizedCoreFormats.SIMPLE_MESSAGE, use.getMessage());
  118.         }
  119.     }

  121.     /** Build a zip crawler for an archive file on network.
  122.      * @param url URL of the zip file on network
  123.      * @exception OrekitException if url syntax is malformed
  124.      */
  125.     public ZipJarCrawler(final URL url) throws OrekitException {
  126.         try {
  127.             this.file        = null;
  128.             this.resource    = null;
  129.             this.classLoader = null;
  130.             this.url         = url;
  131.             this.name        = url.toURI().toString();
  132.         } catch (URISyntaxException use) {
  133.             throw new OrekitException(use, LocalizedCoreFormats.SIMPLE_MESSAGE, use.getMessage());
  134.         }
  135.     }

  137.     /** {@inheritDoc} */
  138.     public boolean feed(final Pattern supported, final DataLoader visitor)
  139.         throws OrekitException {

  141.         try {

  143.             // open the raw data stream
  144.             Archive archive = null;
  145.             try {
  146.                 if (file != null) {
  147.                     archive = new Archive(new FileInputStream(file));
  148.                 } else if (resource != null) {
  149.                     archive = new Archive(classLoader.getResourceAsStream(resource));
  150.                 } else {
  151.                     archive = new Archive(url.openConnection().getInputStream());
  152.                 }

  154.                 return feed(name, supported, visitor, archive);

  156.             } finally {
  157.                 if (archive != null) {
  158.                     archive.close();
  159.                 }
  160.             }

  162.         } catch (IOException ioe) {
  163.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  164.         } catch (ParseException pe) {
  165.             throw new OrekitException(pe, new DummyLocalizable(pe.getMessage()));
  166.         }

  168.     }

  170.     /** Feed a data file loader by browsing the entries in a zip/jar.
  171.      * @param prefix prefix to use for name
  172.      * @param supported pattern for file names supported by the visitor
  173.      * @param visitor data file visitor to use
  174.      * @param archive archive to read
  175.      * @exception OrekitException if some data is missing, duplicated
  176.      * or can't be read
  177.      * @return true if something has been loaded
  178.      * @exception IOException if data cannot be read
  179.      * @exception ParseException if data cannot be read
  180.      */
  181.     private boolean feed(final String prefix, final Pattern supported,
  182.                          final DataLoader visitor, final Archive archive)
  183.         throws OrekitException, IOException, ParseException {

  185.         OrekitException delayedException = null;
  186.         boolean loaded = false;

  188.         // loop over all entries
  189.         for (final Archive.EntryStream entry : archive) {

  191.             try {

  193.                 if (visitor.stillAcceptsData() && !entry.isDirectory()) {

  195.                     final String fullName = prefix + "!" + entry.getName();

  197.                     if (ZIP_ARCHIVE_PATTERN.matcher(entry.getName()).matches()) {

  199.                         // recurse inside the archive entry
  200.                         loaded = feed(fullName, supported, visitor, new Archive(entry)) || loaded;

  202.                     } else {

  204.                         // remove leading directories
  205.                         String entryName = entry.getName();
  206.                         final int lastSlash = entryName.lastIndexOf('/');
  207.                         if (lastSlash >= 0) {
  208.                             entryName = entryName.substring(lastSlash + 1);
  209.                         }

  211.                         // apply all registered filters
  212.                         NamedData data = new NamedData(entryName, () -> entry);
  213.                         data = DataProvidersManager.getInstance().applyAllFilters(data);

  215.                         if (supported.matcher(data.getName()).matches()) {
  216.                             // visit the current file
  217.                             try (InputStream input = data.getStreamOpener().openStream()) {
  218.                                 visitor.loadData(input, fullName);
  219.                                 loaded = true;
  220.                             }
  221.                         }

  223.                     }

  225.                 }

  227.             } catch (OrekitException oe) {
  228.                 delayedException = oe;
  229.             }

  231.             entry.close();

  233.         }

  235.         if (!loaded && delayedException != null) {
  236.             throw delayedException;
  237.         }
  238.         return loaded;

  240.     }

  242.     /** Local class wrapping a zip archive. */
  243.     private static final class Archive implements Closeable, Iterable<Archive.EntryStream> {

  245.         /** Zip stream. */
  246.         private final ZipInputStream zip;

  248.         /** Next entry. */
  249.         private EntryStream next;

  251.         /** Simple constructor.
  252.          * @param rawStream raw stream
  253.          * @exception IOException if first entry cannot be retrieved
  254.          */
  255.         Archive(final InputStream rawStream) throws IOException {
  256.             zip = new ZipInputStream(rawStream);
  257.             goToNext();
  258.         }

  260.         /** Go to next entry.
  261.         * @exception IOException if next entry cannot be retrieved
  262.          */
  263.         private void goToNext() throws IOException {
  264.             final ZipEntry ze = zip.getNextEntry();
  265.             if (ze == null) {
  266.                 next = null;
  267.             } else {
  268.                 next = new EntryStream(ze.getName(), ze.isDirectory());
  269.             }
  270.         }

  272.         /** {@inheritDoc} */
  273.         @Override
  274.         public Iterator<Archive.EntryStream> iterator() {
  275.             return new Iterator<EntryStream> () {

  277.                 /** {@inheritDoc} */
  278.                 @Override
  279.                 public boolean hasNext() {
  280.                     return next != null;
  281.                 }

  283.                 /** {@inheritDoc} */
  284.                 @Override
  285.                 public EntryStream next() throws NoSuchElementException {
  286.                     if (next == null) {
  287.                         // this should never happen
  288.                         throw new NoSuchElementException();
  289.                     }
  290.                     return next;
  291.                 }

  293.             };
  294.         }

  296.         /** {@inheritDoc} */
  297.         @Override
  298.         public void close() throws IOException {
  299.             zip.close();
  300.         }

  302.         /** Archive entry. */
  303.         public class EntryStream extends InputStream {

  305.             /** Name of the entry. */
  306.             private final String name;

  308.             /** Directory indicator. */
  309.             private boolean isDirectory;

  311.             /** Indicator for already closed stream. */
  312.             private boolean closed;

  314.             /** Simple constructor.
  315.              * @param name name of the entry
  316.              * @param isDirectory if true, the entry is a directory
  317.              */
  318.             EntryStream(final String name, final boolean isDirectory) {
  319.                 this.name        = name;
  320.                 this.isDirectory = isDirectory;
  321.                 this.closed      = false;
  322.             }

  324.             /** Get the name of the entry.
  325.              * @return name of the entry
  326.              */
  327.             public String getName() {
  328.                 return name;
  329.             }

  331.             /** Check if the entry is a directory.
  332.              * @return true if the entry is a directory
  333.              */
  334.             public boolean isDirectory() {
  335.                 return isDirectory;
  336.             }

  338.             /** {@inheritDoc} */
  339.             @Override
  340.             public int read() throws IOException {
  341.                 // delegate read to global input stream
  342.                 return zip.read();
  343.             }

  345.             /** {@inheritDoc} */
  346.             @Override
  347.             public void close() throws IOException {
  348.                 if (!closed) {
  349.                     zip.closeEntry();
  350.                     goToNext();
  351.                     closed = true;
  352.                 }
  353.             }

  355.         }

  357.     }

  359. }
Created with JaCoCo 0.7.9.201702052155