implement defaultRemoteResourceResolverProvider instead

Author: samgst-amazon

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

@@ -3,9 +3,10 @@
 
 package software.aws.toolkits.core.utils
 
-import com.intellij.util.io.HttpRequests
 import java.io.FileInputStream
 import java.io.InputStream
+import java.net.HttpURLConnection
+import java.net.URL
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.StandardCopyOption
@@ -18,6 +19,8 @@ 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
@@ -43,12 +46,12 @@ class DefaultRemoteResourceResolver(
 
     override fun resolve(resource: RemoteResource): CompletionStage<Path> = executor(Callable { internalResolve(resource) })
 
-    fun getLocalResourcePath(resourceName: String): Path? {
-        val expectedLocation = cacheBasePath.resolve(resourceName)
+    override fun getLocalResourcePath(filename: String): Path? {
+        val expectedLocation = cacheBasePath.resolve(filename)
         return expectedLocation.existsOrNull()
     }
 
-    fun checkForUpdates(endpoint: String, eTagProvider: ETagProvider): UpdateCheckResult {
+    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) {
@@ -124,13 +127,18 @@ class DefaultRemoteResourceResolver(
 
     private fun getEndpointETag(endpoint: String): String =
         try {
-            HttpRequests.request(endpoint)
-                .userAgent("AWS Toolkit for JetBrains")
-                .connect { request ->
-                    request.connection.headerFields["ETag"]?.firstOrNull().orEmpty()
-                }
+            val url = URL(endpoint)
+            (url.openConnection() as HttpURLConnection).let { connection ->
+                connection.requestMethod = "HEAD"
+                connection.setRequestProperty("User-Agent", "AWS Toolkit for JetBrains")
+                connection.connect()
+
+                val eTag = connection.getHeaderField("ETag") ?: ""
+                connection.disconnect()
+                eTag
+            }
         } catch (e: Exception) {
-            LOG.warn { "Failed to fetch notification ETag: $e.message" }
+            LOG.warn { "Failed to fetch notification ETag: ${e.message}" }
             throw e
         }
 

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

@@ -14,16 +14,20 @@ 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.UpdateCheckResult
 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
 
 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 =
@@ -45,9 +49,9 @@ internal final class NotificationPollingService : Disposable {
     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: NotificationResourceResolverProvider = DefaultNotificationResourceResolverProvider()
+    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)
@@ -71,7 +75,12 @@ internal final class NotificationPollingService : Disposable {
         while (retryCount < MAX_RETRIES) {
             LOG.info { "Polling for notifications" }
             try {
-                when (resourceResolver.get().checkForUpdates()) {
+                when (
+                    resourceResolver.get().checkForUpdates(
+                        NotificationEndpoint.getEndpoint(),
+                        NotificationEtagState.getInstance()
+                    )
+                ) {
                     is UpdateCheckResult.HasUpdates -> {
                         resourceResolver.get()
                             .resolve(notificationsResource)

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

@@ -16,6 +16,7 @@ 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.util.concurrent.atomic.AtomicBoolean
 
@@ -38,10 +39,10 @@ class ProcessNotificationsBase(
 
     private fun getNotificationsFromFile(): NotificationsList? {
         try {
-            val path = NotificationResourceResolverProvider
+            val path = RemoteResourceResolverProvider
                 .getInstance()
                 .get()
-                .getLocalResourcePath("notifications.json")
+                .getLocalResourcePath(FILENAME)
             if (path == null) {
                 LOG.warn { "Notifications file not found" }
                 return null

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

@@ -13,26 +13,29 @@ 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
 
 @ExtendWith(ApplicationExtension::class)
 class NotificationPollingServiceTest {
     private lateinit var sut: NotificationPollingService
-    private lateinit var mockResolver: NotificationResourceResolver
-    private lateinit var mockProvider: NotificationResourceResolverProvider
+    private lateinit var mockResolver: RemoteResourceResolver
+    private lateinit var mockProvider: RemoteResourceResolverProvider
     private lateinit var observer: () -> Unit
     private val testPath = Path.of("/test/path")
 
     @BeforeEach
     fun setUp() {
         sut = NotificationPollingService()
 
-        mockResolver = mockk<NotificationResourceResolver> {
+        mockResolver = mockk<RemoteResourceResolver> {
             every { resolve(any()) } returns CompletableFuture.completedFuture(testPath)
         }
 
-        mockProvider = mockk<NotificationResourceResolverProvider> {
+        mockProvider = mockk<RemoteResourceResolverProvider> {
             every { get() } returns mockResolver
         }
 
@@ -59,21 +62,21 @@ class NotificationPollingServiceTest {
 
     @Test
     fun `test pollForNotifications when ETag matches - no new notifications`() {
-        every { mockResolver.checkForUpdates() } returns UpdateCheckResult.NoUpdates
+        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`() {
-        every { mockResolver.checkForUpdates() } returns UpdateCheckResult.FirstPollCheck
+        every { mockResolver.checkForUpdates(any(), any()) } returns UpdateCheckResult.FirstPollCheck
         sut.startPolling()
         verify(exactly = 1) { observer.invoke() }
     }
 
     @Test
     fun `test pollForNotifications when ETag different - notify observers`() {
-        every { mockResolver.checkForUpdates() } returns UpdateCheckResult.HasUpdates
+        every { mockResolver.checkForUpdates(any(), any()) } returns UpdateCheckResult.HasUpdates
         sut.startPolling()
         verify(exactly = 1) { observer.invoke() }
     }