ZipJarCrawler.java

  1. /* Copyright 2002-2013 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.nio.channels.UnsupportedAddressTypeException;
  27. import java.text.ParseException;
  28. import java.util.Iterator;
  29. import java.util.regex.Matcher;
  30. import java.util.regex.Pattern;
  31. import java.util.zip.GZIPInputStream;
  32. import java.util.zip.ZipEntry;
  33. import java.util.zip.ZipInputStream;

  35. import org.apache.commons.math3.exception.util.DummyLocalizable;
  36. import org.apache.commons.math3.exception.util.LocalizedFormats;
  37. import org.orekit.errors.OrekitException;


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

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

  65.     /** Zip archive on the filesystem. */
  66.     private final File file;

  68.     /** Zip archive in the classpath. */
  69.     private final String resource;

  71.     /** Class loader to use. */
  72.     private final ClassLoader classLoader;

  74.     /** Zip archive on network. */
  75.     private final URL url;

  77.     /** Prefix name of the zip. */
  78.     private final String name;

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

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

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

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

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

  143.         try {

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

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

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

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

  170.     }

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

  187.         OrekitException delayedException = null;
  188.         boolean loaded = false;

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

  193.             try {

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

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

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

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

  204.                     } else {

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

  213.                         // remove suffix from gzip entries
  214.                         final Matcher gzipMatcher = GZIP_FILE_PATTERN.matcher(entryName);
  215.                         final String baseName = gzipMatcher.matches() ? gzipMatcher.group(1) : entryName;

  217.                         if (supported.matcher(baseName).matches()) {

  219.                             // visit the current entry
  220.                             final InputStream stream =
  221.                                 gzipMatcher.matches() ? new GZIPInputStream(entry) : entry;
  222.                             visitor.loadData(stream, fullName);
  223.                             stream.close();
  224.                             loaded = true;

  226.                         }

  228.                     }

  230.                 }

  232.             } catch (OrekitException oe) {
  233.                 delayedException = oe;
  234.             }

  236.             entry.close();

  238.         }

  240.         if (!loaded && delayedException != null) {
  241.             throw delayedException;
  242.         }
  243.         return loaded;

  245.     }

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

  250.         /** Zip stream. */
  251.         private final ZipInputStream zip;

  253.         /** Next entry. */
  254.         private EntryStream next;

  256.         /** Simple constructor.
  257.          * @param rawStream raw stream
  258.          * @exception IOException if first entry cannot be retrieved
  259.          */
  260.         public Archive(final InputStream rawStream) throws IOException {
  261.             zip = new ZipInputStream(rawStream);
  262.             goToNext();
  263.         }

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

  277.         /** {@inheritDoc} */
  278.         @Override
  279.         public Iterator<Archive.EntryStream> iterator() {
  280.             return new Iterator<EntryStream> () {

  282.                 /** {@inheritDoc} */
  283.                 @Override
  284.                 public boolean hasNext() {
  285.                     return next != null;
  286.                 }

  288.                 /** {@inheritDoc} */
  289.                 @Override
  290.                 public EntryStream next() {
  291.                     return next;
  292.                 }

  294.                 /** {@inheritDoc} */
  295.                 @Override
  296.                 public void remove() {
  297.                     // this part is never called
  298.                     throw new UnsupportedAddressTypeException();
  299.                 }

  301.             };
  302.         }

  304.         /** {@inheritDoc} */
  305.         @Override
  306.         public void close() throws IOException {
  307.             zip.close();
  308.         }

  310.         /** Archive entry. */
  311.         public class EntryStream extends InputStream {

  313.             /** Name of the entry. */
  314.             private final String name;

  316.             /** Directory indicator. */
  317.             private boolean isDirectory;

  319.             /** Indicator for already closed stream. */
  320.             private boolean closed;

  322.             /** Simple constructor.
  323.              * @param name name of the entry
  324.              * @param isDirectory if true, the entry is a directory
  325.              */
  326.             public EntryStream(final String name, final boolean isDirectory) {
  327.                 this.name        = name;
  328.                 this.isDirectory = isDirectory;
  329.                 this.closed      = false;
  330.             }

  332.             /** Get the name of the entry.
  333.              * @return name of the entry
  334.              */
  335.             public String getName() {
  336.                 return name;
  337.             }

  339.             /** Check if the entry is a directory.
  340.              * @return true if the entry is a directory
  341.              */
  342.             public boolean isDirectory() {
  343.                 return isDirectory;
  344.             }

  346.             /** {@inheritDoc} */
  347.             @Override
  348.             public int read() throws IOException {
  349.                 // delegate read to global input stream
  350.                 return zip.read();
  351.             }

  353.             /** {@inheritDoc} */
  354.             @Override
  355.             public void close() throws IOException {
  356.                 if (!closed) {
  357.                     zip.closeEntry();
  358.                     goToNext();
  359.                     closed = true;
  360.                 }
  361.             }

  363.         }

  365.     }

  367. }
Created with JaCoCo 0.6.3.201306030806