Introduce option to treat cache dir as exact path

Author: geoand

vertx-core/src/main/generated/io/vertx/core/file/FileSystemOptionsConverter.java

@@ -27,6 +27,11 @@ static void fromJson(Iterable<java.util.Map.Entry<String, Object>> json, FileSys
             obj.setFileCacheDir((String)member.getValue());
           }
           break;
+        case "fileCacheDirAsExactPath":
+          if (member.getValue() instanceof Boolean) {
+            obj.setFileCacheDirAsExactPath((Boolean)member.getValue());
+          }
+          break;
       }
     }
   }
@@ -41,5 +46,6 @@ static void toJson(FileSystemOptions obj, java.util.Map<String, Object> json) {
     if (obj.getFileCacheDir() != null) {
       json.put("fileCacheDir", obj.getFileCacheDir());
     }
+    json.put("fileCacheDirAsExactPath", obj.isFileCacheDirAsExactPath());
   }
 }

vertx-core/src/main/java/io/vertx/core/file/FileSystemOptions.java

@@ -45,9 +45,15 @@ public class FileSystemOptions {
    */
   public static final String DEFAULT_FILE_CACHING_DIR = SysProps.FILE_CACHE_DIR.get();
 
+  /**
+   * The default value for using file cache dir as exact path = {@code false}
+   */
+  public static final boolean DEFAULT_FILE_CACHE_DIR_AS_EXACT_PATH = false;
+
   private boolean classPathResolvingEnabled = DEFAULT_CLASS_PATH_RESOLVING_ENABLED;
   private boolean fileCachingEnabled = DEFAULT_FILE_CACHING_ENABLED;
   private String fileCacheDir = DEFAULT_FILE_CACHING_DIR;
+  private boolean fileCacheDirAsExactPath = DEFAULT_FILE_CACHE_DIR_AS_EXACT_PATH;
 
   /**
    * Default constructor
@@ -64,6 +70,7 @@ public FileSystemOptions(FileSystemOptions other) {
     this.classPathResolvingEnabled = other.isClassPathResolvingEnabled();
     this.fileCachingEnabled = other.isFileCachingEnabled();
     this.fileCacheDir = other.getFileCacheDir();
+    this.fileCacheDirAsExactPath = other.isFileCacheDirAsExactPath();
   }
 
   /**
@@ -147,13 +154,35 @@ public FileSystemOptions setFileCacheDir(String fileCacheDir) {
     return this;
   }
 
+  /**
+   * @return whether the file cache dir should be used as an exact path
+   */
+  public boolean isFileCacheDirAsExactPath() {
+    return this.fileCacheDirAsExactPath;
+  }
+
+  /**
+   * Set to {@code true} to use the configured file cache dir as an exact path.
+   * When {@code false} (the default), a unique subdirectory is created under the
+   * file cache dir. When {@code true} and the directory already exists, a suffix
+   * like "-2", "-3", etc. is appended to guarantee uniqueness.
+   *
+   * @param fileCacheDirAsExactPath the value
+   * @return a reference to this, so the API can be used fluently
+   */
+  public FileSystemOptions setFileCacheDirAsExactPath(boolean fileCacheDirAsExactPath) {
+    this.fileCacheDirAsExactPath = fileCacheDirAsExactPath;
+    return this;
+  }
+
 
   @Override
   public String toString() {
     return "FileSystemOptions{" +
     "classPathResolvingEnabled=" + classPathResolvingEnabled +
     ", fileCachingEnabled=" + fileCachingEnabled +
     ", fileCacheDir=" + fileCacheDir +
+    ", fileCacheDirAsExactPath=" + fileCacheDirAsExactPath +
     '}';
   }
 }

vertx-core/src/main/java/io/vertx/core/file/impl/FileCache.java

@@ -27,8 +27,8 @@
 
 public class FileCache {
 
-  static FileCache setupCache(String fileCacheDir) {
-    FileCache cache = new FileCache(setupCacheDir(fileCacheDir));
+  static FileCache setupCache(String fileCacheDir, boolean useExactPath) {
+    FileCache cache = new FileCache(setupCacheDir(fileCacheDir, useExactPath));
     // Add shutdown hook to delete on exit
     cache.registerShutdownHook();
     return cache;
@@ -37,15 +37,21 @@ static FileCache setupCache(String fileCacheDir) {
   /**
    * Prepares the cache directory to be used in the application.
    */
-  static File setupCacheDir(String fileCacheDir) {
+  static File setupCacheDir(String fileCacheDir, boolean useExactPath) {
     // ensure that the argument doesn't end with separator
     if (fileCacheDir.endsWith(File.separator)) {
       fileCacheDir = fileCacheDir.substring(0, fileCacheDir.length() - File.separator.length());
     }
 
-    // the cacheDir will be suffixed a unique id to avoid eavesdropping from other processes/users
-    // also this ensures that if process A deletes cacheDir, it won't affect process B
-    String cacheDirName = fileCacheDir + "-" + UUID.randomUUID();
+    String cacheDirName;
+    if (useExactPath) {
+      // Use the path as-is, but if it exists, append a suffix to guarantee uniqueness
+      cacheDirName = findUniqueDir(fileCacheDir);
+    } else {
+      // the cacheDir will be suffixed a unique id to avoid eavesdropping from other processes/users
+      // also this ensures that if process A deletes cacheDir, it won't affect process B
+      cacheDirName = fileCacheDir + "-" + UUID.randomUUID();
+    }
     File cacheDir = new File(cacheDirName);
     // Create the cache directory
     try {
@@ -63,6 +69,27 @@ static File setupCacheDir(String fileCacheDir) {
     return cacheDir;
   }
 
+  /**
+   * Find a unique directory path. If the base path doesn't exist, return it.
+   * If it exists, append "-2", "-3", etc. until a non-existing path is found.
+   */
+  private static String findUniqueDir(String basePath) {
+    File baseDir = new File(basePath);
+    if (!baseDir.exists()) {
+      return basePath;
+    }
+    // Directory exists, find a unique suffix
+    int suffix = 2;
+    while (true) {
+      String candidatePath = basePath + "-" + suffix;
+      File candidate = new File(candidatePath);
+      if (!candidate.exists()) {
+        return candidatePath;
+      }
+      suffix++;
+    }
+  }
+
   private Thread shutdownHook;
   private File cacheDir;
 

vertx-core/src/main/java/io/vertx/core/file/impl/FileResolverImpl.java

@@ -68,7 +68,7 @@ public FileResolverImpl(FileSystemOptions fileSystemOptions) {
     enableCPResolving = fileSystemOptions.isClassPathResolvingEnabled();
 
     if (enableCPResolving) {
-      cache = FileCache.setupCache(fileSystemOptions.getFileCacheDir());
+      cache = FileCache.setupCache(fileSystemOptions.getFileCacheDir(), fileSystemOptions.isFileCacheDirAsExactPath());
     } else {
       cache = null;
     }

vertx-core/src/test/java/io/vertx/tests/file/cachedir/ExactDirDoesNotExistTest.java

@@ -0,0 +1,41 @@
+package io.vertx.tests.file.cachedir;
+
+import io.vertx.core.VertxOptions;
+import io.vertx.core.file.FileSystemOptions;
+import io.vertx.core.internal.VertxInternal;
+import io.vertx.core.spi.file.FileResolver;
+import io.vertx.test.core.VertxTestBase;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ExactDirDoesNotExistTest extends VertxTestBase {
+
+  private final Path cacheBaseDir;
+
+  public ExactDirDoesNotExistTest() throws IOException {
+    cacheBaseDir = Files.createTempDirectory("cache-does-not-exist");
+    Files.deleteIfExists(cacheBaseDir);
+    Assert.assertFalse(Files.exists(cacheBaseDir));
+  }
+
+  @Override
+  protected VertxOptions getOptions() {
+    return new VertxOptions(super.getOptions())
+      .setFileSystemOptions(new FileSystemOptions()
+        .setFileCachingEnabled(true)
+        .setFileCacheDir(cacheBaseDir.toAbsolutePath().toString())
+        .setFileCacheDirAsExactPath(true));
+  }
+
+  @Test
+  public void test() throws IOException {
+    try (FileResolver fileResolver = ((VertxInternal) vertx).fileResolver()) {
+      File file = fileResolver.resolve("conf.json");
+      Assert.assertEquals(cacheBaseDir.resolve("conf.json").toFile().getCanonicalPath(), file.getCanonicalPath());
+    }
+  }
+}

vertx-core/src/test/java/io/vertx/tests/file/cachedir/ExactDirExistsTest.java

@@ -0,0 +1,46 @@
+package io.vertx.tests.file.cachedir;
+
+import io.vertx.core.VertxOptions;
+import io.vertx.core.file.FileSystemOptions;
+import io.vertx.core.internal.VertxInternal;
+import io.vertx.core.spi.file.FileResolver;
+import io.vertx.test.core.VertxTestBase;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ExactDirExistsTest extends VertxTestBase {
+
+  private final Path cacheBaseDir;
+
+  public ExactDirExistsTest() throws IOException {
+    cacheBaseDir = Paths.get(System.getProperty("java.io.tmpdir", "."), "cache-exists");
+    Files.deleteIfExists(cacheBaseDir);
+    Files.createDirectories(cacheBaseDir);
+    Assert.assertTrue(Files.exists(cacheBaseDir));
+    Assert.assertTrue(Files.isDirectory(cacheBaseDir));
+  }
+
+  @Override
+  protected VertxOptions getOptions() {
+    return new VertxOptions(super.getOptions())
+      .setFileSystemOptions(new FileSystemOptions()
+        .setFileCachingEnabled(true)
+        .setFileCacheDir(cacheBaseDir.toAbsolutePath().toString())
+        .setFileCacheDirAsExactPath(true));
+  }
+
+  @Test
+  public void test() throws IOException {
+    try (FileResolver fileResolver = ((VertxInternal) vertx).fileResolver()) {
+      File file = fileResolver.resolve("conf.json");
+      // When exact path is used and dir exists, a suffix is appended
+      String resolvedDir = file.getCanonicalFile().getParent();
+      Assert.assertTrue(resolvedDir.startsWith(cacheBaseDir.toFile().getCanonicalPath()));
+    }
+  }
+}