[MRESOLVER-700] Bundle transport: read support (#685)

This PR slightly improves the file transport to fully utilize FileSystem, which now can be ZipFileSystem as well. The "old" part remains unchanged.

For factory just added `bundle:` prefix, that now may be in form `bundle:fileUri`, where `fileUri` is basically a path of a ZIP file that must exist. The ZIP file is read only.

The point of this PR is that user can now use a "bundle" (see https://central.sonatype.org/publish/publish-portal-upload/) just like we did before with staging repositories. Various tools (njord?) can produce bundles. The ZIP file is "mounted" and artifacts from it becomes reachable to Maven just like from any remote repository.

---

https://issues.apache.org/jira/browse/MRESOLVER-700

Author: cstamas

maven-resolver-transport-file/README.md

@@ -0,0 +1,27 @@
+<!---
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+# File transport
+
+This transport uses Java NIO2 `java.nio.file.FileSystem` to implement "remote storage". It is usable in variety of
+use cases, from plain local directory to much more.
+
+Valid file URLs:
+* as before (unchanged)
+
+Valid bundle URLs:
+* `bundle:file.zip` - should point to an existing ZIP file

maven-resolver-transport-file/src/main/java/org/eclipse/aether/transport/file/FileTransporter.java

@@ -18,8 +18,11 @@
  */
 package org.eclipse.aether.transport.file;
 
+import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
+import java.nio.file.FileSystem;
 import java.nio.file.Files;
 import java.nio.file.Path;
 
@@ -28,29 +31,55 @@
 import org.eclipse.aether.spi.connector.transport.PeekTask;
 import org.eclipse.aether.spi.connector.transport.PutTask;
 import org.eclipse.aether.spi.connector.transport.TransportTask;
-import org.eclipse.aether.transfer.NoTransporterException;
+
+import static java.util.Objects.requireNonNull;
 
 /**
- * A transporter using {@link java.io.File}.
+ * A transporter using {@link java.nio.file.Path} that is reading and writing from specified base directory
+ * of given {@link java.nio.file.FileSystem}. It supports multiple {@link WriteOp} and obeys read-only property.
  */
 final class FileTransporter extends AbstractTransporter {
     /**
-     * The file op transport can use.
+     * The write operation transport can use to write contents to the target (usually in local repository) of the
+     * file in remote repository reached by this transporter. Historically, and in some special cases (ZIP file system),
+     * it is only {@link #COPY} that can be used.
+     * <p>
+     * In case when contents of remote repository reached by this transport and target are on same volume,
+     * then {@link #SYMLINK} and {@link #HARDLINK} can be used as well, to reduce storage redundancy. Still, Resolver
+     * cannot do much smartness here, it is user who should evaluate this possibility, and if all conditions are met,
+     * apply it. Resolver does not try play smart here, it will obey configuration and most probably fail (ie cross
+     * volume hardlink).
      *
      * @since 2.0.2
      */
-    enum FileOp {
+    enum WriteOp {
         COPY,
         SYMLINK,
         HARDLINK;
     }
 
+    private final FileSystem fileSystem;
+    private final boolean closeFileSystem;
+    private final boolean writableFileSystem;
     private final Path basePath;
-    private final FileOp fileOp;
+    private final WriteOp writeOp;
+
+    FileTransporter(
+            FileSystem fileSystem,
+            boolean closeFileSystem,
+            boolean writableFileSystem,
+            Path basePath,
+            WriteOp writeOp) {
+        this.fileSystem = requireNonNull(fileSystem);
+        this.closeFileSystem = closeFileSystem;
+        this.writableFileSystem = writableFileSystem;
+        this.basePath = requireNonNull(basePath);
+        this.writeOp = requireNonNull(writeOp);
 
-    FileTransporter(Path basePath, FileOp fileOp) throws NoTransporterException {
-        this.basePath = basePath;
-        this.fileOp = fileOp;
+        // sanity check
+        if (basePath.getFileSystem() != fileSystem) {
+            throw new IllegalArgumentException("basePath must originate from the fileSystem");
+        }
     }
 
     Path getBasePath() {
@@ -65,12 +94,12 @@ public int classify(Throwable error) {
         return ERROR_OTHER;
     }
 
-    private FileOp effectiveFileOp(FileOp wanted, GetTask task) {
+    private WriteOp effectiveFileOp(WriteOp wanted, GetTask task) {
         if (task.getDataPath() != null) {
             return wanted;
         }
-        // task carries no path, caller wants in-memory read, so COPY must be used
-        return FileOp.COPY;
+        // not default FS or task carries no path (caller wants in-memory read) = COPY must be used
+        return WriteOp.COPY;
     }
 
     @Override
@@ -82,7 +111,7 @@ protected void implPeek(PeekTask task) throws Exception {
     protected void implGet(GetTask task) throws Exception {
         Path path = getPath(task, true);
         long size = Files.size(path);
-        FileOp effective = effectiveFileOp(fileOp, task);
+        WriteOp effective = effectiveFileOp(writeOp, task);
         switch (effective) {
             case COPY:
                 utilGet(task, Files.newInputStream(path), true, size, false);
@@ -91,7 +120,7 @@ protected void implGet(GetTask task) throws Exception {
             case HARDLINK:
                 Files.deleteIfExists(task.getDataPath());
                 task.getListener().transportStarted(0L, size);
-                if (effective == FileOp.HARDLINK) {
+                if (effective == WriteOp.HARDLINK) {
                     Files.createLink(task.getDataPath(), path);
                 } else {
                     Files.createSymbolicLink(task.getDataPath(), path);
@@ -113,12 +142,15 @@ protected void implGet(GetTask task) throws Exception {
                 }
                 break;
             default:
-                throw new IllegalStateException("Unknown fileOp" + fileOp);
+                throw new IllegalStateException("Unknown fileOp " + writeOp);
         }
     }
 
     @Override
     protected void implPut(PutTask task) throws Exception {
+        if (!writableFileSystem) {
+            throw new UnsupportedOperationException("Read only FileSystem");
+        }
         Path path = getPath(task, false);
         Files.createDirectories(path.getParent());
         try {
@@ -142,5 +174,13 @@ private Path getPath(TransportTask task, boolean required) throws Exception {
     }
 
     @Override
-    protected void implClose() {}
+    protected void implClose() {
+        if (closeFileSystem) {
+            try {
+                fileSystem.close();
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+    }
 }

maven-resolver-transport-file/src/main/java/org/eclipse/aether/transport/file/FileTransporterFactory.java

@@ -20,8 +20,16 @@
 
 import javax.inject.Named;
 
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.net.URI;
+import java.nio.file.FileSystem;
 import java.nio.file.FileSystemNotFoundException;
+import java.nio.file.FileSystems;
+import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.eclipse.aether.RepositorySystemSession;
 import org.eclipse.aether.repository.RemoteRepository;
@@ -33,23 +41,14 @@
 import static java.util.Objects.requireNonNull;
 
 /**
- * A transporter factory for repositories using the {@code file:} protocol.
+ * A transporter factory for repositories using the {@code file:} or {@code bundle:} protocol.
  */
 @Named(FileTransporterFactory.NAME)
 public final class FileTransporterFactory implements TransporterFactory {
     public static final String NAME = "file";
 
     private float priority;
 
-    /**
-     * Creates an (uninitialized) instance of this transporter factory. <em>Note:</em> In case of manual instantiation
-     * by clients, the new factory needs to be configured via its various mutators before first use or runtime errors
-     * will occur.
-     */
-    public FileTransporterFactory() {
-        // enables default constructor
-    }
-
     @Override
     public float getPriority() {
         return priority;
@@ -66,28 +65,61 @@ public FileTransporterFactory setPriority(float priority) {
         return this;
     }
 
+    /**
+     * Creates new instance of {@link FileTransporter}.
+     *
+     * @param session The session.
+     * @param repository The remote repository.
+     */
     @Override
     public Transporter newInstance(RepositorySystemSession session, RemoteRepository repository)
             throws NoTransporterException {
         requireNonNull(session, "session cannot be null");
         requireNonNull(repository, "repository cannot be null");
 
-        // special case in file transport: to support custom FS providers (like JIMFS), we cannot
-        // cover "all possible protocols" to throw NoTransporterEx, but we rely on FS rejecting the URI
-        FileTransporter.FileOp fileOp = FileTransporter.FileOp.COPY;
         String repositoryUrl = repository.getUrl();
-        if (repositoryUrl.startsWith("symlink+")) {
-            fileOp = FileTransporter.FileOp.SYMLINK;
-            repositoryUrl = repositoryUrl.substring("symlink+".length());
-        } else if (repositoryUrl.startsWith("hardlink+")) {
-            fileOp = FileTransporter.FileOp.HARDLINK;
-            repositoryUrl = repositoryUrl.substring("hardlink+".length());
-        }
-        try {
-            return new FileTransporter(
-                    Paths.get(RepositoryUriUtils.toUri(repositoryUrl)).toAbsolutePath(), fileOp);
-        } catch (FileSystemNotFoundException | IllegalArgumentException e) {
-            throw new NoTransporterException(repository, e);
+        if (repositoryUrl.startsWith("bundle:")) {
+            try {
+                repositoryUrl = repositoryUrl.substring("bundle:".length());
+                URI bundlePath = URI.create("jar:"
+                        + Paths.get(RepositoryUriUtils.toUri(repositoryUrl))
+                                .toAbsolutePath()
+                                .toUri()
+                                .toASCIIString());
+                Map<String, String> env = new HashMap<>();
+                FileSystem fileSystem = FileSystems.newFileSystem(bundlePath, env);
+                return new FileTransporter(
+                        fileSystem,
+                        true,
+                        false,
+                        fileSystem.getPath(fileSystem.getSeparator()),
+                        FileTransporter.WriteOp.COPY);
+            } catch (IOException e) {
+                throw new UncheckedIOException(e); // hard failure; most probably user error (ie wrong path or perm)
+            }
+        } else {
+            // special case in file: transport: to support custom FS providers (like JIMFS), we cannot
+            // cover all possible protocols (to throw NoTransporterEx), hence we rely on FS rejecting the URI
+            FileTransporter.WriteOp writeOp = FileTransporter.WriteOp.COPY;
+            if (repositoryUrl.startsWith("symlink+")) {
+                writeOp = FileTransporter.WriteOp.SYMLINK;
+                repositoryUrl = repositoryUrl.substring("symlink+".length());
+            } else if (repositoryUrl.startsWith("hardlink+")) {
+                writeOp = FileTransporter.WriteOp.HARDLINK;
+                repositoryUrl = repositoryUrl.substring("hardlink+".length());
+            }
+            try {
+                Path basePath =
+                        Paths.get(RepositoryUriUtils.toUri(repositoryUrl)).toAbsolutePath();
+                return new FileTransporter(
+                        basePath.getFileSystem(),
+                        false,
+                        !basePath.getFileSystem().isReadOnly(),
+                        basePath,
+                        writeOp);
+            } catch (FileSystemNotFoundException | IllegalArgumentException e) {
+                throw new NoTransporterException(repository, e);
+            }
         }
     }
 }

maven-resolver-transport-file/src/main/java/org/eclipse/aether/transport/file/package-info.java

@@ -18,6 +18,6 @@
  * under the License.
  */
 /**
- * Support for downloads/uploads using the local filesystem as "remote" storage.
+ * Support for downloads/uploads using the Java NIO2 filesystem as "remote" storage.
  */
 package org.eclipse.aether.transport.file;