cache: separate files per value, read from file on demand (#823)

Author: MykolaGolubyev

webtau-cache/pom.xml

@@ -64,6 +64,13 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.testingisdocumenting.webtau</groupId>
+            <artifactId>webtau-core-groovy</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.testingisdocumenting.webtau</groupId>
             <artifactId>webtau-core</artifactId>

webtau-cache/src/main/java/org/testingisdocumenting/webtau/cache/Cache.java

@@ -47,16 +47,12 @@ public <E> E get(String key) {
         return step.execute(StepReportOptions.SKIP_START);
     }
 
-    public void put(String key, Object value, long expirationTime) {
+    public void put(String key, Object value) {
         WebTauStep step = WebTauStep.createStep(null,
                 tokenizedMessage(action("caching value"), AS, id(key), COLON, stringValue(value)),
                 () -> tokenizedMessage(action("cached value"), AS, id(key), COLON, stringValue(value)),
-                () -> fileBasedCache.put(key, value, expirationTime));
+                () -> fileBasedCache.put(key, value));
 
         step.execute(StepReportOptions.SKIP_START);
     }
-
-    public void put(String key, Object value) {
-        put(key, value, Long.MAX_VALUE);
-    }
 }

webtau-cache/src/main/java/org/testingisdocumenting/webtau/cache/FileBasedCache.java

@@ -17,112 +17,50 @@
 
 package org.testingisdocumenting.webtau.cache;
 
-import org.testingisdocumenting.webtau.time.Time;
 import org.testingisdocumenting.webtau.utils.FileUtils;
 import org.testingisdocumenting.webtau.utils.JsonUtils;
 
+import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Supplier;
 
 class FileBasedCache {
-    private static final String VALUE_KEY = "value";
-    private static final String EXPIRATION_TIME_KEY = "expirationTime";
-
-    private final AtomicBoolean isCacheLoaded;
-
     private final Supplier<Path> cachePathSupplier;
-    private final AtomicLong lastPutTime;
-
-    private final Map<String, Object> loadedCache;
 
+    /**
+     * @param cachePathSupplier path supplier, used instead of a direct value to avoid config trigger load
+     */
     public FileBasedCache(Supplier<Path> cachePathSupplier) {
         this.cachePathSupplier = cachePathSupplier;
-        this.isCacheLoaded = new AtomicBoolean(false);
-        this.lastPutTime = new AtomicLong(Time.currentTimeMillis());
-        this.loadedCache = new ConcurrentHashMap<>();
-
-        registerFlushCacheOnExit();
     }
 
     @SuppressWarnings("unchecked")
     public <E> E get(String key) {
-        loadCacheIfRequired();
-        Map<String, Object> valueWithMeta = (Map<String, Object>) loadedCache.get(key);
-        if (valueWithMeta == null) {
-            return null;
-        }
-
-        Number expirationTime = (Number) valueWithMeta.get(EXPIRATION_TIME_KEY);
-        if (Time.currentTimeMillis() >= expirationTime.longValue()) {
-            loadedCache.remove(key);
-            flushCacheToDiskIfRequired();
+        Path valuePath = valueFilePathByKeyAndCreateDirIfRequired(key);
+        if (!Files.exists(valuePath)) {
             return null;
         }
 
-        E result = (E) valueWithMeta.get(VALUE_KEY);
-        flushCacheToDiskIfRequired();
-
-        return result;
-    }
-
-    public void put(String key, Object value, long expirationTime) {
-        loadCacheIfRequired();
-        Map<String, Object> valueWithMeta = createValueWithMeta(value, expirationTime);
-        loadedCache.put(key, valueWithMeta);
-
-        flushCacheToDiskIfRequired();
+        return (E) JsonUtils.deserialize(FileUtils.fileTextContent(valuePath));
     }
 
     public void put(String key, Object value) {
-        put(key, value, Long.MAX_VALUE);
-    }
-
-    private Map<String, Object> createValueWithMeta(Object value, long expirationTime) {
-        Map<String, Object> result = new LinkedHashMap<>();
-        result.put(VALUE_KEY, value);
-        result.put(EXPIRATION_TIME_KEY, expirationTime);
-
-        return result;
-    }
-
-    @SuppressWarnings("unchecked")
-    private void loadCacheIfRequired() {
-        if (isCacheLoaded.get()) {
-            return;
-        }
-
-        Path cachePath = cachePathSupplier.get();
-        if (!Files.exists(cachePath)) {
-            isCacheLoaded.set(true);
-            return;
+        Path valuePath = valueFilePathByKeyAndCreateDirIfRequired(key);
+        try {
+            Files.write(valuePath, JsonUtils.serializePrettyPrint(value).getBytes());
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
         }
-
-        loadedCache.putAll((Map<String, ?>) JsonUtils.deserialize(FileUtils.fileTextContent(cachePath)));
-        isCacheLoaded.set(true);
     }
 
-    private void flushCacheToDiskIfRequired() {
-        long lastTime = lastPutTime.get();
-        long current = Time.currentTimeMillis();
-
-        if (current - lastTime > 10_000) {
-            flushCacheToDisk();
+    private Path valueFilePathByKeyAndCreateDirIfRequired(String key) {
+        Path root = cachePathSupplier.get();
+        if (!Files.exists(root)) {
+            FileUtils.createDirs(root);
         }
 
-        lastPutTime.set(current);
-    }
-
-    private synchronized void flushCacheToDisk() {
-        FileUtils.writeTextContent(cachePathSupplier.get(), JsonUtils.serializePrettyPrint(loadedCache));
-    }
-
-    private void registerFlushCacheOnExit() {
-        Runtime.getRuntime().addShutdownHook(new Thread(this::flushCacheToDisk));
+        return root.resolve(key + ".json");
     }
 }

webtau-cache/src/test/groovy/org/testingisdocumenting/webtau/cache/FileBasedCacheTest.groovy

@@ -18,16 +18,12 @@
 package org.testingisdocumenting.webtau.cache
 
 import org.junit.After
-import org.junit.Assert
 import org.junit.Test
-import org.testingisdocumenting.webtau.time.DummyTimeProvider
 import org.testingisdocumenting.webtau.time.Time
-import org.testingisdocumenting.webtau.utils.JsonUtils
+import org.testingisdocumenting.webtau.utils.FileUtils
 
 import java.nio.file.Files
 import java.nio.file.Path
-import java.nio.file.Paths
-import java.util.concurrent.Executors
 
 class FileBasedCacheTest {
     @After
@@ -37,114 +33,39 @@ class FileBasedCacheTest {
 
     @Test
     void "should load cached values from a provided file"() {
-        def cache = [
-                url: [
-                        value: 'http://test',
-                        expirationTime: Long.MAX_VALUE
-                ],
-                cost: [
-                        value: 100,
-                        expirationTime: Long.MAX_VALUE
-                ],
-                expired: [
-                        value: 'expired',
-                        expirationTime: 100
-                ]
-        ]
-
-        def cacheFile = createTempCacheFile(cache)
-        def fileBasedCache = new FileBasedCache({ -> cacheFile })
-        assert fileBasedCache.get('url') == 'http://test'
-        assert fileBasedCache.get('cost') == 100
-        assert fileBasedCache.get('nonExisting') == null
-        assert fileBasedCache.get('expired') == null
-    }
-
-    @Test
-    void "should persist values in the file as pretty print json if time passed since last put"() {
-        def cacheFile = createTempCacheFile([:])
+        def cacheDir = createTempCacheDir()
+        FileUtils.writeTextContent(cacheDir.resolve('url.json'), '"http://test"')
 
-        Time.timeProvider = new DummyTimeProvider([0, 11_000])
-
-        def fileBasedCache = new FileBasedCache({ -> cacheFile })
-        fileBasedCache.put('accessToken', 'abc', 400)
-
-        Assert.assertEquals(String.format('{%n' +
-                '  "accessToken" : {%n' +
-                '    "value" : "abc",%n' +
-                '    "expirationTime" : 400%n' +
-                '  }%n' +
-                '}'), cacheFile.text)
+        def fileBasedCache = new FileBasedCache({ -> cacheDir })
+        fileBasedCache.get('url').should == 'http://test'
     }
 
     @Test
-    void "should not persist values in the file right away"() {
-        def cacheFile = createTempCacheFile([:])
+    void "should save cached value to a file within cache dir"() {
+        def cacheDir = createTempCacheDir()
 
-        Time.timeProvider = new DummyTimeProvider([0, 100])
+        def fileBasedCache = new FileBasedCache({ -> cacheDir })
 
-        def fileBasedCache = new FileBasedCache({ -> cacheFile })
-        fileBasedCache.put('accessToken', 'abc', 400)
+        fileBasedCache.put('number', 200)
+        fileBasedCache.get('number').should == 200
 
-        Assert.assertEquals("{ }", cacheFile.text)
+        FileUtils.fileTextContent(cacheDir.resolve('number.json')).should == '200'
     }
 
     @Test
-    void "should create non expiring values if no expiration time is provided"() {
-        def cacheFile = createTempCacheFile([:])
-
-        Time.timeProvider = new DummyTimeProvider([0, 11_000])
-        def fileBasedCache = new FileBasedCache({ -> cacheFile })
-        fileBasedCache.put('accessToken', 'abc')
-
-        Assert.assertEquals(String.format('{%n' +
-                '  "accessToken" : {%n' +
-                '    "value" : "abc",%n' +
-                '    "expirationTime" : 9223372036854775807%n' +
-                '  }%n' +
-                '}'), cacheFile.text)
-    }
+    void "should load cache values on demand without caching"() {
+        def cacheDir = createTempCacheDir()
 
-    @Test
-    void "should handle put from multiple threads"() {
-        def cacheFile = createTempCacheFile([:])
-        Time.timeProvider = new DummyTimeProvider(0)
-        def fileBasedCache = new FileBasedCache({ -> cacheFile })
-
-        def executor = Executors.newFixedThreadPool(300)
-
-        def futures = []
-        300.times {idx ->
-            fileBasedCache.put("value" + idx, 0)
-
-            futures << executor.submit {
-                150.times {
-                    fileBasedCache.put("value" + idx, fileBasedCache.get("value" + idx) + 1)
-                }
-            }
-        }
-
-        futures*.get()
-        assert fileBasedCache.get("value0") == 150
-        assert fileBasedCache.get("value1") == 150
-        assert fileBasedCache.get("value9") == 150
-    }
-
-    @Test
-    void "should handle non existing file"() {
-        def cachePath = Paths.get('nonExisting.json')
-        cachePath.toFile().deleteOnExit()
-        def cache = new FileBasedCache({ -> cachePath })
+        def fileBasedCache = new FileBasedCache({ -> cacheDir })
 
-        assert cache.get('key') == null
+        fileBasedCache.put('number', 200)
+        FileUtils.writeTextContent(cacheDir.resolve('number.json'), '300')
 
-        cache.put('key', 'value')
-        assert cache.get('key') == 'value'
+        fileBasedCache.get('number').should == 300
     }
 
-    private static Path createTempCacheFile(Map<String, Object> content) {
-        def cachePath = Files.createTempFile('webtau.cache', '.json')
-        cachePath.text = JsonUtils.serializePrettyPrint(content)
+    private static Path createTempCacheDir() {
+        def cachePath = Files.createTempDirectory('webtau-cache')
         cachePath.toFile().deleteOnExit()
 
         return cachePath

webtau-config/src/main/java/org/testingisdocumenting/webtau/cfg/WebTauConfig.java

@@ -72,8 +72,8 @@ public class WebTauConfig implements PrettyPrintable {
             "By default webtau appends webtau and its version to the user-agent, this disables that part",
             () -> false);
     private final ConfigValue workingDir = declare("workingDir", "logical working dir", () -> Paths.get(""));
-    private final ConfigValue cachePath = declare("cachePath", "user driven cache file path",
-            () -> workingDir.getAsPath().resolve(".webtau.cache.json"));
+    private final ConfigValue cachePath = declare("cachePath", "user driven cache base dir",
+            () -> workingDir.getAsPath().resolve(".webtau-cache"));
 
     private final ConfigValue docPath = declare("docPath", "path for captured request/responses, screenshots and other generated " +
             "artifacts for documentation", () -> workingDir.getAsPath().resolve(DEFAULT_DOC_ARTIFACTS_DIR_NAME));

webtau-utils/src/main/java/org/testingisdocumenting/webtau/utils/FileUtils.java

@@ -18,6 +18,7 @@
 package org.testingisdocumenting.webtau.utils;
 
 import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -43,7 +44,7 @@ public static void createDirs(Path path) {
         try {
             Files.createDirectories(path);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new UncheckedIOException(e);
         }
     }
 
@@ -56,7 +57,7 @@ public static void writeBinaryContent(Path path, byte[] content) {
             createDirsForFile(path);
             Files.write(path, content);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new UncheckedIOException(e);
         }
     }
 
@@ -68,7 +69,7 @@ public static String fileTextContent(Path path) {
         try {
             return new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new UncheckedIOException(e);
         }
     }
 
@@ -80,7 +81,7 @@ public static byte[] fileBinaryContent(Path path) {
         try {
             return Files.readAllBytes(path);
         } catch (IOException e) {
-            throw new RuntimeException(e);
+            throw new UncheckedIOException(e);
         }
     }