use RemoteResourceResolver in notification polling for etag and PATH handling

plugins/core/core/src/software/aws/toolkits/core/utils/RemoteResourceResolver.kt

@@ -5,6 +5,8 @@
 
 import java.io.FileInputStream
 import java.io.InputStream
+import java.net.HttpURLConnection
+import java.net.URI
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.StandardCopyOption
@@ -13,30 +15,62 @@
 import java.util.UUID
 import java.util.concurrent.Callable
 import java.util.concurrent.CompletionStage
+import java.util.concurrent.atomic.AtomicBoolean
 
 interface RemoteResourceResolver {
     fun resolve(resource: RemoteResource): CompletionStage<Path>
+    fun checkForUpdates(endpoint: String, eTagProvider: ETagProvider): UpdateCheckResult
+    fun getLocalResourcePath(filename: String): Path?
 }
 interface RemoteResolveParser {
     fun canBeParsed(data: InputStream): Boolean
 }
 
+interface ETagProvider {
+    var etag: String?
+    fun updateETag(newETag: String?)
+}
+
+sealed class UpdateCheckResult {
+    data object HasUpdates : UpdateCheckResult()
+    data object NoUpdates : UpdateCheckResult()
+    data object FirstPollCheck : UpdateCheckResult()
+}
+
 class DefaultRemoteResourceResolver(
     private val urlFetcher: UrlFetcher,
     private val cacheBasePath: Path,
     private val executor: (Callable<Path>) -> CompletionStage<Path>,
 ) : RemoteResourceResolver {
+    private val isFirstPoll = AtomicBoolean(true)
 
     override fun resolve(resource: RemoteResource): CompletionStage<Path> = executor(Callable { internalResolve(resource) })
 
+    override fun getLocalResourcePath(filename: String): Path? {
+        val expectedLocation = cacheBasePath.resolve(filename)
+        return expectedLocation.existsOrNull()
+    }
+
+    override fun checkForUpdates(endpoint: String, eTagProvider: ETagProvider): UpdateCheckResult {
+        val hasETagUpdate = updateETags(eTagProvider, endpoint)
+        // for when we need to notify on first poll even when there's no new ETag
+        if (isFirstPoll.compareAndSet(true, false) && !hasETagUpdate) {
+            return UpdateCheckResult.FirstPollCheck
+        }
+
+        return if (hasETagUpdate) {
+            UpdateCheckResult.HasUpdates
+        } else {
+            UpdateCheckResult.NoUpdates
+        }
+    }
+
     private fun internalResolve(resource: RemoteResource): Path {
         val expectedLocation = cacheBasePath.resolve(resource.name)
         val current = expectedLocation.existsOrNull()
-        if (resource.name != "notifications.json") {
-            if ((current != null && !isExpired(current, resource))) {
-                LOG.debug { "Existing file ($current) for ${resource.name} is present and not expired - using it." }
-                return current
-            }
+        if (current != null && !isExpired(current, resource)) {
+            LOG.debug { "Existing file ($current) for ${resource.name} is present and not expired - using it." }
+            return current
         }
 
         LOG.debug { "Current file for ${resource.name} does not exist or is expired. Attempting to fetch from ${resource.urls}" }
@@ -84,6 +118,30 @@
         return expectedLocation
     }
 
+    private fun updateETags(eTagProvider: ETagProvider, endpoint: String): Boolean {
+        val currentEtag = eTagProvider.etag
+        val remoteEtag = getEndpointETag(endpoint)
+        eTagProvider.etag = remoteEtag
+        return currentEtag != remoteEtag
+    }
+
+    private fun getEndpointETag(endpoint: String): String =
+        try {
+            val url = URI(endpoint).toURL()
+            (url.openConnection() as HttpURLConnection).let { connection ->
+                connection.requestMethod = "HEAD"
+                connection.setRequestProperty("User-Agent", "AWS Toolkit for JetBrains")
+                connection.connect()
+
+                val eTag = connection.getHeaderField("ETag").orEmpty()
+                connection.disconnect()
+                eTag
+            }
+        } catch (e: Exception) {
+            LOG.warn { "Failed to fetch notification ETag: ${e.message}" }
+            throw e
+        }
+
     private companion object {
         val LOG = getLogger<RemoteResourceResolver>()
         fun Path.existsOrNull() = if (this.exists()) {

plugins/core/jetbrains-community/src/software/aws/toolkits/jetbrains/core/notifications/NotificationPollingService.kt

@@ -10,12 +10,11 @@
 import com.intellij.openapi.util.registry.Registry
 import com.intellij.util.Alarm
 import com.intellij.util.AlarmFactory
-import com.intellij.util.io.HttpRequests
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
 import software.aws.toolkits.core.utils.RemoteResolveParser
 import software.aws.toolkits.core.utils.RemoteResource
-import software.aws.toolkits.core.utils.error
+import software.aws.toolkits.core.utils.UpdateCheckResult
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.core.utils.warn
@@ -25,10 +24,10 @@
 import software.aws.toolkits.telemetry.ToolkitTelemetry
 import java.io.InputStream
 import java.time.Duration
-import java.util.concurrent.atomic.AtomicBoolean
 
 private const val MAX_RETRIES = 3
 private const val RETRY_DELAY_MS = 1000L
+internal const val FILENAME = "notifications.json"
 
 object NotificationFileValidator : RemoteResolveParser {
     override fun canBeParsed(data: InputStream): Boolean =
@@ -47,20 +46,20 @@
 
 @Service(Service.Level.APP)
 internal final class NotificationPollingService : Disposable {
-    private val isFirstPoll = AtomicBoolean(true)
     private val observers = mutableListOf<() -> Unit>()
     private val alarm = AlarmFactory.getInstance().create(Alarm.ThreadToUse.POOLED_THREAD, this)
     private val pollingIntervalMs = Duration.ofMinutes(10).toMillis()
     private val resourceResolver: RemoteResourceResolverProvider = DefaultRemoteResourceResolverProvider()
     private val notificationsResource = object : RemoteResource {
-        override val name: String = "notifications.json"
+        override val name: String = FILENAME
         override val urls: List<String> = listOf(NotificationEndpoint.getEndpoint())
         override val remoteResolveParser: RemoteResolveParser = NotificationFileValidator
+        override val ttl: Duration = Duration.ofMillis(1)
+        // ttl forces resolver to fetch from endpoint every time
     }
 
     fun startPolling() {
         val newNotifications = runBlocking { pollForNotifications() }
-        isFirstPoll.set(false)
         if (newNotifications) {
             notifyObservers()
         }
@@ -70,37 +69,38 @@
         )
     }
 
-    /**
-     * Main polling function that checks for updates and downloads if necessary
-     * Returns the parsed notifications if successful, null otherwise
-     */
     private suspend fun pollForNotifications(): Boolean {
         var retryCount = 0
         var lastException: Exception? = null
-
         while (retryCount < MAX_RETRIES) {
             LOG.info { "Polling for notifications" }
             try {
-                val newETag = getNotificationETag()
-                if (newETag == NotificationEtagState.getInstance().etag) {
-                    // for when we need to notify on first poll even when there's no new ETag
-                    if (isFirstPoll.compareAndSet(true, false)) {
+                when (
+                    resourceResolver.get().checkForUpdates(
+                        NotificationEndpoint.getEndpoint(),
+                        NotificationEtagState.getInstance()
+                    )
+                ) {
+                    is UpdateCheckResult.HasUpdates -> {
+                        resourceResolver.get()
+                            .resolve(notificationsResource)
+                            .toCompletableFuture()
+                            .get()
+                        LOG.info { "New notifications fetched" }
+                        return true
+                    }
+                    is UpdateCheckResult.FirstPollCheck -> {
                         LOG.info { "No new notifications, checking cached notifications on first poll" }
                         return true
                     }
-                    LOG.info { "No new notifications to fetch" }
-                    return false
+                    is UpdateCheckResult.NoUpdates -> {
+                        LOG.info { "No new notifications to fetch" }
+                        return false
+                    }
                 }
-                resourceResolver.get()
-                    .resolve(notificationsResource)
-                    .toCompletableFuture()
-                    .get()
-                NotificationEtagState.getInstance().etag = newETag
-                LOG.info { "New notifications fetched" }
-                return true
             } catch (e: Exception) {
                 lastException = e
-                LOG.error(e) { "Failed to poll for notifications (attempt ${retryCount + 1}/$MAX_RETRIES)" }
+                LOG.warn { "Failed to poll for notifications (attempt ${retryCount + 1}/$MAX_RETRIES)" }
                 retryCount++
                 if (retryCount < MAX_RETRIES) {
                     val backoffDelay = RETRY_DELAY_MS * (1L shl (retryCount - 1))
@@ -112,18 +112,6 @@
         return false
     }
 
-    private fun getNotificationETag(): String =
-        try {
-            HttpRequests.request(NotificationEndpoint.getEndpoint())
-                .userAgent("AWS Toolkit for JetBrains")
-                .connect { request ->
-                    request.connection.headerFields["ETag"]?.firstOrNull().orEmpty()
-                }
-        } catch (e: Exception) {
-            LOG.warn { "Failed to fetch notification ETag: $e.message" }
-            throw e
-        }
-
     private fun emitFailureMetric(e: Exception?) {
         ToolkitTelemetry.showNotification(
             project = null,

plugins/core/jetbrains-community/src/software/aws/toolkits/jetbrains/core/notifications/NotificationStateUtils.kt

@@ -9,6 +9,7 @@
 import com.intellij.openapi.components.State
 import com.intellij.openapi.components.Storage
 import com.intellij.openapi.components.service
+import software.aws.toolkits.core.utils.ETagProvider
 
 @Service
 @State(name = "notificationDismissals", storages = [Storage("aws.xml", roamingType = RoamingType.DISABLED)])
@@ -41,16 +42,20 @@
 
 @Service
 @State(name = "notificationEtag", storages = [Storage("aws.xml", roamingType = RoamingType.DISABLED)])
-class NotificationEtagState : PersistentStateComponent<NotificationEtagConfiguration> {
+class NotificationEtagState : PersistentStateComponent<NotificationEtagConfiguration>, ETagProvider {
     private val state = NotificationEtagConfiguration()
 
+    override fun updateETag(newETag: String?) {
+        etag = newETag
+    }
+
     override fun getState(): NotificationEtagConfiguration = state
 
     override fun loadState(state: NotificationEtagConfiguration) {
         this.state.etag = state.etag
     }
 
-    var etag: String?
+    override var etag: String?
         get() = state.etag
         set(value) {
             state.etag = value

plugins/core/jetbrains-community/src/software/aws/toolkits/jetbrains/core/notifications/ProcessNotificationsBase.kt

@@ -9,16 +9,15 @@
 import com.fasterxml.jackson.module.kotlin.readValue
 import com.intellij.notification.NotificationType
 import com.intellij.openapi.actionSystem.AnAction
-import com.intellij.openapi.application.PathManager
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.core.utils.inputStream
 import software.aws.toolkits.core.utils.warn
+import software.aws.toolkits.jetbrains.core.RemoteResourceResolverProvider
 import software.aws.toolkits.jetbrains.utils.notifyStickyWithData
-import java.nio.file.Paths
 import java.util.concurrent.atomic.AtomicBoolean
 
 object NotificationMapperUtil {
@@ -40,7 +39,14 @@
 
     private fun getNotificationsFromFile(): NotificationsList? {
         try {
-            val path = Paths.get(PathManager.getSystemPath(), NOTIFICATIONS_PATH)
+            val path = RemoteResourceResolverProvider
+                .getInstance()
+                .get()
+                .getLocalResourcePath(FILENAME)
+            if (path == null) {
+                LOG.warn { "Notifications file not found" }
+                return null
+            }
             val content = path.inputStream().bufferedReader().use { it.readText() }
             if (content.isEmpty()) {
                 return null
@@ -119,8 +125,6 @@
     companion object {
         private val LOG = getLogger<ProcessNotificationsBase>()
         fun getInstance(project: Project): ProcessNotificationsBase = project.service()
-
-        private const val NOTIFICATIONS_PATH = "aws-static-resources/notifications.json"
     }
 }
 

plugins/core/jetbrains-community/tst/software/aws/toolkits/jetbrains/core/notifications/NotificationPollingServiceTest.kt

@@ -4,22 +4,20 @@
 package software.aws.toolkits.jetbrains.core.notifications
 
 import com.intellij.testFramework.ApplicationExtension
-import com.intellij.util.io.HttpRequests
 import io.mockk.Runs
 import io.mockk.every
 import io.mockk.just
 import io.mockk.mockk
-import io.mockk.mockkStatic
 import io.mockk.verify
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
 import software.aws.toolkits.core.utils.RemoteResourceResolver
+import software.aws.toolkits.core.utils.UpdateCheckResult
 import software.aws.toolkits.jetbrains.core.RemoteResourceResolverProvider
 import java.nio.file.Path
 import java.util.concurrent.CompletableFuture
-import java.util.concurrent.atomic.AtomicBoolean
 
 @ExtendWith(ApplicationExtension::class)
 class NotificationPollingServiceTest {
@@ -64,48 +62,22 @@ class NotificationPollingServiceTest {
 
     @Test
     fun `test pollForNotifications when ETag matches - no new notifications`() {
-        NotificationEtagState.getInstance().etag = "same"
-        val firstPollField = NotificationPollingService::class.java
-            .getDeclaredField("isFirstPoll")
-            .apply { isAccessible = true }
-        firstPollField.set(sut, AtomicBoolean(false))
-
-        mockkStatic(HttpRequests::class) {
-            every {
-                HttpRequests.request(any<String>())
-                    .userAgent(any())
-                    .connect<String>(any())
-            } returns "same"
-            sut.startPolling()
-        }
+        every { mockResolver.checkForUpdates(any(), any()) } returns UpdateCheckResult.NoUpdates
+        sut.startPolling()
         verify(exactly = 0) { observer.invoke() }
     }
 
     @Test
     fun `test pollForNotifications when ETag matches on startup - notify observers`() {
-        NotificationEtagState.getInstance().etag = "same"
-        mockkStatic(HttpRequests::class) {
-            every {
-                HttpRequests.request(any<String>())
-                    .userAgent(any())
-                    .connect<String>(any())
-            } returns "same"
-            sut.startPolling()
-        }
+        every { mockResolver.checkForUpdates(any(), any()) } returns UpdateCheckResult.FirstPollCheck
+        sut.startPolling()
         verify(exactly = 1) { observer.invoke() }
     }
 
     @Test
     fun `test pollForNotifications when ETag different - notify observers`() {
-        NotificationEtagState.getInstance().etag = "oldETag"
-        mockkStatic(HttpRequests::class) {
-            every {
-                HttpRequests.request(any<String>())
-                    .userAgent(any())
-                    .connect<String>(any())
-            } returns "newEtag"
-            sut.startPolling()
-        }
+        every { mockResolver.checkForUpdates(any(), any()) } returns UpdateCheckResult.HasUpdates
+        sut.startPolling()
         verify(exactly = 1) { observer.invoke() }
     }
 }