retry on 502, don't log when logger is disabled

Author: adamint

src/main/kotlin/com/adamratzman/spotify/main/SpotifyAPI.kt

@@ -212,7 +212,8 @@ class SpotifyApiBuilder {
                                 url = "https://accounts.spotify.com/api/token",
                                 method = HttpRequestMethod.POST,
                                 body = "grant_type=authorization_code&code=$authorizationCode&redirect_uri=$redirectUri",
-                                contentType = "application/x-www-form-urlencoded"
+                                contentType = "application/x-www-form-urlencoded",
+                                api = null
                         ).execute(
                                 HttpHeader(
                                         "Authorization",
@@ -386,7 +387,8 @@ class SpotifyClientAPI internal constructor(
                         url = "https://accounts.spotify.com/api/token",
                         method = HttpRequestMethod.POST,
                         body = "grant_type=refresh_token&refresh_token=${token.refreshToken ?: ""}",
-                        contentType = "application/x-www-form-urlencoded"
+                        contentType = "application/x-www-form-urlencoded",
+                        api = this
                 ).execute(HttpHeader("Authorization", "Basic ${"$clientId:$clientSecret".byteEncode()}")).body
                         .toObjectNullable<Token>(null)
         if (tempToken?.accessToken == null) {
@@ -431,7 +433,8 @@ private fun getCredentialedToken(clientId: String, clientSecret: String) =
                 url = "https://accounts.spotify.com/api/token",
                 method = HttpRequestMethod.POST,
                 body = "grant_type=client_credentials",
-                contentType = "application/x-www-form-urlencoded"
+                contentType = "application/x-www-form-urlencoded",
+                api = null
         ).execute(HttpHeader("Authorization", "Basic ${"$clientId:$clientSecret".byteEncode()}")).body
                 .toObjectNullable<Token>(null)
 

src/main/kotlin/com/adamratzman/spotify/main/SpotifyLogger.kt

@@ -4,10 +4,16 @@ package com.adamratzman.spotify.main
 class SpotifyLogger(var enabled: Boolean) {
     val redString = "\u001B[31m"
     val resetString = "\u001B[0m"
-    fun logInfo(message: String) = println("Spotify Logger Info: $message")
-    fun logWarning(message: String) = println("${redString}Spotify Logger Warning: $message$resetString")
+    fun logInfo(message: String) {
+        if (enabled) println("Spotify Logger Info: $message")
+    }
+    fun logWarning(message: String) {
+        if (enabled) println("${redString}Spotify Logger Warning: $message$resetString")
+    }
 
     fun logError(fatal: Boolean, message: String?, throwable: Throwable?) {
+        if (!enabled) return
+
         val sb = StringBuilder("${redString}Spotify Logger ")
         sb.append(if (fatal) "FATAL" else "Error")
         if (message != null) sb.append(": $message")

src/main/kotlin/com/adamratzman/spotify/utils/Endpoints.kt

@@ -25,19 +25,19 @@ abstract class SpotifyEndpoint(val api: SpotifyAPI) {
     }
 
     internal fun delete(
-        url: String,
-        body: String? = null,
-        contentType: String? = null
+            url: String,
+            body: String? = null,
+            contentType: String? = null
     ): String {
         return execute(url, body, HttpRequestMethod.DELETE, contentType = contentType)
     }
 
     private fun execute(
-        url: String,
-        body: String? = null,
-        method: HttpRequestMethod = HttpRequestMethod.GET,
-        retry202: Boolean = true,
-        contentType: String? = null
+            url: String,
+            body: String? = null,
+            method: HttpRequestMethod = HttpRequestMethod.GET,
+            retry202: Boolean = true,
+            contentType: String? = null
     ): String {
         if (api is SpotifyAppAPI && System.currentTimeMillis() >= api.expireTime) api.refreshToken()
 
@@ -50,25 +50,25 @@ abstract class SpotifyEndpoint(val api: SpotifyAPI) {
         }
 
         val document = createConnection(url, body, method, contentType).execute(
-            cacheState?.eTag?.let {
-                HttpHeader("If-None-Match", it)
-            }
+                cacheState?.eTag?.let {
+                    HttpHeader("If-None-Match", it)
+                }
         )
 
         return handleResponse(document, cacheState, spotifyRequest, retry202) ?: execute(
-            url,
-            body,
-            method,
-            false,
-            contentType
+                url,
+                body,
+                method,
+                false,
+                contentType
         )
     }
 
     private fun handleResponse(
-        document: HttpResponse,
-        cacheState: CacheState?,
-        spotifyRequest: SpotifyRequest,
-        retry202: Boolean
+            document: HttpResponse,
+            cacheState: CacheState?,
+            spotifyRequest: SpotifyRequest,
+            retry202: Boolean
     ): String? {
         val statusCode = document.responseCode
 
@@ -82,7 +82,7 @@ abstract class SpotifyEndpoint(val api: SpotifyAPI) {
         document.headers.find { it.key == "Cache-Control" }?.also { cacheControlHeader ->
             if (api.useCache) {
                 cache[spotifyRequest] = (cacheState ?: CacheState(
-                    responseBody, document.headers
+                        responseBody, document.headers
                         .find { it.key == "ETag" }?.value
                 )).update(cacheControlHeader.value)
             }
@@ -100,16 +100,17 @@ abstract class SpotifyEndpoint(val api: SpotifyAPI) {
     }
 
     private fun createConnection(
-        url: String,
-        body: String? = null,
-        method: HttpRequestMethod = HttpRequestMethod.GET,
-        contentType: String? = null
+            url: String,
+            body: String? = null,
+            method: HttpRequestMethod = HttpRequestMethod.GET,
+            contentType: String? = null
     ) = HttpConnection(
-        url,
-        method,
-        body,
-        contentType,
-        HttpHeader("Authorization", "Bearer ${api.token.accessToken}")
+            url,
+            method,
+            body,
+            contentType,
+            HttpHeader("Authorization", "Bearer ${api.token.accessToken}"),
+            api = api
     )
 
     internal fun <T> toAction(supplier: Supplier<T>) = SpotifyRestAction(api, supplier)
@@ -150,9 +151,9 @@ internal class SpotifyCache {
 }
 
 internal data class SpotifyRequest(
-    val url: String,
-    val method: HttpRequestMethod,
-    val body: String?
+        val url: String,
+        val method: HttpRequestMethod,
+        val body: String?
 )
 
 internal data class CacheState(val data: String, val eTag: String?, val expireBy: Long = 0) {
@@ -164,7 +165,7 @@ internal data class CacheState(val data: String, val eTag: String?, val expireBy
         val time = group?.getOrNull(1)?.toLongOrNull() ?: throw BadRequestException("Unable to match regex")
 
         return this.copy(
-            expireBy = System.currentTimeMillis() + 1000 * time
+                expireBy = System.currentTimeMillis() + 1000 * time
         )
     }
 }

src/main/kotlin/com/adamratzman/spotify/utils/HttpConnection.kt

@@ -1,21 +1,23 @@
 /* Created by Adam Ratzman (2018) */
 package com.adamratzman.spotify.utils
 
+import com.adamratzman.spotify.main.SpotifyAPI
 import java.net.HttpURLConnection
 import java.net.URL
 
 internal enum class HttpRequestMethod { GET, POST, PUT, DELETE }
 internal data class HttpHeader(val key: String, val value: String)
 
 internal class HttpConnection(
-    private val url: String,
-    private val method: HttpRequestMethod,
-    private val body: String?,
-    private val contentType: String?,
-    private vararg val headers: HttpHeader
+        private val url: String,
+        private val method: HttpRequestMethod,
+        private val body: String?,
+        private val contentType: String?,
+        private vararg val headers: HttpHeader,
+        val api: SpotifyAPI? = null
 ) {
 
-    fun execute(vararg additionalHeaders: HttpHeader?): HttpResponse {
+    fun execute(vararg additionalHeaders: HttpHeader?, retryIf502: Boolean = true): HttpResponse {
         val connection = URL(url).openConnection() as HttpURLConnection
         connection.requestMethod = method.toString()
 
@@ -36,18 +38,36 @@ internal class HttpConnection(
         connection.connect()
 
         val responseCode = connection.responseCode
+
+        if (responseCode == 502 && retryIf502) {
+            api?.logger?.logWarning("Received 502 (Invalid response) for URL $url and $this\nRetrying..")
+            return execute(*additionalHeaders, retryIf502 = false)
+        }
+
+        if (responseCode == 502 && !retryIf502) api?.logger?.logInfo("502 retry successful for $this")
+
         val body = (connection.errorStream ?: connection.inputStream).bufferedReader().use {
             val text = it.readText()
             it.close()
             text
         }
 
         return HttpResponse(
-            responseCode = responseCode,
-            body = body,
-            headers = connection.headerFields.keys.filterNotNull().map { HttpHeader(it, connection.getHeaderField(it)) }
+                responseCode = responseCode,
+                body = body,
+                headers = connection.headerFields.keys.filterNotNull().map { HttpHeader(it, connection.getHeaderField(it)) }
         ).also { connection.disconnect() }
     }
+
+    override fun toString(): String {
+        return """HttpConnection  (
+            |url=$url,
+            |method=$method,
+            |body=$body,
+            |contentType=$contentType,
+            |headers=${headers.toList()}
+            |  )""".trimMargin()
+    }
 }
 
 internal data class HttpResponse(val responseCode: Int, val body: String, val headers: List<HttpHeader>)