use RemoteResourceResolver in notification polling for etag and PATH handling

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

@@ -13,30 +13,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 = UpdateCheckResult.NoUpdates
+    fun getLocalResourcePath(filename: String): Path? = null
 }
 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 +116,21 @@
         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 {
+            urlFetcher.getETag(endpoint)
+        } catch (e: Exception) {
+            LOG.warn { "Failed to fetch ETag: $e.message" }
+            throw e
+        }
+
     private companion object {
         val LOG = getLogger<RemoteResourceResolver>()
         fun Path.existsOrNull() = if (this.exists()) {
@@ -105,6 +152,7 @@
 
 interface UrlFetcher {
     fun fetch(url: String, file: Path)
+    fun getETag(url: String): String
 }
 
 /**

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

@@ -4,6 +4,7 @@
 package software.aws.toolkits.jetbrains.core
 
 import com.intellij.openapi.application.PathManager
+import com.intellij.util.io.HttpRequests
 import com.intellij.util.io.createDirectories
 import software.aws.toolkits.core.utils.DefaultRemoteResourceResolver
 import software.aws.toolkits.core.utils.UrlFetcher
@@ -38,6 +39,13 @@
             override fun fetch(url: String, file: Path) {
                 saveFileFromUrl(url, file)
             }
+
+            override fun getETag(url: String): String =
+                HttpRequests.head(url)
+                    .userAgent("AWS Toolkit for JetBrains")
+                    .connect { request ->
+                        request.connection.headerFields["ETag"]?.firstOrNull().orEmpty()
+                    }
         }
     }
 }

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,19 +9,18 @@
 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 software.aws.toolkits.telemetry.Component
 import software.aws.toolkits.telemetry.Result
 import software.aws.toolkits.telemetry.ToolkitTelemetry
-import java.nio.file.Paths
 import java.util.concurrent.atomic.AtomicBoolean
 
 object NotificationMapperUtil {
@@ -43,7 +42,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
@@ -127,8 +133,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"
     }
 }