aboutsummaryrefslogtreecommitdiff
path: root/src/main/kotlin/apis/UrsaManager.kt
blob: 13f7aef751dde096b485429e719837b52ef58935 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package moe.nea.firmament.apis

import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.withContext
import moe.nea.firmament.Firmament
import net.minecraft.client.MinecraftClient
import java.time.Duration
import java.time.Instant
import java.util.*

object UrsaManager {
    private data class Token(
        val validUntil: Instant,
        val token: String,
        val obtainedFrom: String,
    ) {
        fun isValid(host: String) = Instant.now().plusSeconds(60) < validUntil && obtainedFrom == host
    }

    private var currentToken: Token? = null
    private val lock = Mutex()
    private fun getToken(host: String) = currentToken?.takeIf { it.isValid(host) }

    suspend fun request(path: List<String>): HttpResponse {
        var didLock = false
        try {
            val host = "ursa.notenoughupdates.org"
            var token = getToken(host)
            if (token == null) {
                lock.lock()
                didLock = true
                token = getToken(host)
            }
            val response = Firmament.httpClient.get {
                url {
                    this.host = host
                    appendPathSegments(path, encodeSlash = true)
                }
                if (token == null) {
                    withContext(Dispatchers.IO) {
                        val mc = MinecraftClient.getInstance()
                        val serverId = UUID.randomUUID().toString()
                        mc.sessionService.joinServer(mc.session.uuidOrNull, mc.session.accessToken, serverId)
                        header("x-ursa-username", mc.session.username)
                        header("x-ursa-serverid", serverId)
                    }
                } else {
                    header("x-ursa-token", token.token)
                }
            }
            val savedToken = response.headers["x-ursa-token"]
            if (savedToken != null) {
                val validUntil = response.headers["x-ursa-expires"]?.toLongOrNull()?.let { Instant.ofEpochMilli(it) }
                    ?: (Instant.now() + Duration.ofMinutes(55))
                currentToken = Token(validUntil, savedToken, host)
            }
            if (response.status.value != 200) {
                Firmament.logger.error("Failed to contact ursa minor: ${response.bodyAsText()}")
            }
            return response
        } finally {
            if (didLock)
                lock.unlock()
        }
    }
}