Handle twitch token invalidation

onoderis · onoderis · commit 4aa65597d4d9 · 2023-09-11T00:55:18.000+06:00
diff --git a/src/main/kotlin/failchat/AppStateManager.kt b/src/main/kotlin/failchat/AppStateManager.kt
@@ -27,7 +27,7 @@ import failchat.goodgame.GgChatClient
 import failchat.goodgame.GgViewersCountLoader
 import failchat.peka2tv.Peka2tvApiClient
 import failchat.peka2tv.Peka2tvChatClient
-import failchat.twitch.TwitchApiClient
+import failchat.twitch.TokenAwareTwitchApiClient
 import failchat.twitch.TwitchChatClient
 import failchat.twitch.TwitchViewersCountLoader
 import failchat.util.CoroutineExceptionLogger
@@ -62,7 +62,7 @@ class AppStateManager(private val kodein: DirectDI) {
 
     private val messageIdGenerator: MessageIdGenerator = kodein.instance()
     private val peka2tvApiClient: Peka2tvApiClient = kodein.instance()
-    private val twitchApiClient: TwitchApiClient = kodein.instance()
+    private val twitchApiClient: TokenAwareTwitchApiClient = kodein.instance()
     private val goodgameApiClient: GgApiClient = kodein.instance()
     private val configLoader: ConfigLoader = kodein.instance()
     private val ignoreFilter: IgnoreFilter = kodein.instance()
diff --git a/src/main/kotlin/failchat/ConfigKeys.kt b/src/main/kotlin/failchat/ConfigKeys.kt
@@ -17,6 +17,8 @@ object ConfigKeys {
     object Twitch {
         const val enabled = "twitch.enabled"
         const val channel = "twitch.channel"
+        const val clientId = "twitch.client-id"
+        const val clientSecret = "twitch.client-secret"
         const val expiresAt = "twitch.bearer-token-expires-at"
         const val token = "twitch.bearer-token"
     }
diff --git a/src/main/kotlin/failchat/Kodein.kt b/src/main/kotlin/failchat/Kodein.kt
@@ -74,6 +74,7 @@ import failchat.twitch.FfzEmoticonHandler
 import failchat.twitch.SevenTvApiClient
 import failchat.twitch.SevenTvGlobalEmoticonLoadConfiguration
 import failchat.twitch.SevenTvGlobalEmoticonLoader
+import failchat.twitch.TokenAwareTwitchApiClient
 import failchat.twitch.TwitchApiClient
 import failchat.twitch.TwitchBadgeHandler
 import failchat.twitch.TwitchChatClient
@@ -250,7 +251,7 @@ val kodein = DI.direct {
     bind<BadgeManager>() with singleton {
         BadgeManager(
                 instance<BadgeStorage>(),
-                instance<TwitchApiClient>(),
+                instance<TokenAwareTwitchApiClient>(),
                 instance<Peka2tvApiClient>()
         )
     }
@@ -388,12 +389,18 @@ val kodein = DI.direct {
         TwitchApiClient(
                 httpClient = instance<OkHttpClient>(),
                 objectMapper = instance<ObjectMapper>(),
-                clientId = config.getString("twitch.client-id"),
-                clientSecret = config.getString("twitch.client-secret"),
+                clientId = config.getString(ConfigKeys.Twitch.clientId)
+        )
+    }
+    bind<TokenAwareTwitchApiClient>() with singleton {
+        val config = instance<Configuration>()
+        TokenAwareTwitchApiClient(
+                twitchApiClient = instance(),
+                clientSecret = config.getString(ConfigKeys.Twitch.clientSecret),
                 tokenContainer = ConfigurationTokenContainer(instance<Configuration>())
         )
     }
-    bind<TwitchGlobalEmoticonLoader>() with singleton { TwitchGlobalEmoticonLoader(instance<TwitchApiClient>()) }
+    bind<TwitchGlobalEmoticonLoader>() with singleton { TwitchGlobalEmoticonLoader(instance<TokenAwareTwitchApiClient>()) }
     bind<TwitchEmoticonLoadConfiguration>() with singleton {
         TwitchEmoticonLoadConfiguration(
                 instance<TwitchGlobalEmoticonLoader>()
@@ -419,7 +426,7 @@ val kodein = DI.direct {
         )
     }
     bind<TwitchViewersCountLoader>() with factory { channelName: String ->
-        TwitchViewersCountLoader(channelName, instance<TwitchApiClient>())
+        TwitchViewersCountLoader(channelName, instance<TokenAwareTwitchApiClient>())
     }
     bind<TwitchBadgeHandler>() with singleton {
         TwitchBadgeHandler(instance<BadgeFinder>())
diff --git a/src/main/kotlin/failchat/chat/badge/BadgeManager.kt b/src/main/kotlin/failchat/chat/badge/BadgeManager.kt
@@ -4,7 +4,7 @@ import failchat.chat.badge.BadgeOrigin.PEKA2TV
 import failchat.chat.badge.BadgeOrigin.TWITCH_CHANNEL
 import failchat.chat.badge.BadgeOrigin.TWITCH_GLOBAL
 import failchat.peka2tv.Peka2tvApiClient
-import failchat.twitch.TwitchApiClient
+import failchat.twitch.TokenAwareTwitchApiClient
 import failchat.util.CoroutineExceptionLogger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Deferred
@@ -15,7 +15,7 @@ import mu.KLogging
 
 class BadgeManager(
         private val badgeStorage: BadgeStorage,
-        private val twitchApiClient: TwitchApiClient,
+        private val twitchApiClient: TokenAwareTwitchApiClient,
         private val peka2tvApiClient: Peka2tvApiClient
 ) {
 
diff --git a/src/main/kotlin/failchat/twitch/ConfigurationTokenContainer.kt b/src/main/kotlin/failchat/twitch/ConfigurationTokenContainer.kt
@@ -23,7 +23,7 @@ class ConfigurationTokenContainer(
 
     override fun setToken(token: HelixApiToken) {
         config.setProperty(ConfigKeys.Twitch.token, token.value)
-        config.setProperty(ConfigKeys.Twitch.expiresAt, token.ttl.toEpochMilli())
+        config.setProperty(ConfigKeys.Twitch.expiresAt, token.expiresAt.toEpochMilli())
         logger.info("Helix token was saved to configuration")
     }
 }
diff --git a/src/main/kotlin/failchat/twitch/HelixApiToken.kt b/src/main/kotlin/failchat/twitch/HelixApiToken.kt
@@ -4,5 +4,5 @@ import java.time.Instant
 
 data class HelixApiToken(
         val value: String,
-        val ttl: Instant
+        val expiresAt: Instant
 )
diff --git a/src/main/kotlin/failchat/twitch/InvalidTokenException.kt b/src/main/kotlin/failchat/twitch/InvalidTokenException.kt
@@ -0,0 +1,3 @@
+package failchat.twitch
+
+class InvalidTokenException : RuntimeException("Invalid twitch token")
diff --git a/src/main/kotlin/failchat/twitch/TokenAwareTwitchApiClient.kt b/src/main/kotlin/failchat/twitch/TokenAwareTwitchApiClient.kt
@@ -0,0 +1,54 @@
+package failchat.twitch
+
+import failchat.chat.badge.ImageBadge
+import mu.KLogging
+
+/**
+ * The [TwitchApiClient] wrapper that:
+ * - reuses existing token.
+ * - retries the request if the token is expired.
+ * */
+class TokenAwareTwitchApiClient(
+        private val twitchApiClient: TwitchApiClient,
+        private val clientSecret: String,
+        private val tokenContainer: HelixTokenContainer
+) {
+
+    private companion object : KLogging()
+
+    suspend fun getUserId(userName: String): Long {
+        return doWithRetryOnAuthError(twitchApiClient, clientSecret, tokenContainer) {
+            twitchApiClient.getUserId(userName, it)
+        }
+    }
+
+    suspend fun getViewersCount(userName: String): Int {
+        return doWithRetryOnAuthError(twitchApiClient, clientSecret, tokenContainer) {
+            twitchApiClient.getViewersCount(userName, it)
+        }
+    }
+
+    suspend fun getGlobalEmoticons(): List<TwitchEmoticon> {
+        return doWithRetryOnAuthError(twitchApiClient, clientSecret, tokenContainer) {
+            twitchApiClient.getGlobalEmoticons(it)
+        }
+    }
+
+    suspend fun getFirstLiveChannelName(): String {
+        return doWithRetryOnAuthError(twitchApiClient, clientSecret, tokenContainer) {
+            twitchApiClient.getFirstLiveChannelName(it)
+        }
+    }
+
+    suspend fun getGlobalBadges(): Map<TwitchBadgeId, ImageBadge> {
+        return doWithRetryOnAuthError(twitchApiClient, clientSecret, tokenContainer) {
+            twitchApiClient.getGlobalBadges(it)
+        }
+    }
+
+    suspend fun getChannelBadges(channelId: Long): Map<TwitchBadgeId, ImageBadge> {
+        return doWithRetryOnAuthError(twitchApiClient, clientSecret, tokenContainer) {
+            twitchApiClient.getChannelBadges(channelId, it)
+        }
+    }
+}
diff --git a/src/main/kotlin/failchat/twitch/TwitchApiClient.kt b/src/main/kotlin/failchat/twitch/TwitchApiClient.kt
@@ -23,9 +23,7 @@ import kotlin.reflect.KClass
 class TwitchApiClient(
         private val httpClient: OkHttpClient,
         private val objectMapper: ObjectMapper,
-        private val clientId: String,
-        private val clientSecret: String,
-        private val tokenContainer: HelixTokenContainer
+        private val clientId: String
 ) {
 
     private companion object : KLogging() {
@@ -39,9 +37,9 @@ class TwitchApiClient(
     }
 
     // https://dev.twitch.tv/docs/api/reference/#get-users
-    suspend fun getUserId(userName: String): Long {
+    suspend fun getUserId(userName: String, token: String): Long {
         val url = usersUrl.newBuilder().addQueryParameter("login", userName).build()
-        val response = doRequest(url, UsersResponse::class)
+        val response = doRequest(url, token, UsersResponse::class)
 
         if (response.data.isEmpty()) {
             throw ChannelNotFoundException("Twitch user $userName not found")
@@ -51,9 +49,9 @@ class TwitchApiClient(
     }
 
     // https://dev.twitch.tv/docs/api/reference/#get-streams
-    suspend fun getViewersCount(userName: String): Int {
+    suspend fun getViewersCount(userName: String, token: String): Int {
         val url = streamsUrl.newBuilder().addQueryParameter("user_login", userName).build()
-        val response = doRequest(url, StreamsResponse::class)
+        val response = doRequest(url, token, StreamsResponse::class)
 
         if (response.data.isEmpty()) {
             throw ChannelOfflineException(Origin.TWITCH, userName)
@@ -63,8 +61,8 @@ class TwitchApiClient(
     }
 
     // https://dev.twitch.tv/docs/api/reference/#get-global-emotes
-    suspend fun getGlobalEmoticons(): List<TwitchEmoticon> {
-        val response = doRequest(globalEmotesUrl, EmotesResponse::class)
+    suspend fun getGlobalEmoticons(token: String): List<TwitchEmoticon> {
+        val response = doRequest(globalEmotesUrl, token, EmotesResponse::class)
         return response.data.map {
             TwitchEmoticon(
                     twitchId = it.id,
@@ -74,28 +72,28 @@ class TwitchApiClient(
     }
 
     // https://dev.twitch.tv/docs/api/reference/#get-streams
-    suspend fun getFirstLiveChannelName(): String {
+    suspend fun getFirstLiveChannelName(token: String): String {
         val url = streamsUrl.newBuilder()
                 .addQueryParameter("type", "live")
                 .addQueryParameter("first", "1")
                 .build()
-        val response = doRequest(url, StreamsResponse::class)
+        val response = doRequest(url, token, StreamsResponse::class)
         return response.data.first().userLogin
     }
 
-    suspend fun getGlobalBadges(): Map<TwitchBadgeId, ImageBadge> {
+    suspend fun getGlobalBadges(token: String): Map<TwitchBadgeId, ImageBadge> {
         // https://dev.twitch.tv/docs/api/reference/#get-global-chat-badges
-        return getBadges(globalBadgesUrl)
+        return getBadges(globalBadgesUrl, token)
     }
 
-    suspend fun getChannelBadges(channelId: Long): Map<TwitchBadgeId, ImageBadge> {
+    suspend fun getChannelBadges(channelId: Long, token: String): Map<TwitchBadgeId, ImageBadge> {
         // https://dev.twitch.tv/docs/api/reference/#get-channel-chat-badges
         val url = channelBadgesUrl.newBuilder().addQueryParameter("broadcaster_id", channelId.toString()).build()
-        return getBadges(url)
+        return getBadges(url, token)
     }
 
-    private suspend fun getBadges(url: HttpUrl): Map<TwitchBadgeId, ImageBadge> {
-        val badgesResponse = doRequest(url, BadgesResponse::class)
+    private suspend fun getBadges(url: HttpUrl, token: String): Map<TwitchBadgeId, ImageBadge> {
+        val badgesResponse = doRequest(url, token, BadgesResponse::class)
 
         return badgesResponse.data
                 .flatMap { data ->
@@ -108,9 +106,7 @@ class TwitchApiClient(
                 }
     }
 
-    private suspend fun <T : Any> doRequest(url: HttpUrl, responseType: KClass<T>): T {
-        val token = getOrGenerateToken()
-
+    private suspend fun <T : Any> doRequest(url: HttpUrl, token: String, responseType: KClass<T>): T {
         val request = Request.Builder()
                 .get()
                 .url(url)
@@ -119,27 +115,17 @@ class TwitchApiClient(
                 .build()
 
         return httpClient.newCall(request).await().use { response ->
+            if (response.code == 401) {
+                throw InvalidTokenException()
+            }
             if (!response.isSuccessful) {
                 throw UnexpectedResponseCodeException(response.code, url.toString())
             }
             objectMapper.readValue(response.nonNullBody.charStream(), responseType.java)
         }
     }
 
-    private suspend fun getOrGenerateToken(): String {
-        val token = tokenContainer.getToken()
-
-        if (token == null) {
-            val newToken = generateToken()
-            tokenContainer.setToken(newToken)
-            return newToken.value
-        }
-
-        logger.info("Helix token was retrieved from configuration")
-        return token.value
-    }
-
-    private suspend fun generateToken(): HelixApiToken {
+    suspend fun generateToken(clientSecret: String): HelixApiToken {
         val request = Request.Builder()
                 .url(oauthUrl)
                 .post(FormBody.Builder()
@@ -153,15 +139,15 @@ class TwitchApiClient(
 
         val response = httpClient.newCall(request).await()
         if (!response.isSuccessful) {
-            throw UnexpectedResponseCodeException(200, oauthUrl)
+            throw UnexpectedResponseCodeException(response.code, oauthUrl)
         }
 
         val body = response.nonNullBody.string()
         val authResponse = objectMapper.readValue<AuthResponse>(body)
 
         val token = HelixApiToken(
                 value = authResponse.accessToken,
-                ttl = Instant.now() + Duration.ofSeconds(authResponse.expiresIn) - Duration.ofSeconds(60)
+                expiresAt = Instant.now() + Duration.ofSeconds(authResponse.expiresIn) - Duration.ofSeconds(60)
         )
         logger.info("New helix token was generated")
         return token
diff --git a/src/main/kotlin/failchat/twitch/TwitchGlobalEmoticonLoader.kt b/src/main/kotlin/failchat/twitch/TwitchGlobalEmoticonLoader.kt
@@ -9,7 +9,7 @@ import java.util.concurrent.CompletableFuture
 
 /** Uses official twitch API. */
 class TwitchGlobalEmoticonLoader(
-        private val twitchClient: TwitchApiClient
+        private val twitchClient: TokenAwareTwitchApiClient
 ) : EmoticonBulkLoader<TwitchEmoticon> {
 
     override val origin = Origin.TWITCH
diff --git a/src/main/kotlin/failchat/twitch/TwitchRetries.kt b/src/main/kotlin/failchat/twitch/TwitchRetries.kt
@@ -0,0 +1,26 @@
+package failchat.twitch
+
+import mu.KotlinLogging
+
+val logger = KotlinLogging.logger {}
+
+suspend fun <T> doWithRetryOnAuthError(
+        twitchApiClient: TwitchApiClient,
+        clientSecret: String,
+        tokenContainer: HelixTokenContainer,
+        operation: suspend (String) -> T
+): T {
+    val existingToken = tokenContainer.getToken()
+
+    if (existingToken != null) {
+        try {
+            return operation(existingToken.value)
+        } catch (e: InvalidTokenException) {
+            logger.info("Invalid twitch token")
+        }
+    }
+
+    val newToken = twitchApiClient.generateToken(clientSecret)
+    tokenContainer.setToken(newToken)
+    return operation(newToken.value)
+}
diff --git a/src/main/kotlin/failchat/twitch/TwitchViewersCountLoader.kt b/src/main/kotlin/failchat/twitch/TwitchViewersCountLoader.kt
@@ -9,7 +9,7 @@ import java.util.concurrent.CompletableFuture
 
 class TwitchViewersCountLoader(
         private val userName: String,
-        private val twitchClient: TwitchApiClient
+        private val twitchClient: TokenAwareTwitchApiClient
 ) : ViewersCountLoader {
 
     override val origin = Origin.TWITCH
diff --git a/src/main/kotlin/failchat/util/Coroutines.kt b/src/main/kotlin/failchat/util/Coroutines.kt
@@ -13,7 +13,7 @@ object CoroutineExceptionLogger : CoroutineExceptionHandler {
     override val key = CoroutineExceptionHandler.Key
 
     override fun handleException(context: CoroutineContext, exception: Throwable) {
-        logger.warn("Uncaught exception in coroutine '{}'", context[CoroutineName.Key]?.name, exception)
+        logger.error(exception) { "Uncaught exception in coroutine '${context[CoroutineName.Key]?.name}'" }
     }
 }
 
diff --git a/src/test/kotlin/failchat/twitch/TwitchApiClientTest.kt b/src/test/kotlin/failchat/twitch/TwitchApiClientTest.kt
@@ -1,5 +1,6 @@
 package failchat.twitch
 
+import failchat.ConfigKeys
 import failchat.assertRequestToUrlReturns200
 import failchat.exception.ChannelNotFoundException
 import failchat.exception.ChannelOfflineException
@@ -22,11 +23,13 @@ class TwitchApiClientTest {
         const val nonExistingUserName = "fail_chatbot2"
     }
 
-    private val apiClient = TwitchApiClient(
-            okHttpClient,
-            testObjectMapper,
-            userHomeConfig.getString("twitch.client-id"),
-            userHomeConfig.getString("twitch.client-secret"),
+    private val apiClient: TokenAwareTwitchApiClient = TokenAwareTwitchApiClient(
+            TwitchApiClient(
+                    okHttpClient,
+                    testObjectMapper,
+                    userHomeConfig.getString(ConfigKeys.Twitch.clientId),
+            ),
+            userHomeConfig.getString(ConfigKeys.Twitch.clientSecret),
             ConfigurationTokenContainer(userHomeConfig)
     )
 
diff --git a/src/test/kotlin/failchat/twitch/TwitchRetriesTest.kt b/src/test/kotlin/failchat/twitch/TwitchRetriesTest.kt

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,8 @@ object ConfigKeys {`
`17`	`17`	`object Twitch {`
`18`	`18`	`const val enabled = "twitch.enabled"`
`19`	`19`	`const val channel = "twitch.channel"`
	`20`	`+ const val clientId = "twitch.client-id"`
	`21`	`+ const val clientSecret = "twitch.client-secret"`
`20`	`22`	`const val expiresAt = "twitch.bearer-token-expires-at"`
`21`	`23`	`const val token = "twitch.bearer-token"`
`22`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class ConfigurationTokenContainer(`
`23`	`23`
`24`	`24`	`override fun setToken(token: HelixApiToken) {`
`25`	`25`	`config.setProperty(ConfigKeys.Twitch.token, token.value)`
`26`		`- config.setProperty(ConfigKeys.Twitch.expiresAt, token.ttl.toEpochMilli())`
	`26`	`+ config.setProperty(ConfigKeys.Twitch.expiresAt, token.expiresAt.toEpochMilli())`
`27`	`27`	`logger.info("Helix token was saved to configuration")`
`28`	`28`	`}`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,5 +4,5 @@ import java.time.Instant`
`4`	`4`
`5`	`5`	`data class HelixApiToken(`
`6`	`6`	`val value: String,`
`7`		`- val ttl: Instant`
	`7`	`+ val expiresAt: Instant`
`8`	`8`	`)`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+package failchat.twitch`
	`2`	`+`
	`3`	`+class InvalidTokenException : RuntimeException("Invalid twitch token")`