okhttp: add retry interceptor

Author: thewizrd

app/src/androidTestFullgms/java/com/thewizrd/simpleweather/test/UnitTests.kt

@@ -18,6 +18,7 @@ import com.thewizrd.shared_resources.exceptions.WeatherException
 import com.thewizrd.shared_resources.locationdata.LocationData
 import com.thewizrd.shared_resources.locationdata.WeatherLocationProvider
 import com.thewizrd.shared_resources.locationdata.toLocationData
+import com.thewizrd.shared_resources.okhttp3.OkHttp3Utils.await
 import com.thewizrd.shared_resources.preferences.SettingsManager
 import com.thewizrd.shared_resources.remoteconfig.WeatherProviderConfig
 import com.thewizrd.shared_resources.utils.Coordinate
@@ -50,6 +51,7 @@ import com.thewizrd.weather_api.weatherkit.CurrentWeather
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
+import okhttp3.Request
 import org.junit.After
 import org.junit.Assert.*
 import org.junit.Before
@@ -688,4 +690,43 @@ class UnitTests {
             UpdateInfo::class.java
         )
     }
+
+    @Test
+    fun test500error() {
+        val request = Request.Builder()
+            .url("https://httpstat.us/500")
+            .build()
+
+        val client = sharedDeps.httpClient
+
+        runBlocking {
+            client.newCall(request).await()
+        }
+    }
+
+    @Test
+    fun test502error() {
+        val request = Request.Builder()
+            .url("https://httpstat.us/502?sleep=1000")
+            .build()
+
+        val client = sharedDeps.httpClient
+
+        runBlocking {
+            client.newCall(request).await()
+        }
+    }
+
+    @Test
+    fun test504error() {
+        val request = Request.Builder()
+            .url("https://httpstat.us/504?sleep=1000")
+            .build()
+
+        val client = sharedDeps.httpClient
+
+        runBlocking {
+            client.newCall(request).await()
+        }
+    }
 }

shared_resources/src/main/java/com/thewizrd/shared_resources/SharedModule.kt

@@ -3,6 +3,7 @@ package com.thewizrd.shared_resources
 import android.content.Context
 import com.thewizrd.shared_resources.icons.WeatherIconsManager
 import com.thewizrd.shared_resources.okhttp3.CacheInterceptor
+import com.thewizrd.shared_resources.okhttp3.RetryPolicyInterceptor
 import com.thewizrd.shared_resources.preferences.SettingsManager
 import com.thewizrd.shared_resources.utils.Logger
 import okhttp3.Cache
@@ -38,6 +39,7 @@ abstract class SharedModule {
             .retryOnConnectionFailure(true)
             .cache(Cache(File(context.cacheDir, "okhttp3"), 50L * 1024 * 1024))
             .addNetworkInterceptor(CacheInterceptor())
+            .addInterceptor(RetryPolicyInterceptor())
             .build()
     }
 

shared_resources/src/main/java/com/thewizrd/shared_resources/okhttp3/CacheInterceptor.java

@@ -0,0 +1,45 @@
+package com.thewizrd.shared_resources.okhttp3
+
+import okhttp3.CacheControl
+import okhttp3.Interceptor
+import okhttp3.Response
+import java.util.concurrent.TimeUnit
+
+class CacheInterceptor : Interceptor {
+    companion object {
+        private const val CACHE_CONTROL_HEADER = "Cache-Control"
+        private const val CACHE_CONTROL_NO_CACHE = "no-cache"
+    }
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val request = chain.request()
+        val response = chain.proceed(request)
+
+        val shouldUseCache =
+            !CACHE_CONTROL_NO_CACHE.equals(request.header(CACHE_CONTROL_HEADER), ignoreCase = true)
+
+        if (!shouldUseCache) {
+            return response
+        }
+
+        val hasCacheHeader = !request.header(CACHE_CONTROL_HEADER).isNullOrEmpty()
+
+        // Override server cache protocol
+        val builder = response.newBuilder()
+            .removeHeader("Pragma")
+
+        if (!hasCacheHeader) {
+            // If original response does not contain a Cache-Control header
+            // cache the response for a minimum of 2 min to avoid repeat requests
+            val cacheControl = CacheControl.Builder()
+                .maxAge(2, TimeUnit.MINUTES)
+                .build()
+
+            builder.header(CACHE_CONTROL_HEADER, cacheControl.toString())
+        } else {
+            builder.header(CACHE_CONTROL_HEADER, request.cacheControl.toString())
+        }
+
+        return builder.build()
+    }
+}

shared_resources/src/main/java/com/thewizrd/shared_resources/okhttp3/CacheInterceptor.kt

@@ -0,0 +1,63 @@
+package com.thewizrd.shared_resources.okhttp3
+
+import com.thewizrd.shared_resources.utils.Logger
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import okhttp3.Interceptor
+import okhttp3.Response
+import okhttp3.internal.closeQuietly
+import okio.IOException
+import java.net.HttpURLConnection
+import kotlin.math.pow
+
+class RetryPolicyInterceptor : Interceptor {
+    companion object {
+        private const val TAG = "RetryPolicyInterceptor"
+
+        private val RETRYABLE_STATUSES = setOf(
+            HttpURLConnection.HTTP_INTERNAL_ERROR,
+            HttpURLConnection.HTTP_BAD_GATEWAY,
+            //HttpURLConnection.HTTP_UNAVAILABLE, -- RetryAndFollowUpInterceptor
+            HttpURLConnection.HTTP_GATEWAY_TIMEOUT,
+        )
+
+        private const val DEFAULT_RETRY_COUNT = 2
+        private const val DEFAULT_RETRY_DELAY_MS = 300
+
+        private const val HEADER_RETRY_COUNT = "X-Retry-Count"
+        private const val HEADER_RETRY_AFTER = "Retry-After"
+    }
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val request = chain.request()
+        var response = chain.proceed(request)
+
+        val retryDelay = (response.header(HEADER_RETRY_AFTER)?.toIntOrNull()?.times(1000)
+            ?: DEFAULT_RETRY_DELAY_MS).coerceAtMost(10000)
+        val retryCount = (request.header(HEADER_RETRY_COUNT)?.toIntOrNull() ?: DEFAULT_RETRY_COUNT)
+
+        var tryCount = 0
+
+        while ((!response.isSuccessful && response.code in RETRYABLE_STATUSES) && tryCount < retryCount) {
+            response.closeQuietly()
+
+            val expDelay = retryDelay * 2f.pow(tryCount)
+            tryCount++
+
+            runBlocking {
+                try {
+                    delay(expDelay.toLong())
+                    response = chain.proceed(request.newBuilder().build())
+                    Logger.debug(
+                        TAG,
+                        "retried request - tryCount = $tryCount | host: ${request.url.host} | statusCode: ${response.code}"
+                    )
+                } catch (e: IOException) {
+                    Logger.error(TAG, e)
+                }
+            }
+        }
+
+        return response
+    }
+}