HTTP cache size limit environment variables

distribution/lib/Standard/Base/0.0.0-dev/src/Meta/Enso_Project.enso

@@ -91,6 +91,11 @@ type Project_Description
     namespace : Text
     namespace self = self.ns
 
+    ## PRIVATE
+       Returns the path of the project root.
+    root_path : Text
+    root_path self = self.root.path
+
 ## ICON enso_icon
    Returns the Enso project description for the project that the engine was
    executed with, i.e., the project that contains the `main` method, or

distribution/lib/Standard/Base/0.0.0-dev/src/Network/HTTP.enso

@@ -49,7 +49,6 @@ polyglot java import java.net.http.HttpRequest.Builder
 polyglot java import java.net.InetSocketAddress
 polyglot java import java.net.ProxySelector
 polyglot java import javax.net.ssl.SSLContext
-polyglot java import org.enso.base.enso_cloud.EnsoHTTPResponseCache
 polyglot java import org.enso.base.enso_cloud.EnsoSecretHelper
 polyglot java import org.enso.base.file_system.File_Utils
 polyglot java import org.enso.base.net.http.MultipartBodyBuilder
@@ -184,7 +183,7 @@ type HTTP
 
              HTTP.clear_response_cache
     clear_response_cache : Nothing
-    clear_response_cache -> Nothing = EnsoHTTPResponseCache.clear
+    clear_response_cache -> Nothing = EnsoSecretHelper.getCache.clear
 
     ## PRIVATE
        ADVANCED

std-bits/base/src/main/java/org/enso/base/CurrentEnsoProject.java

@@ -7,26 +7,32 @@
 public final class CurrentEnsoProject {
   private final String name;
   private final String namespace;
+  private final String rootPath;
 
   private static CurrentEnsoProject cached = null;
   private static boolean isCached = false;
 
-  private CurrentEnsoProject(String name, String namespace) {
+  private CurrentEnsoProject(String name, String namespace, String rootPath) {
     this.name = name;
     this.namespace = namespace;
+    this.rootPath = rootPath;
   }
 
   public static CurrentEnsoProject get() {
     if (!isCached) {
       Value ensoProject =
           EnsoMeta.callStaticModuleMethod("Standard.Base.Meta.Enso_Project", "enso_project");
-      if (ensoProject.hasMember("name") && ensoProject.hasMember("namespace")) {
+      if (ensoProject.hasMember("name")
+          && ensoProject.hasMember("namespace")
+          && ensoProject.hasMember("root_path")) {
         Value namespace = ensoProject.invokeMember("namespace");
         Value name = ensoProject.invokeMember("name");
-        if (namespace == null || name == null) {
+        Value rootPath = ensoProject.invokeMember("root_path");
+        if (namespace == null || name == null || rootPath == null) {
           cached = null;
         } else {
-          cached = new CurrentEnsoProject(name.asString(), namespace.asString());
+          cached =
+              new CurrentEnsoProject(name.asString(), namespace.asString(), rootPath.asString());
         }
       } else {
         cached = null;
@@ -46,6 +52,10 @@ public String getNamespace() {
     return namespace;
   }
 
+  public String getRootPath() {
+    return rootPath;
+  }
+
   public String fullName() {
     return namespace + "." + name;
   }

std-bits/base/src/main/java/org/enso/base/cache/DiskSpaceGetter.java

@@ -0,0 +1,15 @@
+package org.enso.base.cache;
+
+import java.io.File;
+import org.enso.base.CurrentEnsoProject;
+
+public class DiskSpaceGetter extends Mockable<Long> {
+  @Override
+  public Long computeValue() {
+    return getRootPath().getUsableSpace();
+  }
+
+  private static File getRootPath() {
+    return new File(CurrentEnsoProject.get().getRootPath());
+  }
+}

std-bits/base/src/main/java/org/enso/base/cache/LRUCache.java

@@ -28,22 +28,59 @@
  * deleting entries to make space for new ones. All cache files are set to be deleted automatically
  * on JVM exit.
  *
+ * <p>Limits should be set with environment variables:
+ *
+ * <p>
+ *
+ * <pre>
+ * - ENSO_LIB_HTTP_CACHE_MAX_FILE_SIZE_MB: single file size, in MB
+ * - ENSO_LIB_HTTP_CACHE_MAX_TOTAL_CACHE_LIMIT: total cache size, in MB or
+ *   percentage of free disk space
+ * </pre>
+ *
+ * <p>Examples:
+ *
+ * <pre>
+ *   ENSO_LIB_HTTP_CACHE_MAX_FILE_SIZE_MB=20
+ *   ENSO_LIB_HTTP_CACHE_MAX_TOTAL_CACHE_LIMIT=200 ENSO_LIB_HTTP_CACHE_MAX_TOTAL_CACHE_LIMIT=50%
+ * </pre>
+ *
+ * <p>Regardless of other settings, the total cache size is capped at a percentage of the free disk
+ * space (MAX_PERCENTAGE).
+ *
  * @param <M> Additional metadata to associate with the data.
  */
 public class LRUCache<M> {
   private static final Logger logger = Logger.getLogger(LRUCache.class.getName());
 
-  private final long maxFileSize;
-  private final long maxTotalCacheSize;
-
-  private final CacheTestParameters cacheTestParameters = new CacheTestParameters();
+  /**
+   * An upper limit on the total cache size. If the cache size limit specified by the other
+   * parameters goes over this value, then this value is used.
+   */
+  private static final double MAX_PERCENTAGE = 0.9;
 
+  /** Used to override cache parameters for testing. */
   private final Map<String, CacheEntry<M>> cache = new HashMap<>();
+
   private final Map<String, ZonedDateTime> lastUsed = new HashMap<>();
 
-  public LRUCache(long maxFileSize, long maxTotalCacheSize) {
-    this.maxFileSize = maxFileSize;
-    this.maxTotalCacheSize = maxTotalCacheSize;
+  /** Defines the per-file and total cache size limits. */
+  private final LRUCacheSettings settings;
+
+  /** Used to get the current time; mockable. */
+  private final NowGetter nowGetter;
+
+  /** Used to get the current free disk space; mockable. */
+  private final DiskSpaceGetter diskSpaceGetter;
+
+  public LRUCache() {
+    this(LRUCacheSettings.getDefault(), new NowGetter(), new DiskSpaceGetter());
+  }
+
+  public LRUCache(LRUCacheSettings settings, NowGetter nowGetter, DiskSpaceGetter diskSpaceGetter) {
+    this.settings = settings;
+    this.nowGetter = nowGetter;
+    this.diskSpaceGetter = diskSpaceGetter;
   }
 
   public CacheResult<M> getResult(ItemBuilder<M> itemBuilder)
@@ -70,30 +107,31 @@ private CacheResult<M> makeRequestAndCache(String cacheKey, ItemBuilder<M> itemB
       return new CacheResult<>(item.stream(), item.metadata());
     }
 
+    // If we have a content-length, clear up enough space for that. If not,
+    // then clear up enough space for the largest allowed file size.
+    long maxFileSize = settings.getMaxFileSize();
     if (item.sizeMaybe.isPresent()) {
       long size = item.sizeMaybe().get();
-      if (size > getMaxFileSize()) {
-        throw new ResponseTooLargeException(getMaxFileSize());
+      if (size > maxFileSize) {
+        throw new ResponseTooLargeException(maxFileSize);
       }
       makeRoomFor(size);
+    } else {
+      makeRoomFor(maxFileSize);
     }
 
     try {
       // Download the response data.
       File responseData = downloadResponseData(cacheKey, item);
       M metadata = item.metadata();
       long size = responseData.length();
-      ZonedDateTime expiry = getNow().plus(Duration.ofSeconds(item.ttl().get()));
+      ZonedDateTime expiry = nowGetter.get().plus(Duration.ofSeconds(item.ttl().get()));
 
       // Create a cache entry.
       var cacheEntry = new CacheEntry<>(responseData, metadata, size, expiry);
       cache.put(cacheKey, cacheEntry);
       markCacheEntryUsed(cacheKey);
 
-      // Clear out old entries to satisfy the total cache size limit. This might
-      // be necessary here if we didn't receive a correct content size value.
-      removeFilesToSatisfyLimit();
-
       return getResultForCacheEntry(cacheKey);
     } catch (IOException e) {
       logger.log(
@@ -124,13 +162,14 @@ private File downloadResponseData(String cacheKey, Item item)
     boolean successful = false;
     try {
       // Limit the download to getMaxFileSize().
-      boolean sizeOK = Stream_Utils.limitedCopy(inputStream, outputStream, getMaxFileSize());
+      long maxFileSize = settings.getMaxFileSize();
+      boolean sizeOK = Stream_Utils.limitedCopy(inputStream, outputStream, maxFileSize);
 
       if (sizeOK) {
         successful = true;
         return temp;
       } else {
-        throw new ResponseTooLargeException(getMaxFileSize());
+        throw new ResponseTooLargeException(maxFileSize);
       }
     } finally {
       outputStream.close();
@@ -144,12 +183,12 @@ private File downloadResponseData(String cacheKey, Item item)
 
   /** Mark the entry with the current time, to maintain LRU data. */
   private void markCacheEntryUsed(String cacheKey) {
-    lastUsed.put(cacheKey, getNow());
+    lastUsed.put(cacheKey, nowGetter.get());
   }
 
   /** Remove all cache entries (and their files) that have passed their TTL. */
   private void removeStaleEntries() {
-    var now = getNow();
+    var now = nowGetter.get();
     removeCacheEntriesByPredicate(e -> e.expiry().isBefore(now));
   }
 
@@ -195,8 +234,13 @@ private void removeCacheFile(String key, CacheEntry<M> cacheEntry) {
   private void makeRoomFor(long newFileSize) {
     removeStaleEntries();
 
-    long totalSize = getTotalCacheSize() + newFileSize;
-    long maxTotalCacheSize = getMaxTotalCacheSize();
+    // Size of files on disk.
+    long currentCacheSize = getTotalCacheSize();
+    // Upper limit to cache size.
+    long maxTotalCacheSize = getMaxTotalCacheSize(currentCacheSize);
+    // Size including new file.
+    long totalSize = currentCacheSize + newFileSize;
+
     if (totalSize <= maxTotalCacheSize) {
       return;
     }
@@ -221,39 +265,46 @@ private SortedSet<Map.Entry<String, CacheEntry<M>>> getSortedEntries() {
     return sortedEntries;
   }
 
-  /** Remove least-recently used entries until the total cache size is under the limit. */
-  private void removeFilesToSatisfyLimit() {
-    makeRoomFor(0L);
-  }
-
   private long getTotalCacheSize() {
     return cache.values().stream().collect(Collectors.summingLong(e -> e.size()));
   }
 
-  private long getMaxFileSize() {
-    return cacheTestParameters.getMaxFileSizeOverrideTestOnly().orElse(maxFileSize);
+  /**
+   * Calculate the max total cache size, using the current limit but also constraining the result to
+   * the upper bound.
+   */
+  public long getMaxTotalCacheSize(long currentlyUsed) {
+    long freeSpace = diskSpaceGetter.get() + currentlyUsed;
+
+    var totalCacheSize =
+        switch (settings.getTotalCacheLimit()) {
+          case TotalCacheLimit.Bytes bytes -> bytes.bytes();
+          case TotalCacheLimit.Percentage percentage -> {
+            yield (long) (percentage.percentage() * freeSpace);
+          }
+        };
+    long upperBound = (long) (freeSpace * MAX_PERCENTAGE);
+    return Long.min(upperBound, totalCacheSize);
   }
 
-  private long getMaxTotalCacheSize() {
-    return cacheTestParameters.getMaxTotalCacheSizeOverrideTestOnly().orElse(maxTotalCacheSize);
+  /** For testing. */
+  public long getMaxTotalCacheSize() {
+    return getMaxTotalCacheSize(getTotalCacheSize());
   }
 
   public int getNumEntries() {
     return cache.size();
   }
 
-  public List<Long> getFileSizesTestOnly() {
+  /** Public for testing. */
+  public List<Long> getFileSizes() {
     return new ArrayList<>(
         cache.values().stream().map(CacheEntry::size).collect(Collectors.toList()));
   }
 
-  private ZonedDateTime getNow() {
-    return cacheTestParameters.getNowOverrideTestOnly().orElse(ZonedDateTime.now());
-  }
-
-  /** Return a set of parameters that can be used to modify settings for testing purposes. */
-  public CacheTestParameters getCacheTestParameters() {
-    return cacheTestParameters;
+  /** Public for testing. */
+  public LRUCacheSettings getSettings() {
+    return settings;
   }
 
   private record CacheEntry<M>(File responseData, M metadata, long size, ZonedDateTime expiry) {}
@@ -290,64 +341,4 @@ public interface ItemBuilder<M> {
 
   private final Comparator<Map.Entry<String, CacheEntry<M>>> cacheEntryLRUComparator =
       Comparator.comparing(me -> lastUsed.get(me.getKey()));
-
-  /** A set of parameters that can be used to modify cache settings for testing purposes. */
-  public class CacheTestParameters {
-    /** This value is used for the current time when testing TTL expiration logic. */
-    private Optional<ZonedDateTime> nowOverrideTestOnly = Optional.empty();
-
-    /**
-     * Used for testing file and cache size limits. These cannot be set to values larger than the
-     * real limits.
-     */
-    private Optional<Long> maxFileSizeOverrideTestOnly = Optional.empty();
-
-    private Optional<Long> maxTotalCacheSizeOverrideTestOnly = Optional.empty();
-
-    public Optional<ZonedDateTime> getNowOverrideTestOnly() {
-      return nowOverrideTestOnly;
-    }
-
-    public void setNowOverrideTestOnly(ZonedDateTime nowOverride) {
-      nowOverrideTestOnly = Optional.of(nowOverride);
-    }
-
-    public void clearNowOverrideTestOnly() {
-      nowOverrideTestOnly = Optional.empty();
-    }
-
-    public Optional<Long> getMaxFileSizeOverrideTestOnly() {
-      return maxFileSizeOverrideTestOnly;
-    }
-
-    public void setMaxFileSizeOverrideTestOnly(long maxFileSizeOverrideTestOnly_) {
-      if (maxFileSizeOverrideTestOnly_ > maxFileSize) {
-        throw new IllegalArgumentException(
-            "Cannot set the (test-only) maximum file size to more than the allowed limit of "
-                + maxFileSize);
-      }
-      maxFileSizeOverrideTestOnly = Optional.of(maxFileSizeOverrideTestOnly_);
-    }
-
-    public void clearMaxFileSizeOverrideTestOnly() {
-      maxFileSizeOverrideTestOnly = Optional.empty();
-    }
-
-    public Optional<Long> getMaxTotalCacheSizeOverrideTestOnly() {
-      return maxTotalCacheSizeOverrideTestOnly;
-    }
-
-    public void setMaxTotalCacheSizeOverrideTestOnly(long maxTotalCacheSizeOverrideTestOnly_) {
-      if (maxTotalCacheSizeOverrideTestOnly_ > maxTotalCacheSize) {
-        throw new IllegalArgumentException(
-            "Cannot set the (test-only) total cache size to more than the allowed limit of "
-                + maxTotalCacheSize);
-      }
-      maxTotalCacheSizeOverrideTestOnly = Optional.of(maxTotalCacheSizeOverrideTestOnly_);
-    }
-
-    public void clearMaxTotalCacheSizeOverrideTestOnly() {
-      maxTotalCacheSizeOverrideTestOnly = Optional.empty();
-    }
-  }
 }