Cache error responses (#50)

With our publishing mechanism of only including known published
artifacts in the BOM, we rarely see 404s or errors.

When we do it usually means something bad went wrong but we should not
keep retrying it to avoid overwhelming the artifact repo backend.

Author: joshfriend

cli/build.gradle.kts

@@ -22,10 +22,12 @@ dependencies {
   implementation(libs.kotlinxCoroutines)
   implementation(libs.moshi)
   implementation(libs.okhttp)
+  implementation(libs.okhttp.logging)
   implementation(libs.picocli.core)
   implementation(libs.retrofit.core)
   implementation(libs.retrofit.converter.jackson)
   implementation(libs.retrofit.wire)
+  implementation(libs.slf4j.api)
 
   runtimeOnly(libs.log4j.slf4j2.impl) {
     because("JGit uses SLF4J for logging")

cli/src/main/kotlin/xyz/block/artifactswap/cli/di/NetworkModule.kt

@@ -5,17 +5,23 @@ import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.databind.SerializationFeature
 import com.fasterxml.jackson.dataformat.xml.XmlMapper
 import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import java.io.File
 import kotlin.io.path.Path
 import kotlin.io.path.readLines
 import kotlin.time.Duration.Companion.seconds
 import kotlin.time.toJavaDuration
+import okhttp3.Cache
 import okhttp3.Dispatcher
+import okhttp3.Interceptor
 import okhttp3.OkHttpClient
+import okhttp3.logging.HttpLoggingInterceptor
 import org.koin.core.KoinApplication
 import org.koin.core.qualifier.named
 import org.koin.dsl.module
+import org.slf4j.LoggerFactory
 import retrofit2.Retrofit
 import retrofit2.converter.jackson.JacksonConverterFactory
+import retrofit2.converter.wire.WireConverterFactory
 import retrofit2.create
 import xyz.block.artifactswap.core.config.ArtifactSwapConfigHolder
 import xyz.block.artifactswap.core.eventstream.Eventstream
@@ -26,18 +32,67 @@ import xyz.block.artifactswap.core.network.ArtifactoryService
 private val UNAUTHENTICATED_HTTP_METHODS = listOf("GET", "HEAD")
 
 internal fun artifactoryNetworkModule() = module {
+  // HTTP cache for OkHttp client (10MB)
+  // It's small because we only cache error responses from the repo
+  single<Cache> {
+    val cacheDirectory = File(System.getProperty("java.io.tmpdir"), "artifactswap-cache")
+    Cache(cacheDirectory, 10L * 1024L * 1024L)
+  }
+
+  single<HttpLoggingInterceptor> {
+    val logger = LoggerFactory.getLogger("http")
+    HttpLoggingInterceptor { message -> logger.trace(message) }
+      .apply { level = HttpLoggingInterceptor.Level.BASIC }
+  }
+
+  // Interceptor that caches only 404 responses for 1 hour and prevents caching of successful
+  // responses.
+  // Successful artifact downloads are implicitly cached in the local .m2 repository.
+  // Missing artifacts are expensive to query from the repo backend and should be cached.
+  single<Interceptor>(named("cache404Interceptor")) {
+    Interceptor { chain ->
+      val response = chain.proceed(chain.request())
+
+      when (response.code) {
+        // Cache 404 responses for 1 hour
+        404 -> {
+          response
+            .newBuilder()
+            .header("Cache-Control", "public, max-age=3600, immutable")
+            .removeHeader("Pragma")
+            .removeHeader("Expires")
+            .build()
+        }
+        // Prevent caching of successful responses (artifacts are cached in local .m2 repo)
+        in 200..299 -> {
+          response
+            .newBuilder()
+            .header("Cache-Control", "no-store")
+            .removeHeader("Pragma")
+            .removeHeader("Expires")
+            .build()
+        }
+        // Don't modify other response codes
+        else -> response
+      }
+    }
+  }
+
   single<OkHttpClient>(named("artifactoryClient")) {
     OkHttpClient.Builder()
+      .cache(get<Cache>())
       .retryOnConnectionFailure(true)
-      .connectTimeout(30.seconds.toJavaDuration())
-      .readTimeout(30.seconds.toJavaDuration())
-      .callTimeout(30.seconds.toJavaDuration())
+      .connectTimeout(5.seconds.toJavaDuration())
+      .readTimeout(10.seconds.toJavaDuration())
+      .callTimeout(10.seconds.toJavaDuration())
       .dispatcher(
         Dispatcher().apply {
           maxRequestsPerHost = 128
           maxRequests = 512
         }
       )
+      .addInterceptor(get<HttpLoggingInterceptor>())
+      .addNetworkInterceptor(get<Interceptor>(named("cache404Interceptor")))
       .addInterceptor { chain ->
         // GET/HEAD methods don't require authentication
         if (chain.request().method !in UNAUTHENTICATED_HTTP_METHODS) {
@@ -95,15 +150,15 @@ internal fun analyticsNetworkModule() = module {
   single<EventstreamService> {
     val httpClient =
       OkHttpClient.Builder()
-        .connectTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
-        .readTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
-        .writeTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+        .connectTimeout(5.seconds.toJavaDuration())
+        .readTimeout(10.seconds.toJavaDuration())
+        .writeTimeout(10.seconds.toJavaDuration())
         .build()
 
     Retrofit.Builder()
       .baseUrl(ArtifactSwapConfigHolder.instance.eventstreamBaseUrl)
       .client(httpClient)
-      .addConverterFactory(retrofit2.converter.wire.WireConverterFactory.create())
+      .addConverterFactory(WireConverterFactory.create())
       .build()
       .create<EventstreamService>()
   }

gradle/libs.versions.toml

@@ -65,6 +65,7 @@ moshi = { module = "com.squareup.moshi:moshi", version.ref = "moshi" }
 moshi-kotlin = { module = "com.squareup.moshi:moshi-kotlin", version.ref = "moshi" }
 moshi-kotlin-codegen = { module = "com.squareup.moshi:moshi-kotlin-codegen", version.ref = "moshi" }
 okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp"}
+okhttp-logging = { module = "com.squareup.okhttp3:logging-interceptor", version.ref = "okhttp" }
 okio = { module = "com.squareup.okio:okio", version.ref = "okio" }
 picocli-core = { module = "info.picocli:picocli", version.ref = "picocli" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version = "1.7.36" }