MCR-3126 try to reduce usage of toPhysicalPath

Author: Mewel

mycore-ocfl/src/main/java/org/mycore/ocfl/niofs/MCROCFLFileTypeDetector.java

@@ -61,8 +61,7 @@ public String probeContentType(Path path) throws IOException {
         if (virtualObject == null) {
             throw new NoSuchFileException(path.toString());
         }
-        Path physicalPath = virtualObject.toPhysicalPath(versionedPath);
-        return Files.probeContentType(physicalPath);
+        return virtualObject.probeContentType(versionedPath);
     }
 
 }

mycore-ocfl/src/main/java/org/mycore/ocfl/niofs/MCROCFLLocalVirtualObject.java

@@ -53,7 +53,6 @@
  * It handles file operations such as copying, moving, and deleting files within the local file system,
  * and ensures consistency with the OCFL repository. This class also manages local modifications and
  * synchronizes changes with the OCFL repository.
- * </p>
  */
 public class MCROCFLLocalVirtualObject extends MCROCFLVirtualObject {
 
@@ -111,40 +110,46 @@ public void copy(MCRVersionedPath source, MCRVersionedPath target, CopyOption...
         MCRVersionedPath lockedTarget = lockVersion(target);
         checkPurged(lockedSource);
         checkReadOnly();
-        boolean targetExists = exists(lockedTarget);
         if (this.localStorage.exists(lockedSource)) {
             this.localStorage.copy(lockedSource, lockedTarget, options);
         } else {
-            Path localSourcePath = toPhysicalPath(lockedSource);
+            Path localSourcePath = toPhysicalOcflPath(lockedSource);
             try (InputStream inputStream = Files.newInputStream(localSourcePath)) {
                 this.localStorage.copy(inputStream, lockedTarget, options);
             }
         }
+        boolean targetExists = exists(lockedTarget);
         trackFileWrite(lockedTarget, targetExists ? MCREvent.EventType.UPDATE : MCREvent.EventType.CREATE);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public void externalCopy(MCROCFLVirtualObject virtualTarget, MCRVersionedPath source,
-        MCRVersionedPath target, CopyOption... options) throws IOException {
+    public void externalCopy(MCROCFLVirtualObject virtualTarget, MCRVersionedPath source, MCRVersionedPath target,
+        CopyOption... options) throws IOException {
         MCRVersionedPath lockedSource = lockVersion(source);
         checkPurged(lockedSource);
         virtualTarget.checkReadOnly();
-        boolean targetExists = virtualTarget.exists(target);
-        Path localSourcePath = toPhysicalPath(lockedSource);
-        try (InputStream is = Files.newInputStream(localSourcePath)) {
-            this.localStorage.copy(is, target, options);
+        if (this.localStorage.exists(lockedSource)) {
+            this.localStorage.copy(lockedSource, target, options);
+        } else {
+            Path localOcflPath = toPhysicalOcflPath(lockedSource);
+            try (InputStream is = Files.newInputStream(localOcflPath)) {
+                this.localStorage.copy(is, target, options);
+            }
         }
+        boolean targetExists = virtualTarget.exists(target);
         virtualTarget.trackFileWrite(target, targetExists ? MCREvent.EventType.UPDATE : MCREvent.EventType.CREATE);
     }
 
     @Override
     protected SeekableByteChannel readByteChannel(MCRVersionedPath path, Set<? extends OpenOption> options,
         FileAttribute<?>... fileAttributes) throws IOException {
-        return this.localStorage.exists(path) ? this.localStorage.newByteChannel(path, options, fileAttributes)
-            : Files.newByteChannel(toPhysicalPath(path), options, fileAttributes);
+        if (this.localStorage.exists(path)) {
+            return this.localStorage.newByteChannel(path, options, fileAttributes);
+        }
+        return Files.newByteChannel(toPhysicalOcflPath(path), options, fileAttributes);
     }
 
     @Override
@@ -173,18 +178,38 @@ protected SeekableByteChannel writeByteChannel(MCRVersionedPath path, Set<? exte
     public FileTime getModifiedTime(MCRVersionedPath path) throws IOException {
         MCRVersionedPath lockedPath = lockVersion(path);
         checkExists(lockedPath);
-        Path physicalPath = toPhysicalPath(lockedPath);
+        if (this.localStorage.exists(lockedPath)) {
+            return this.localStorage.readAttributes(lockedPath, BasicFileAttributes.class).lastModifiedTime();
+        }
+        Path physicalPath = toPhysicalOcflPath(lockedPath);
         return Files.readAttributes(physicalPath, BasicFileAttributes.class).lastModifiedTime();
     }
 
     @Override
     public FileTime getAccessTime(MCRVersionedPath path) throws IOException {
         MCRVersionedPath lockedPath = lockVersion(path);
         checkExists(lockedPath);
-        Path physicalPath = toPhysicalPath(lockedPath);
+        if (this.localStorage.exists(lockedPath)) {
+            return this.localStorage.readAttributes(lockedPath, BasicFileAttributes.class).lastAccessTime();
+        }
+        Path physicalPath = toPhysicalOcflPath(lockedPath);
         return Files.readAttributes(physicalPath, BasicFileAttributes.class).lastAccessTime();
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Object getFileKey(MCRVersionedPath path) throws IOException {
+        MCRVersionedPath lockedPath = lockVersion(path);
+        checkExists(lockedPath);
+        if (this.localStorage.exists(lockedPath)) {
+            return this.localStorage.readAttributes(lockedPath, BasicFileAttributes.class).fileKey();
+        }
+        Path physicalPath = toPhysicalOcflPath(lockedPath);
+        return Files.readAttributes(physicalPath, BasicFileAttributes.class).fileKey();
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -195,6 +220,11 @@ public Path toPhysicalPath(MCRVersionedPath path) throws IOException {
         if (this.localStorage.exists(lockedPath)) {
             return this.localStorage.toPhysicalPath(lockedPath);
         }
+        return toPhysicalOcflPath(path);
+    }
+
+    private Path toPhysicalOcflPath(MCRVersionedPath path) throws IOException {
+        MCRVersionedPath lockedPath = lockVersion(path);
         FileChangeHistory changeHistory = getChangeHistory(lockedPath);
         String storageRelativePath = changeHistory.getMostRecent().getStorageRelativePath();
         return getLocalRepositoryPath().resolve(storageRelativePath);

mycore-ocfl/src/main/java/org/mycore/ocfl/niofs/MCROCFLRemoteVirtualObject.java

@@ -157,8 +157,7 @@ public FileTime getModifiedTime(MCRVersionedPath path) throws IOException {
         MCRVersionedPath lockedPath = lockVersion(path);
         checkExists(lockedPath);
         if (this.localStorage.exists(lockedPath)) {
-            Path physicalPath = this.localStorage.toPhysicalPath(lockedPath);
-            return Files.readAttributes(physicalPath, BasicFileAttributes.class).lastModifiedTime();
+            return this.localStorage.readAttributes(lockedPath, BasicFileAttributes.class).lastModifiedTime();
         }
         FileChangeHistory changeHistory = getChangeHistory(lockedPath);
         return FileTime.from(changeHistory.getMostRecent().getTimestamp().toInstant());
@@ -172,8 +171,7 @@ public FileTime getAccessTime(MCRVersionedPath path) throws IOException {
         MCRVersionedPath lockedPath = lockVersion(path);
         checkExists(lockedPath);
         if (this.localStorage.exists(lockedPath)) {
-            Path physicalPath = this.localStorage.toPhysicalPath(lockedPath);
-            return Files.readAttributes(physicalPath, BasicFileAttributes.class).lastAccessTime();
+            return this.localStorage.readAttributes(lockedPath, BasicFileAttributes.class).lastAccessTime();
         }
         FileChangeHistory changeHistory = getChangeHistory(lockedPath);
         return FileTime.from(changeHistory.getMostRecent().getTimestamp().toInstant());
@@ -211,17 +209,26 @@ public void externalCopy(MCROCFLVirtualObject virtualTarget, MCRVersionedPath so
 
     /**
      * {@inheritDoc}
-     * This implementation always creates a copy before returning the physical path, guaranteeing
-     * that the file exists in the local temporary storage.
      */
     @Override
-    public Path toPhysicalPath(MCRVersionedPath path) throws IOException {
+    protected Path toPhysicalPath(MCRVersionedPath path) throws IOException {
         MCRVersionedPath lockedPath = lockVersion(path);
         checkExists(lockedPath);
         localCopy(lockedPath);
         return this.localStorage.toPhysicalPath(lockedPath);
     }
 
+    /**
+     * {@inheritDoc}
+     * This implementation always creates a copy before returning the physical path, guaranteeing
+     * that the file exists in the local temporary storage.
+     */
+    @Override
+    public Object getFileKey(MCRVersionedPath path) throws IOException {
+        Path physicalPath = toPhysicalPath(path);
+        return Files.readAttributes(physicalPath, BasicFileAttributes.class).fileKey();
+    }
+
     /**
      * Creates a deep clone of this remote virtual object.
      *

mycore-ocfl/src/main/java/org/mycore/ocfl/niofs/MCROCFLVirtualObject.java

@@ -636,8 +636,7 @@ public FileTime getCreationTime(MCRVersionedPath path) throws IOException {
         boolean added = this.isAdded(lockedPath);
         boolean inLocalStorage = this.isLocal(lockedPath);
         if (added && inLocalStorage) {
-            Path physicalPath = this.localStorage.toPhysicalPath(lockedPath);
-            return Files.readAttributes(physicalPath, BasicFileAttributes.class).creationTime();
+            return this.localStorage.readAttributes(lockedPath, BasicFileAttributes.class).creationTime();
         }
         FileChangeHistory changeHistory = getChangeHistory(lockedPath);
         return FileTime.from(changeHistory.getOldest().getTimestamp().toInstant());
@@ -676,8 +675,7 @@ public long getSize(MCRVersionedPath path) throws IOException {
             return 0;
         }
         if (this.localStorage.exists(lockedPath)) {
-            Path physicalPath = this.localStorage.toPhysicalPath(lockedPath);
-            return Files.size(physicalPath);
+            return this.localStorage.size(lockedPath);
         }
         OcflObjectVersionFile ocflObjectVersionFile = fromOcfl(lockedPath);
         String sizeAsString = ocflObjectVersionFile.getFixity().get(new SizeDigestAlgorithm());
@@ -687,48 +685,56 @@ public long getSize(MCRVersionedPath path) throws IOException {
     /**
      * Returns the `filekey` of the given path.
      * <p>
-     *     Because OCFL is a version file system and the mycore implementation uses transactions this `filekey`
-     *     implementation differs from a Unix like system.
-     * </p>
+     * Because OCFL is a version file system and the mycore implementation uses transactions this `filekey`
+     * implementation differs from a Unix like system.
      * <p>
-     *     The Unix `filekey` is typically derived from the inode and device ID, ensuring uniqueness within the
-     *     filesystem. When a file is modified (written, moved...), the Unix `filekey` remains unchanged as long as the
-     *     inode remains the same.
-     * </p>
+     * The Unix `filekey` is typically derived from the inode and device ID, ensuring uniqueness within the
+     * filesystem. When a file is modified (written, moved...), the Unix `filekey` remains unchanged as long as the
+     * inode remains the same.
      * <p>
-     *     In contrast this implementation returns a new `filekey` as soon as a file is written or moved. The `filekey`
-     *     then remains constant as long as the transaction is open. After the transaction is committed the `filekey`
-     *     may change again.
-     * </p>
+     * In contrast, this implementation returns a new `filekey` as soon as a file is written or moved. The `filekey`
+     * then remains constant as long as the transaction is open. After the transaction is committed the `filekey`
+     * may change again.
      * <p>
-     *     Implementation detail: Be aware that this method calls {@link #toPhysicalPath(MCRVersionedPath)}. For remote
-     *     virtual objects this means that the whole file is copied to the local storage. Because the fileKey is not
-     *     accessed frequently this should be acceptable. If this assumption proves to be wrong a special implementation
-     *     for remote virtual objects is required!
-     * </p>
+     * Implementation detail: Be aware that for remote virtual objects the whole file is copied to the local
+     * storage. Because the fileKey is not accessed frequently this should be acceptable. If this assumption proves
+     * to be wrong a special implementation for remote virtual objects is required!
      *
      * @param path versioned path
      * @return fileKey
      * @throws IOException if an I/O error occurs.
      */
-    public Object getFileKey(MCRVersionedPath path) throws IOException {
+    public abstract Object getFileKey(MCRVersionedPath path) throws IOException;
+
+    /**
+     * Identifies the MIME type of a give path.
+     * <p>
+     * Implementation detail: Be aware that for remote virtual objects the whole file is copied to the local
+     * storage. Because the MIME type is not accessed frequently this should be acceptable. If this assumption proves
+     * to be wrong a special implementation for remote virtual objects is required! 
+     *
+     * @param path versioned path
+     * @return the mime type
+     * @throws IOException  if an I/O error occurs.
+     */
+    public String probeContentType(MCRVersionedPath path) throws IOException {
         MCRVersionedPath lockedPath = lockVersion(path);
-        Path physicalPath = toPhysicalPath(lockedPath);
-        return Files.readAttributes(physicalPath, BasicFileAttributes.class).fileKey();
+        checkExists(lockedPath);
+        return Files.probeContentType(toPhysicalPath(lockedPath));
     }
 
     /**
      * Converts the specified versioned path to a local file system path. The path can either point at the local
      * temporary storage (if it exists) or at the original OCFL file or directory.
      * <p>
- *     Use the returned path ONLY for read operations. It's not allowed to write/move or remove the returned path.
+    *     Use the returned path ONLY for read operations. It's not allowed to write/move or remove the returned path.
      * Because this would create inconsistencies in the OCFL repository or the local storage.
      *
      * @param path the virtual path.
      * @return the physical path.
      * @throws IOException if an I/O error occurs.
      */
-    public abstract Path toPhysicalPath(MCRVersionedPath path) throws IOException;
+    protected abstract Path toPhysicalPath(MCRVersionedPath path) throws IOException;
 
     /**
      * Returns the change history of a path.
@@ -1001,7 +1007,7 @@ protected MCRVersionedPath lockVersion(MCRVersionedPath versionedPath) {
     }
 
     /**
-     * Releases the version on a given {@link MCRVersionedPath}, returning the path 
+     * Releases the version on a given {@link MCRVersionedPath}, returning the path
      * that points to the latest (head) version of the virtual object.
      * <p>
      * This is necessary for the mycore event system. Due to the fact that the metadata is not yet
@@ -1012,7 +1018,7 @@ protected MCRVersionedPath lockVersion(MCRVersionedPath versionedPath) {
      * TODO: This should be removed when the metadata is also included in the transaction system!
      *
      * @param versionedPath the {@link MCRVersionedPath} to release, retaining the same owner.
-     * @return a {@link MCRVersionedPath} that points to the head (latest) version of 
+     * @return a {@link MCRVersionedPath} that points to the head (latest) version of
      *         the path for the specified owner.
      */
     protected MCRVersionedPath releaseVersion(MCRVersionedPath versionedPath) {
@@ -1162,5 +1168,4 @@ protected MCRDigest calculateDigest(MCRVersionedPath path) {
             throw new UncheckedIOException("Unable to calculate digest for path '" + path + "'.", ioException);
         }
     }
-
 }

mycore-ocfl/src/main/java/org/mycore/ocfl/niofs/storage/MCROCFLRollingCacheStorage.java

@@ -91,6 +91,9 @@ public MCROCFLRollingCacheStorage(Path root, MCROCFLEvictionStrategy evictionStr
 
     private void init() throws IOException {
         final List<Path> toRemoveList = new ArrayList<>();
+        if (!Files.exists(root)) {
+            return;
+        }
         // update cache
         try (Stream<Path> pathStream = Files.walk(root)) {
             pathStream.filter(Files::isRegularFile)
@@ -108,7 +111,7 @@ private void init() throws IOException {
             try {
                 Files.delete(toRemove);
             } catch (IOException removeException) {
-                LOGGER.error(() -> "Unable to remove path " + toRemove + "from rolling cache.", removeException);
+                LOGGER.error(() -> "Unable to remove path " + toRemove + " from rolling cache.", removeException);
             }
         }
     }

mycore-ocfl/src/main/java/org/mycore/ocfl/niofs/storage/MCROCFLTempFileStorage.java

@@ -23,9 +23,11 @@
 import java.nio.channels.SeekableByteChannel;
 import java.nio.file.CopyOption;
 import java.nio.file.Files;
+import java.nio.file.LinkOption;
 import java.nio.file.OpenOption;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
+import java.nio.file.attribute.BasicFileAttributes;
 import java.nio.file.attribute.FileAttribute;
 import java.util.Set;
 
@@ -139,6 +141,32 @@ default void createDirectories(MCRVersionedPath directoryPath, FileAttribute<?>.
         Files.createDirectories(toPhysicalPath(directoryPath), attrs);
     }
 
+    /**
+     * Returns the size of a file (in bytes).
+     * 
+     * @param path the path to the file
+     * @return the size of a file in bytes
+     * @throws IOException if an I/O error occurs.
+     */
+    default long size(MCRVersionedPath path) throws IOException {
+        // TODO implement
+        return Files.size(toPhysicalPath(path));
+    }
+
+    /**
+     * Reads a file's attributes as a bulk operation.
+     *
+     * @param path the path to the file
+     * @param type the Class of the file attributes required to read
+     * @param options options indicating how symbolic links are handled
+     * @return the file attributes
+     * @throws IOException if an I/O error occurs.
+     */
+    default <A extends BasicFileAttributes> A readAttributes(MCRVersionedPath path, Class<A> type,
+        LinkOption... options) throws IOException {
+        return Files.readAttributes(toPhysicalPath(path), type, options);
+    }
+
     /**
      * Clears the storage by deleting all files and directories under the root path.
      *