FileLocator: better handling of locators routines - zip-file recognition - ZipStreamProvider

Author: pavly-gerges

snaploader/src/main/java/electrostatic4j/snaploader/filesystem/FileLocator.java

@@ -34,7 +34,6 @@
 
 import electrostatic4j.snaploader.throwable.FilesystemResourceInitializationException;
 import electrostatic4j.snaploader.util.SnapLoaderLogger;
-
 import java.io.*;
 import java.util.logging.Level;
 import java.util.zip.ZipEntry;
@@ -46,7 +45,7 @@
  * 
  * @author pavl_g
  */
-public class FileLocator implements InputStreamProvider {
+public class FileLocator implements ZipStreamProvider {
 
     /**
      * The input stream associated with the located filesystem.
@@ -59,27 +58,39 @@ public class FileLocator implements InputStreamProvider {
      */
     protected FileLocalizingListener fileLocalizingListener;
 
-    protected String directory;
+    protected ZipFile compression;
+
+    protected String compressionPath;
 
     protected String filePath;
 
     protected ZipCompressionType compressionType;
 
+    /**
+     * Locates the library inside the stock jar filesystem.
+     * This object leaks an input stream.
+     *
+     * @param filePath the path to the dynamic native library inside that jar filesystem
+     */
+    public FileLocator(String filePath) {
+        this.filePath = filePath;
+    }
+
     /**
      * Locates a filesystem inside an external zip compression, the zip filesystem is defined as a {@link ZipFile} object and
      * the locatable filesystem is defined as a {@link ZipEntry} object.
      * <p>
      * Warning: This object leaks a buffered stream, either use try-with-resources, or handle your
      * memory manually!
      * 
-     * @param directory the absolute path for the external jar filesystem
+     * @param compressionPath the absolute path for the external jar filesystem
      * @param filePath the path to the filesystem to be extracted
      * @param compressionType the type of the zip compression, ZIP or JAR
      * 
      * @throws IOException if the jar to be located is not found or an interrupted I/O exception has occured
      */
-    public FileLocator(String directory, String filePath, ZipCompressionType compressionType) throws IOException {
-        this.directory = directory;
+    public FileLocator(String compressionPath, String filePath, ZipCompressionType compressionType) throws IOException {
+        this.compressionPath = compressionPath;
         this.filePath = filePath;
         this.compressionType = compressionType;
     }
@@ -94,53 +105,54 @@ protected FileLocator() {
     @Override
     public void initialize(int size) throws IOException {
         // 1) sanity-check for double initializing
-        // 2) sanity-check for pre-initialization using other routines
-        // (e.g., classpath resources stream).
         if (this.fileInputStream != null) {
             SnapLoaderLogger.log(Level.INFO, getClass().getName(), "initialize(int)",
                     "File locator already initialized using external routines with hash key #" + getHashKey());
             return;
         }
         try {
-            final ZipFile compression = compressionType.createNewCompressionObject(directory);
-            final ZipEntry zipEntry = compression.getEntry(filePath);
-            validateFileLocalization(zipEntry);
-            if (size > 0) {
-                this.fileInputStream = new BufferedInputStream(compression.getInputStream(zipEntry), size);
-                SnapLoaderLogger.log(Level.INFO, getClass().getName(), "initialize(int)",
-                        "File locator initialized with hash key #" + getHashKey());
-                return;
+
+            // 2) sanity-check for initialization routines
+            // (e.g., classpath resources stream v.s. external compression).
+            if (compressionPath == null || compressionType == null) {
+                classPathRoutine();
+            } else {
+                externalCompressionRoutine(size);
+            }
+
+            // fire the success listener if the file localization has passed!
+            if (fileLocalizingListener != null) {
+                fileLocalizingListener.onFileLocalizationSuccess(this);
             }
-            this.fileInputStream = compression.getInputStream(zipEntry);
-            SnapLoaderLogger.log(Level.INFO, getClass().getName(), "initialize(int)",
-                    "File locator initialized with hash key #" + getHashKey());
         } catch (Exception e) {
             close();
-            throw new FilesystemResourceInitializationException(
+            final FilesystemResourceInitializationException exception = new FilesystemResourceInitializationException(
                     "Failed to initialize the file locator handler #" + getHashKey(), e);
+            // fire the failure listener when file localization fails and pass
+            // the causative exception
+            if (fileLocalizingListener != null) {
+                fileLocalizingListener.onFileLocalizationFailure(this, exception);
+            }
+            throw exception;
         }
     }
 
-    /**
-     * Validates the file localization process inside the compression.
-     *
-     * @throws FileNotFoundException if the localization of the file inside
-     *                               the specified compression has failed.
-     */
-    protected void validateFileLocalization(final ZipEntry zipEntry) throws FileNotFoundException {
-        if (zipEntry != null) {
-            if (fileLocalizingListener != null) {
-                fileLocalizingListener.onFileLocalizationSuccess(this);
-            }
-        } else {
-            final FileNotFoundException fileNotFoundException =
-                    new FileNotFoundException("File locator has failed to locate the file inside the compression!");
+    protected void classPathRoutine() {
+        SnapLoaderLogger.log(Level.INFO, getClass().getName(), "initialize(int)",
+                "File locator initialized using classpath routine with hash key #" + getHashKey());
+        this.fileInputStream = getClass().getResourceAsStream(filePath);
+    }
 
-            if (fileLocalizingListener != null) {
-                fileLocalizingListener.onFileLocalizationFailure(this, fileNotFoundException);
-            }
-            throw fileNotFoundException;
+    protected void externalCompressionRoutine(int size) throws IOException {
+        this.compression = compressionType.createNewCompressionObject(compressionPath);
+        final ZipEntry zipEntry = compression.getEntry(filePath);
+        if (size > 0) {
+            this.fileInputStream = new BufferedInputStream(compression.getInputStream(zipEntry), size);
+        } else {
+            this.fileInputStream = compression.getInputStream(zipEntry);
         }
+        SnapLoaderLogger.log(Level.INFO, getClass().getName(), "initialize(int)",
+                "File locator initialized using external compression routine with hash key #" + getHashKey());
     }
 
     @Override
@@ -150,10 +162,24 @@ public InputStream getFileInputStream() {
 
     @Override
     public void close() throws IOException {
+        // this is executed in all routines
+        // it updates the CleanableResource object
+        // for the Compression Routines
         if (fileInputStream != null) {
             fileInputStream.close();
             fileInputStream = null;
         }
+
+        // this will be bypassed in the case of using other non-compression routines to
+        // initialize the file streams (e.g., the classpath routines).
+        if (compression != null) {
+            // this closes all the streams associated with it (if they are not closed)
+            // aka.
+            // the file entries stream
+            // and the native resources for this object
+            compression.close();
+            compression = null;
+        }
         SnapLoaderLogger.log(Level.INFO, getClass().getName(),
                 "close", "File locator #" + getHashKey() + " resources closed!");
     }
@@ -162,4 +188,9 @@ public void close() throws IOException {
     public void setFileLocalizingListener(FileLocalizingListener fileLocalizingListener) {
         this.fileLocalizingListener = fileLocalizingListener;
     }
+
+    @Override
+    public ZipFile getCompression() {
+        return compression;
+    }
 }