kopia lustrzana https://github.com/vitorpamplona/amethyst
171 wiersze
6.9 KiB
Kotlin
171 wiersze
6.9 KiB
Kotlin
/**
|
|
* Copyright (c) 2024 Vitor Pamplona
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
* this software and associated documentation files (the "Software"), to deal in
|
|
* the Software without restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
|
|
* Software, and to permit persons to whom the Software is furnished to do so,
|
|
* subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
package com.vitorpamplona.amethyst.service
|
|
|
|
import android.util.Log
|
|
import android.util.LruCache
|
|
import com.vitorpamplona.quartz.encoders.Nip11RelayInformation
|
|
import com.vitorpamplona.quartz.utils.TimeUtils
|
|
import kotlinx.coroutines.CancellationException
|
|
import okhttp3.Call
|
|
import okhttp3.Callback
|
|
import okhttp3.Request
|
|
import okhttp3.Response
|
|
import java.io.IOException
|
|
|
|
object Nip11CachedRetriever {
|
|
open class RetrieveResult(val time: Long)
|
|
|
|
class RetrieveResultError(val error: Nip11Retriever.ErrorCode, val msg: String? = null) : RetrieveResult(TimeUtils.now())
|
|
|
|
class RetrieveResultSuccess(val data: Nip11RelayInformation) : RetrieveResult(TimeUtils.now())
|
|
|
|
val relayInformationDocumentCache = LruCache<String, RetrieveResult?>(100)
|
|
val retriever = Nip11Retriever()
|
|
|
|
fun getFromCache(dirtyUrl: String): Nip11RelayInformation? {
|
|
val result = relayInformationDocumentCache.get(retriever.cleanUrl(dirtyUrl)) ?: return null
|
|
if (result is RetrieveResultSuccess) return result.data
|
|
return null
|
|
}
|
|
|
|
suspend fun loadRelayInfo(
|
|
dirtyUrl: String,
|
|
onInfo: (Nip11RelayInformation) -> Unit,
|
|
onError: (String, Nip11Retriever.ErrorCode, String?) -> Unit,
|
|
) {
|
|
val url = retriever.cleanUrl(dirtyUrl)
|
|
val doc = relayInformationDocumentCache.get(url)
|
|
|
|
if (doc != null) {
|
|
if (doc is RetrieveResultSuccess) {
|
|
onInfo(doc.data)
|
|
} else if (doc is RetrieveResultError) {
|
|
if (TimeUtils.now() - doc.time < TimeUtils.ONE_HOUR) {
|
|
onError(dirtyUrl, doc.error, null)
|
|
} else {
|
|
Nip11Retriever()
|
|
.loadRelayInfo(
|
|
url = url,
|
|
dirtyUrl = dirtyUrl,
|
|
onInfo = {
|
|
relayInformationDocumentCache.put(url, RetrieveResultSuccess(it))
|
|
onInfo(it)
|
|
},
|
|
onError = { dirtyUrl, code, errorMsg ->
|
|
relayInformationDocumentCache.put(url, RetrieveResultError(code, errorMsg))
|
|
onError(url, code, errorMsg)
|
|
},
|
|
)
|
|
}
|
|
}
|
|
} else {
|
|
Nip11Retriever()
|
|
.loadRelayInfo(
|
|
url = url,
|
|
dirtyUrl = dirtyUrl,
|
|
onInfo = {
|
|
relayInformationDocumentCache.put(url, RetrieveResultSuccess(it))
|
|
onInfo(it)
|
|
},
|
|
onError = { dirtyUrl, code, errorMsg ->
|
|
relayInformationDocumentCache.put(url, RetrieveResultError(code, errorMsg))
|
|
onError(url, code, errorMsg)
|
|
},
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
class Nip11Retriever {
|
|
enum class ErrorCode {
|
|
FAIL_TO_ASSEMBLE_URL,
|
|
FAIL_TO_REACH_SERVER,
|
|
FAIL_TO_PARSE_RESULT,
|
|
FAIL_WITH_HTTP_STATUS,
|
|
}
|
|
|
|
fun cleanUrl(dirtyUrl: String): String {
|
|
return if (dirtyUrl.contains("://")) {
|
|
dirtyUrl.replace("wss://", "https://").replace("ws://", "http://")
|
|
} else {
|
|
"https://$dirtyUrl"
|
|
}
|
|
}
|
|
|
|
suspend fun loadRelayInfo(
|
|
url: String,
|
|
dirtyUrl: String,
|
|
onInfo: (Nip11RelayInformation) -> Unit,
|
|
onError: (String, ErrorCode, String?) -> Unit,
|
|
) {
|
|
checkNotInMainThread()
|
|
try {
|
|
val request: Request =
|
|
Request.Builder().header("Accept", "application/nostr+json").url(url).build()
|
|
val isLocalHost = dirtyUrl.startsWith("ws://127.0.0.1") || dirtyUrl.startsWith("ws://localhost")
|
|
|
|
HttpClientManager.getHttpClient(useProxy = !isLocalHost)
|
|
.newCall(request)
|
|
.enqueue(
|
|
object : Callback {
|
|
override fun onResponse(
|
|
call: Call,
|
|
response: Response,
|
|
) {
|
|
checkNotInMainThread()
|
|
response.use {
|
|
val body = it.body.string()
|
|
try {
|
|
if (it.isSuccessful) {
|
|
onInfo(Nip11RelayInformation.fromJson(body))
|
|
} else {
|
|
onError(dirtyUrl, ErrorCode.FAIL_WITH_HTTP_STATUS, it.code.toString())
|
|
}
|
|
} catch (e: Exception) {
|
|
if (e is CancellationException) throw e
|
|
Log.e(
|
|
"RelayInfoFail",
|
|
"Resulting Message from Relay $dirtyUrl in not parseable: $body",
|
|
e,
|
|
)
|
|
onError(dirtyUrl, ErrorCode.FAIL_TO_PARSE_RESULT, e.message)
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onFailure(
|
|
call: Call,
|
|
e: IOException,
|
|
) {
|
|
Log.e("RelayInfoFail", "$dirtyUrl unavailable", e)
|
|
onError(dirtyUrl, ErrorCode.FAIL_TO_REACH_SERVER, e.message)
|
|
}
|
|
},
|
|
)
|
|
} catch (e: Exception) {
|
|
if (e is CancellationException) throw e
|
|
Log.e("RelayInfoFail", "Invalid URL $dirtyUrl", e)
|
|
onError(dirtyUrl, ErrorCode.FAIL_TO_ASSEMBLE_URL, e.message)
|
|
}
|
|
}
|
|
}
|