use RemoteResourceResolver in notification polling for etag and PATH handling

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

@@ -32,11 +32,9 @@ class DefaultRemoteResourceResolver(
     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}" }

plugins/core/jetbrains-community/resources/META-INF/aws.toolkit.core.xml

@@ -36,6 +36,9 @@
                             testServiceImplementation="software.aws.toolkits.jetbrains.core.region.MockRegionProvider"/>
         <applicationService serviceInterface="migration.software.aws.toolkits.jetbrains.core.RemoteResourceResolverProvider"
                             serviceImplementation="software.aws.toolkits.jetbrains.core.DefaultRemoteResourceResolverProvider"/>
+        <applicationService serviceInterface="software.aws.toolkits.jetbrains.core.notifications.NotificationResourceResolverProvider"
+                            serviceImplementation="software.aws.toolkits.jetbrains.core.notifications.DefaultNotificationResourceResolverProvider"/>
+
         <applicationService serviceInterface="migration.software.aws.toolkits.core.clients.SdkClientProvider"
                             serviceImplementation="software.aws.toolkits.jetbrains.core.AwsSdkClient"/>
         <applicationService serviceInterface="migration.software.aws.toolkits.core.ToolkitClientManager"

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

@@ -10,22 +10,17 @@
 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.getLogger
 import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.core.utils.warn
-import software.aws.toolkits.jetbrains.core.DefaultRemoteResourceResolverProvider
-import software.aws.toolkits.jetbrains.core.RemoteResourceResolverProvider
 import software.aws.toolkits.telemetry.Component
 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
@@ -47,20 +42,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 resourceResolver: NotificationResourceResolverProvider = DefaultNotificationResourceResolverProvider()
     private val notificationsResource = object : RemoteResource {
         override val name: String = "notifications.json"
         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 +65,33 @@
         )
     }
 
-    /**
-     * 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()) {
+                    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 +103,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/NotificationResourceResolver.kt

@@ -0,0 +1,127 @@
+// Copyright 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.core.notifications
+
+import com.intellij.openapi.application.PathManager
+import com.intellij.openapi.components.service
+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.RemoteResource
+import software.aws.toolkits.core.utils.RemoteResourceResolver
+import software.aws.toolkits.core.utils.UrlFetcher
+import software.aws.toolkits.core.utils.exists
+import software.aws.toolkits.core.utils.getLogger
+import software.aws.toolkits.core.utils.warn
+import software.aws.toolkits.jetbrains.core.saveFileFromUrl
+import software.aws.toolkits.jetbrains.utils.pluginAwareExecuteOnPooledThread
+import java.nio.file.Path
+import java.nio.file.Paths
+import java.util.concurrent.Callable
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.CompletionStage
+import java.util.concurrent.atomic.AtomicBoolean
+
+interface NotificationResourceResolverProvider {
+    fun get(): NotificationResourceResolver
+
+    companion object {
+        fun getInstance(): NotificationResourceResolverProvider = service()
+    }
+}
+
+internal final class DefaultNotificationResourceResolverProvider : NotificationResourceResolverProvider {
+    override fun get() = RESOLVER_INSTANCE
+
+    companion object {
+        private val RESOLVER_INSTANCE by lazy {
+            val cachePath = Paths.get(PathManager.getSystemPath(), "aws-notifications").createDirectories()
+
+            NotificationResourceResolver(HttpRequestUrlFetcher, cachePath) {
+                val future = CompletableFuture<Path>()
+                pluginAwareExecuteOnPooledThread {
+                    try {
+                        future.complete(it.call())
+                    } catch (e: Exception) {
+                        future.completeExceptionally(e)
+                    }
+                }
+                future
+            }
+        }
+
+        object HttpRequestUrlFetcher : UrlFetcher {
+            override fun fetch(url: String, file: Path) {
+                saveFileFromUrl(url, file)
+            }
+        }
+    }
+}
+
+sealed class UpdateCheckResult {
+    data object HasUpdates : UpdateCheckResult()
+    data object NoUpdates : UpdateCheckResult()
+    data object FirstPollCheck : UpdateCheckResult()
+}
+
+class NotificationResourceResolver(
+    private val urlFetcher: UrlFetcher,
+    private val cacheBasePath: Path,
+    private val executor: (Callable<Path>) -> CompletionStage<Path>,
+) : RemoteResourceResolver {
+    private val delegate = DefaultRemoteResourceResolver(urlFetcher, cacheBasePath, executor)
+    private val etagState: NotificationEtagState = NotificationEtagState.getInstance()
+    private val isFirstPoll = AtomicBoolean(true)
+
+    override fun resolve(resource: RemoteResource): CompletionStage<Path> =
+        delegate.resolve(resource)
+
+    fun getLocalResourcePath(resourceName: String): Path? {
+        val expectedLocation = cacheBasePath.resolve(resourceName)
+        return expectedLocation.existsOrNull()
+    }
+
+    fun checkForUpdates(): UpdateCheckResult {
+        val hasETagUpdate = updateETags()
+
+        // 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 updateETags(): Boolean {
+        val currentEtag = etagState.etag
+        val remoteEtag = getEndpointETag()
+        etagState.etag = remoteEtag
+        return currentEtag != remoteEtag
+    }
+
+    private fun getEndpointETag(): 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
+        }
+
+    companion object {
+        private val LOG = getLogger<NotificationResourceResolver>()
+        fun Path.existsOrNull() = if (this.exists()) {
+            this
+        } else {
+            null
+        }
+    }
+}

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

@@ -9,7 +9,6 @@
 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
@@ -18,7 +17,6 @@
 import software.aws.toolkits.core.utils.inputStream
 import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.utils.notifyStickyWithData
-import java.nio.file.Paths
 import java.util.concurrent.atomic.AtomicBoolean
 
 object NotificationMapperUtil {
@@ -40,7 +38,14 @@
 
     private fun getNotificationsFromFile(): NotificationsList? {
         try {
-            val path = Paths.get(PathManager.getSystemPath(), NOTIFICATIONS_PATH)
+            val path = NotificationResourceResolverProvider
+                .getInstance()
+                .get()
+                .getLocalResourcePath("notifications.json")
+            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 +124,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"
     }
 }