fix: check if RGS url is reachable

Author: jvsena42

app/src/main/java/to/bitkit/di/HttpModule.kt

@@ -12,10 +12,14 @@ import io.ktor.client.plugins.defaultRequest
 import io.ktor.client.plugins.logging.LogLevel
 import io.ktor.client.plugins.logging.Logging
 import io.ktor.client.plugins.logging.LoggingConfig
+import io.ktor.client.request.head
 import io.ktor.http.ContentType
 import io.ktor.http.contentType
+import io.ktor.http.isSuccess
 import io.ktor.serialization.kotlinx.json.json
 import kotlinx.serialization.json.Json
+import to.bitkit.utils.UrlValidator
+import to.bitkit.utils.AppError
 import to.bitkit.utils.Logger
 import javax.inject.Singleton
 import io.ktor.client.plugins.logging.Logger as KtorLogger
@@ -43,6 +47,17 @@ object HttpModule {
         }
     }
 
+    @Provides
+    @Singleton
+    fun provideUrlValidator(httpClient: HttpClient) = UrlValidator { url ->
+        runCatching {
+            val response = httpClient.head(url)
+            if (!response.status.isSuccess()) {
+                throw AppError("Server returned '${response.status}'")
+            }
+        }
+    }
+
     @Suppress("MagicNumber")
     private fun HttpTimeoutConfig.defaultTimeoutConfig() {
         requestTimeoutMillis = 60_000

app/src/main/java/to/bitkit/repositories/LightningRepo.kt

@@ -79,6 +79,7 @@ import to.bitkit.services.NodeEventHandler
 import to.bitkit.utils.AppError
 import to.bitkit.utils.Logger
 import to.bitkit.utils.ServiceError
+import to.bitkit.utils.UrlValidator
 import java.io.File
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicBoolean
@@ -105,6 +106,7 @@ class LightningRepo @Inject constructor(
     private val preActivityMetadataRepo: PreActivityMetadataRepo,
     private val connectivityRepo: ConnectivityRepo,
     private val vssBackupClientLdk: VssBackupClientLdk,
+    private val urlValidator: UrlValidator,
 ) {
     private val _lightningState = MutableStateFlow(LightningState())
     val lightningState = _lightningState.asStateFlow()
@@ -620,6 +622,8 @@ class LightningRepo @Inject constructor(
         runCatching {
             Logger.info("Changing ldk-node RGS server to: '$newRgsUrl'", context = TAG)
 
+            validateRgsUrl(newRgsUrl).onFailure { return@runCatching Result.failure(it) }
+
             waitForNodeToStop().onFailure { return@runCatching Result.failure(it) }
             stop().onFailure {
                 Logger.error("Failed to stop node during RGS server change", it, context = TAG)
@@ -645,6 +649,14 @@ class LightningRepo @Inject constructor(
         }
     }
 
+    private suspend fun validateRgsUrl(url: String): Result<Unit> = withContext(bgDispatcher) {
+        val initialTimestamp = 0
+        val testUrl = "${url.trimEnd('/')}/$initialTimestamp"
+        urlValidator.validate(testUrl).onFailure {
+            Logger.warn("RGS server unreachable at '$testUrl'", it, context = TAG)
+        }
+    }
+
     suspend fun getBalanceForAddressType(addressType: AddressType): Result<ULong> = withContext(bgDispatcher) {
         executeWhenNodeRunning("getBalanceForAddressType") {
             runCatching {

app/src/main/java/to/bitkit/utils/UrlValidator.kt

@@ -0,0 +1,5 @@
+package to.bitkit.utils
+
+fun interface UrlValidator {
+    suspend fun validate(url: String): Result<Unit>
+}

app/src/test/java/to/bitkit/repositories/LightningRepoTest.kt

@@ -51,6 +51,7 @@ import to.bitkit.services.LightningService
 import to.bitkit.services.LnurlService
 import to.bitkit.services.LspNotificationsService
 import to.bitkit.test.BaseUnitTest
+import to.bitkit.utils.UrlValidator
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
@@ -72,6 +73,7 @@ class LightningRepoTest : BaseUnitTest() {
     private val lnurlService = mock<LnurlService>()
     private val connectivityRepo = mock<ConnectivityRepo>()
     private val vssBackupClientLdk = mock<VssBackupClientLdk>()
+    private val urlValidator = UrlValidator { Result.success(Unit) }
 
     @Before
     fun setUp() = runBlocking {
@@ -94,6 +96,7 @@ class LightningRepoTest : BaseUnitTest() {
             preActivityMetadataRepo = preActivityMetadataRepo,
             connectivityRepo = connectivityRepo,
             vssBackupClientLdk = vssBackupClientLdk,
+            urlValidator = urlValidator,
         )
     }
 
@@ -538,6 +541,38 @@ class LightningRepoTest : BaseUnitTest() {
         assertTrue(result.isFailure)
     }
 
+    @Test
+    fun `restartWithRgsServer should fail when url is unreachable`() = test {
+        val failingValidator = UrlValidator { Result.failure(Exception("DNS resolution failed")) }
+        val sutWithFailingValidator = LightningRepo(
+            bgDispatcher = testDispatcher,
+            lightningService = lightningService,
+            settingsStore = settingsStore,
+            coreService = coreService,
+            lspNotificationsService = lspNotificationsService,
+            firebaseMessaging = firebaseMessaging,
+            keychain = keychain,
+            lnurlService = lnurlService,
+            cacheStore = cacheStore,
+            preActivityMetadataRepo = preActivityMetadataRepo,
+            connectivityRepo = connectivityRepo,
+            vssBackupClientLdk = vssBackupClientLdk,
+            urlValidator = failingValidator,
+        )
+        sutWithFailingValidator.setInitNodeLifecycleState()
+        whenever(lightningService.node).thenReturn(mock())
+        whenever(lightningService.sync()).thenReturn(Unit)
+        val blocktank = mock<BlocktankService>()
+        whenever(coreService.blocktank).thenReturn(blocktank)
+        whenever(blocktank.info(any())).thenReturn(null)
+        sutWithFailingValidator.start()
+
+        val result = sutWithFailingValidator.restartWithRgsServer("https://rapidsync.lightningdevkit/snapshot")
+
+        assertTrue(result.isFailure)
+        assertEquals("DNS resolution failed", result.exceptionOrNull()?.message)
+    }
+
     @Test
     fun `getFeeRateForSpeed should use provided feeRates`() = test {
         val mockFeeRates = mock<FeeRates>()