Allow short-term caching of /builds

Author: gabrielfeo

src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/Api.kt

@@ -4,6 +4,7 @@ package com.gabrielfeo.gradle.enterprise.api
 
 import com.gabrielfeo.gradle.enterprise.api.internal.*
 import java.io.File
+import kotlin.time.Duration.Companion.days
 
 /**
  * The global instance of [GradleEnterpriseApi].
@@ -42,19 +43,51 @@ fun shutdown() {
 }
 
 /**
- * Regex pattern to match API URLs that are OK to store in the HTTP cache. Matches by default:
+ * Regex pattern to match API URLs that are OK to store long-term in the HTTP cache, up to
+ * [longTermCacheMaxAge] (1y by default, max value). By default, uses environment variable
+ * `GRADLE_ENTERPRISE_API_LONG_TERM_CACHE_URL_PATTERN` or a pattern matching:
  * - {host}/api/builds/{id}/gradle-attributes
  * - {host}/api/builds/{id}/maven-attributes
  *
- * By default, the Gradle Enterprise API disallows HTTP caching via response headers. This library
- * removes such headers to forcefully allow caching, if the path is matched by any of these
- * patterns.
+ * Gradle Enterprise API disallows HTTP caching, but this library forcefully removes such
+ * restriction.
  *
  * Use `|` to define multiple patterns in one, e.g. `.*gradle-attributes|.*test-distribution`.
+*/
+var longTermCacheUrlPattern: Regex =
+    System.getenv("GRADLE_ENTERPRISE_API_LONG_TERM_CACHE_URL_PATTERN")?.toRegex()
+        ?: """.*/api/builds/[\d\w]+/(?:gradle|maven)-attributes""".toRegex()
+
+/**
+ * Max age in seconds for URLs to be cached long-term (matched by [longTermCacheUrlPattern]).
+ * By default, uses environment variable `GRADLE_ENTERPRISE_API_LONG_TERM_CACHE_MAX_AGE` or 1 year.
+ */
+var longTermCacheMaxAge: Long =
+    System.getenv("GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_MAX_AGE")?.toLong()
+        ?: 365.days.inWholeSeconds
+
+/**
+ * Regex pattern to match API URLs that are OK to store short-term in the HTTP cache, up to
+ * [shortTermCacheMaxAge] (1d by default). By default, uses environment variable
+ * `GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_URL_PATTERN` or a pattern matching:
+ * - {host}/api/builds
+ *
+ * Gradle Enterprise API disallows HTTP caching, but this library forcefully removes such
+ * restriction.
+ *
+ * Use `|` to define multiple patterns in one, e.g. `.*gradle-attributes|.*test-distribution`.
+ */
+var shortTermCacheUrlPattern: Regex =
+    System.getenv("GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_URL_PATTERN")?.toRegex()
+        ?: """.*/builds(?:\?.*|\Z)""".toRegex()
+
+/**
+ * Max age in seconds for URLs to be cached short-term (matched by [shortTermCacheUrlPattern]).
+ * By default, uses environment variable `GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_MAX_AGE` or 1 day.
  */
-val cacheableUrlPattern: Regex = System.getenv("GRADLE_ENTERPRISE_API_CACHEABLE_URL_PATTERN")
-    ?.toRegex()
-    ?: """.*/api/builds/[\d\w]+/(?:gradle|maven)-attributes""".toRegex()
+var shortTermCacheMaxAge: Long =
+    System.getenv("GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_MAX_AGE")?.toLong()
+        ?: 1.days.inWholeSeconds
 
 /**
  * Maximum amount of concurrent requests allowed. Further requests will be queued. By default,

src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/internal/OkHttpClient.kt

@@ -1,23 +1,33 @@
 package com.gabrielfeo.gradle.enterprise.api.internal
 
-import com.gabrielfeo.gradle.enterprise.api.accessToken
 import com.gabrielfeo.gradle.enterprise.api.auth.HttpBearerAuth
-import com.gabrielfeo.gradle.enterprise.api.cacheableUrlPattern
 import com.gabrielfeo.gradle.enterprise.api.internal.caching.CacheEnforcingInterceptor
 import com.gabrielfeo.gradle.enterprise.api.internal.caching.CacheHitLoggingInterceptor
 import com.gabrielfeo.gradle.enterprise.api.internal.caching.cache
+import com.gabrielfeo.gradle.enterprise.api.accessToken
+import com.gabrielfeo.gradle.enterprise.api.longTermCacheMaxAge
+import com.gabrielfeo.gradle.enterprise.api.longTermCacheUrlPattern
 import com.gabrielfeo.gradle.enterprise.api.maxConcurrentRequests
+import com.gabrielfeo.gradle.enterprise.api.shortTermCacheMaxAge
+import com.gabrielfeo.gradle.enterprise.api.shortTermCacheUrlPattern
 import okhttp3.OkHttpClient
 
 val okHttpClient: OkHttpClient by lazy {
     OkHttpClient.Builder()
         .cache(cache)
         .addInterceptor(HttpBearerAuth("bearer", accessToken()))
         .addInterceptor(CacheHitLoggingInterceptor())
-        .addNetworkInterceptor(CacheEnforcingInterceptor(cacheableUrlPattern))
+        .addNetworkInterceptor(buildCacheEnforcingInterceptor())
         .build()
         .apply {
             dispatcher.maxRequests = maxConcurrentRequests
             dispatcher.maxRequestsPerHost = maxConcurrentRequests
         }
 }
+
+private fun buildCacheEnforcingInterceptor() = CacheEnforcingInterceptor(
+    longTermCacheUrlPattern = longTermCacheUrlPattern,
+    longTermCacheMaxAge = longTermCacheMaxAge,
+    shortTermCacheUrlPattern = shortTermCacheUrlPattern,
+    shortTermCacheMaxAge = shortTermCacheMaxAge,
+)

src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/internal/caching/CacheEnforcingInterceptor.kt

@@ -3,17 +3,18 @@ package com.gabrielfeo.gradle.enterprise.api.internal.caching
 import okhttp3.Interceptor
 import okhttp3.Request
 import okhttp3.Response
-import kotlin.time.Duration.Companion.days
 
 internal class CacheEnforcingInterceptor(
-    private val cacheableUrlPattern: Regex,
+    private val longTermCacheUrlPattern: Regex,
+    private val longTermCacheMaxAge: Long,
+    private val shortTermCacheUrlPattern: Regex,
+    private val shortTermCacheMaxAge: Long,
 ) : Interceptor {
 
-    private val maxAge = 365.days.inWholeMilliseconds
-
     override fun intercept(chain: Interceptor.Chain): Response {
         val response = chain.proceed(chain.request())
-        if (!isCacheable(response.request)) {
+        val maxAge = maxAgeFor(response.request)
+        if (maxAge <= 0) {
             return response
         }
         return response.newBuilder()
@@ -24,6 +25,12 @@ internal class CacheEnforcingInterceptor(
             .build()
     }
 
-    private fun isCacheable(request: Request) =
-        cacheableUrlPattern.matches(request.url.toString())
+    private fun maxAgeFor(request: Request): Long {
+        val url = request.url.toString()
+        return when {
+            longTermCacheUrlPattern.matches(url) -> longTermCacheMaxAge
+            shortTermCacheUrlPattern.matches(url) -> shortTermCacheMaxAge
+            else -> 0
+        }
+    }
 }