Poll for new notifications

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

@@ -0,0 +1,199 @@
+// 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.fasterxml.jackson.module.kotlin.readValue
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.components.PersistentStateComponent
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.components.State
+import com.intellij.openapi.components.Storage
+import com.intellij.util.Alarm
+import com.intellij.util.AlarmFactory
+import com.intellij.util.io.HttpRequests
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import org.jetbrains.annotations.VisibleForTesting
+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.warn
+import software.aws.toolkits.jetbrains.core.DefaultRemoteResourceResolverProvider
+import software.aws.toolkits.jetbrains.core.RemoteResourceResolverProvider
+import software.aws.toolkits.jetbrains.core.coroutines.getCoroutineBgContext
+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
+
+object NotificationFileValidator : RemoteResolveParser {
+    override fun canBeParsed(data: InputStream): Boolean =
+        try {
+            NotificationMapperUtil.mapper.readValue<NotificationsList>(data)
+            true
+        } catch (e: Exception) {
+            false
+        }
+}
+
+object NotificationEndpoint {
+    private var overriddenEndpoint: String? = null
+
+    fun getEndpoint(): String = overriddenEndpoint ?: DEFAULT_ENDPOINT
+
+    @VisibleForTesting
+    fun setTestEndpoint(endpoint: String) {
+        overriddenEndpoint = endpoint
+    }
+
+    @VisibleForTesting
+    fun resetEndpoint() {
+        overriddenEndpoint = null
+    }
+
+    private const val DEFAULT_ENDPOINT = "" // TODO: Replace with actual endpoint
+}
+
+@State(name = "notificationEtag", storages = [Storage("aws.xml")])
+class NotificationEtagState : PersistentStateComponent<NotificationEtagConfiguration> {
+    private var state = NotificationEtagConfiguration()
+
+    override fun getState(): NotificationEtagConfiguration = state
+
+    override fun loadState(state: NotificationEtagConfiguration) {
+        this.state = state
+    }
+
+    var etag: String?
+        get() = state.etag
+        set(value) {
+            state.etag = value
+        }
+
+    companion object {
+        fun getInstance(): NotificationEtagState =
+            ApplicationManager.getApplication().getService(NotificationEtagState::class.java)
+    }
+}
+
+data class NotificationEtagConfiguration(
+    var etag: String? = null,
+)
+
+@Service(Service.Level.APP)
+internal final class NotificationPollingService : Disposable {
+    private val isFirstPoll = AtomicBoolean(true)
+    private val isStartup = AtomicBoolean(true)
+    private val observers = mutableListOf<(Boolean) -> Unit>()
+    private val alarm = AlarmFactory.getInstance().create(Alarm.ThreadToUse.POOLED_THREAD, this)
+    private val scope = CoroutineScope(getCoroutineBgContext())
+    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 urls: List<String> = listOf(NotificationEndpoint.getEndpoint())
+        override val remoteResolveParser: RemoteResolveParser = NotificationFileValidator
+    }
+
+    fun startPolling() {
+        val newNotifications = pollForNotifications()
+        if (newNotifications) {
+            notifyObservers()
+        }
+        alarm.addRequest(
+            { startPolling() },
+            pollingIntervalMs
+        )
+    }
+
+    /**
+     * Main polling function that checks for updates and downloads if necessary
+     * Returns the parsed notifications if successful, null otherwise
+     */
+    private fun pollForNotifications(): Boolean {
+        var retryCount = 0
+        var lastException: Exception? = null
+
+        while (retryCount < MAX_RETRIES) {
+            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)) {
+                        notifyObservers()
+                    }
+                    return false
+                }
+                resourceResolver.get()
+                    .resolve(notificationsResource)
+                    .toCompletableFuture()
+                    .get()
+                NotificationEtagState.getInstance().etag = newETag
+                return true
+            } catch (e: Exception) {
+                lastException = e
+                LOG.error(e) { "Failed to poll for notifications (attempt ${retryCount + 1}/$MAX_RETRIES)" }
+                retryCount++
+                if (retryCount < MAX_RETRIES) {
+                    val backoffDelay = RETRY_DELAY_MS * (1L shl (retryCount - 1))
+                    scope.launch {
+                        delay(backoffDelay)
+                    }
+                }
+            }
+        }
+        emitFailureMetric(lastException)
+        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,
+            component = Component.Filesystem,
+            id = "",
+            reason = "Failed to poll for notifications",
+            success = false,
+            reasonDesc = "${e?.javaClass?.simpleName ?: "Unknown"}: ${e?.message ?: "No message"}",
+        )
+    }
+
+    fun addObserver(observer: (Boolean) -> Unit) = observers.add(observer)
+
+    private fun notifyObservers() {
+        observers.forEach { observer ->
+            observer(isStartup.getAndSet(false))
+        }
+    }
+
+    override fun dispose() {
+        alarm.dispose()
+        scope.cancel()
+    }
+
+    companion object {
+        private val LOG = getLogger<NotificationPollingService>()
+        fun getInstance(): NotificationPollingService =
+            ApplicationManager.getApplication().getService(NotificationPollingService::class.java)
+    }
+}

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

@@ -0,0 +1,21 @@
+// 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.project.Project
+import com.intellij.openapi.startup.ProjectActivity
+import java.util.concurrent.atomic.AtomicBoolean
+
+internal class NotificationServiceInitializer : ProjectActivity {
+
+    private val initialized = AtomicBoolean(false)
+
+    override suspend fun execute(project: Project) {
+        if (initialized.compareAndSet(false, true)) {
+            val service = NotificationPollingService.getInstance()
+            ProcessNotificationsBase()
+            service.startPolling()
+        }
+    }
+}

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

@@ -3,25 +3,42 @@
 
 package software.aws.toolkits.jetbrains.core.notifications
 
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+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.inputStream
 import software.aws.toolkits.jetbrains.utils.notifyStickyWithData
+import java.nio.file.Paths
+
+object NotificationMapperUtil {
+    val mapper = jacksonObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
+}
 
 @Service(Service.Level.PROJECT)
 class ProcessNotificationsBase {
     private val notifListener = mutableListOf<NotifListener>()
     init {
-        // TODO: install a listener for the polling class
+        NotificationPollingService.getInstance().addObserver { isStartup ->
+            retrieveStartupAndEmergencyNotifications(isStartup)
+        }
     }
 
-    fun getNotificationsFromFile() {
-        // TODO: returns a notification list
+    private fun getNotificationsFromFile(): NotificationsList? {
+        val path = Paths.get(PathManager.getSystemPath(), NOTIFICATIONS_PATH)
+        val content = path.inputStream().bufferedReader().use { it.readText() }
+        if (content.isEmpty()) {
+            return null
+        }
+        return NotificationMapperUtil.mapper.readValue(content)
     }
 
-    fun retrieveStartupAndEmergencyNotifications() {
+    fun retrieveStartupAndEmergencyNotifications(isStartup: Boolean) {
         // TODO: separates notifications into startup and emergency
         // iterates through the 2 lists and processes each notification(if it isn't dismissed)
     }
@@ -71,6 +88,7 @@
         fun getInstance(project: Project): ProcessNotificationsBase = project.service()
 
         val showBannerNotification = mutableMapOf<String, BannerContent>()
+        private const val NOTIFICATIONS_PATH = "aws-static-resources/notifications.json"
     }
 }
 

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

@@ -0,0 +1,111 @@
+// 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.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.jetbrains.core.RemoteResourceResolverProvider
+import java.nio.file.Path
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.atomic.AtomicBoolean
+
+@ExtendWith(ApplicationExtension::class)
+class NotificationPollingServiceTest {
+    private lateinit var sut: NotificationPollingService
+    private lateinit var mockResolver: RemoteResourceResolver
+    private lateinit var mockProvider: RemoteResourceResolverProvider
+    private lateinit var observer: (Boolean) -> Unit
+    private val testPath = Path.of("/test/path")
+
+    @BeforeEach
+    fun setUp() {
+        sut = NotificationPollingService()
+
+        mockResolver = mockk<RemoteResourceResolver> {
+            every { resolve(any()) } returns CompletableFuture.completedFuture(testPath)
+        }
+
+        mockProvider = mockk<RemoteResourceResolverProvider> {
+            every { get() } returns mockResolver
+        }
+
+        val providerField = NotificationPollingService::class.java
+            .getDeclaredField("resourceResolver")
+        providerField.isAccessible = true
+        providerField.set(sut, mockProvider)
+
+        // Create mock observers
+        observer = mockk<(Boolean) -> Unit>()
+        every { observer.invoke(any()) } just Runs
+
+        val observersField = NotificationPollingService::class.java
+            .getDeclaredField("observers")
+            .apply { isAccessible = true }
+
+        observersField.set(sut, mutableListOf(observer))
+    }
+
+    @AfterEach
+    fun tearDown() {
+        sut.dispose()
+    }
+
+    @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()
+        }
+        verify(exactly = 0) { observer.invoke(any()) }
+    }
+
+    @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()
+        }
+        verify(exactly = 1) { observer.invoke(any()) }
+    }
+
+    @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()
+        }
+        verify(exactly = 1) { observer.invoke(any()) }
+    }
+}

plugins/core/src/main/resources/META-INF/plugin.xml

@@ -20,8 +20,10 @@
 
     <extensions defaultExtensionNs="com.intellij">
         <!-- each plugin needs its own instance of these -->
+        <applicationService serviceImplementation="software.aws.toolkits.jetbrains.core.notifications.NotificationEtagState"/>
         <applicationService serviceImplementation="migration.software.aws.toolkits.jetbrains.core.coroutines.PluginCoroutineScopeTracker"/>
         <projectService serviceImplementation="migration.software.aws.toolkits.jetbrains.core.coroutines.PluginCoroutineScopeTracker"/>
+        <postStartupActivity implementation = "software.aws.toolkits.jetbrains.core.notifications.NotificationServiceInitializer"/>
     </extensions>
     <projectListeners>
         <listener class="software.aws.toolkits.jetbrains.services.telemetry.OpenedFileTypesMetricsListener" topic="com.intellij.openapi.fileEditor.FileEditorManagerListener"/>