Merge pull request #1044 from JetBrains/rival/fix-tools-feed-downloading-243

rafaelldi · web-flow · commit 137c509a48eb · 2025-03-27T14:10:52.000+01:00
Download Functions tooling feed to a json file
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -145,6 +145,13 @@ jobs:
         run: |
           ./gradlew patchChangelog --release-note="$CHANGELOG"
 
+      # Upload artifact as a release asset
+      - name: Upload Release Asset
+        working-directory: ${{ github.workspace }}/PluginsAndFeatures/azure-toolkit-for-rider
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh release upload ${{ github.event.release.tag_name }} ./build/distributions/*
+
       # Publish the plugin to JetBrains Marketplace
       - name: Publish Plugin
         working-directory: ${{ github.workspace }}/PluginsAndFeatures/azure-toolkit-for-rider
@@ -155,13 +162,6 @@ jobs:
           PRIVATE_KEY_PASSWORD: ${{ secrets.PRIVATE_KEY_PASSWORD }}
         run: ./gradlew publishPlugin
 
-      # Upload artifact as a release asset
-      - name: Upload Release Asset
-        working-directory: ${{ github.workspace }}/PluginsAndFeatures/azure-toolkit-for-rider
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: gh release upload ${{ github.event.release.tag_name }} ./build/distributions/*
-
       # Create a pull request
       - name: Create Pull Request
         if: ${{ steps.properties.outputs.changelog != '' }}
diff --git a/PluginsAndFeatures/azure-toolkit-for-rider/CHANGELOG.md b/PluginsAndFeatures/azure-toolkit-for-rider/CHANGELOG.md
@@ -4,6 +4,12 @@
 
 ## [Unreleased]
 
+### Fixed
+
+- Unable to download Azure Functions Core Tools because of the `NoTransformationFoundException` ([#1042](https://github.com/JetBrains/azure-tools-for-intellij/issues/1042))
+
+## [4.3.9] - 2025-02-07
+
 ### Changed
 
 - Update domain for Azure Functions CDN
@@ -248,7 +254,8 @@
 - Reimplement Azure Functions Core Tools integration
 - Reimplement Azure Functions templates
 
-[Unreleased]: https://github.com/JetBrains/azure-tools-for-intellij/compare/v4.3.8...HEAD
+[Unreleased]: https://github.com/JetBrains/azure-tools-for-intellij/compare/v4.3.9...HEAD
+[4.3.9]: https://github.com/JetBrains/azure-tools-for-intellij/compare/v4.3.8...v4.3.9
 [4.3.8]: https://github.com/JetBrains/azure-tools-for-intellij/compare/v4.3.7...v4.3.8
 [4.3.7]: https://github.com/JetBrains/azure-tools-for-intellij/compare/v4.3.6...v4.3.7
 [4.3.6]: https://github.com/JetBrains/azure-tools-for-intellij/compare/v4.3.5...v4.3.6
diff --git a/PluginsAndFeatures/azure-toolkit-for-rider/azure-intellij-plugin-appservice-dotnet/src/main/kotlin/com/microsoft/azure/toolkit/intellij/legacy/function/toolingFeed/FunctionsToolingFeedService.kt b/PluginsAndFeatures/azure-toolkit-for-rider/azure-intellij-plugin-appservice-dotnet/src/main/kotlin/com/microsoft/azure/toolkit/intellij/legacy/function/toolingFeed/FunctionsToolingFeedService.kt
@@ -22,28 +22,21 @@ import com.microsoft.azure.toolkit.intellij.legacy.function.settings.AzureFuncti
 import io.ktor.client.*
 import io.ktor.client.call.*
 import io.ktor.client.engine.cio.*
-import io.ktor.client.plugins.contentnegotiation.*
+import io.ktor.client.plugins.HttpTimeout
 import io.ktor.client.request.*
-import io.ktor.serialization.kotlinx.json.*
-import io.ktor.utils.io.ByteReadChannel
-import io.ktor.utils.io.core.isEmpty
-import io.ktor.utils.io.core.readBytes
+import io.ktor.util.cio.*
+import io.ktor.utils.io.*
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromStream
 import java.io.File
 import java.nio.file.Path
 import java.nio.file.attribute.PosixFilePermission
-import kotlin.io.path.ExperimentalPathApi
-import kotlin.io.path.Path
-import kotlin.io.path.createDirectories
-import kotlin.io.path.deleteRecursively
-import kotlin.io.path.exists
-import kotlin.io.path.isExecutable
-import kotlin.io.path.setPosixFilePermissions
+import kotlin.io.path.*
 
 @Service(Service.Level.APP)
 class FunctionsToolingFeedService : Disposable {
@@ -64,29 +57,86 @@ class FunctionsToolingFeedService : Disposable {
                 trustManager = CertificateManager.getInstance().trustManager
             }
         }
-        install(ContentNegotiation) {
-            json(Json {
-                explicitNulls = false
-                ignoreUnknownKeys = true
-                allowTrailingComma = true
-            })
+        install(HttpTimeout) {
+            requestTimeoutMillis = 300000
         }
     }
 
+    @OptIn(ExperimentalSerializationApi::class)
+    private val json = Json {
+        explicitNulls = false
+        ignoreUnknownKeys = true
+        allowTrailingComma = true
+        allowComments = true
+    }
+
+    /**
+     * Downloads the latest Azure Functions tooling release for the specified Azure Functions runtime version.
+     *
+     * This method fetches the release information, determines if the release has already been downloaded,
+     * and if not, it downloads the release, extracts it to the appropriate directory and cleans up any temporary files.
+     *
+     * @param functionsRuntimeVersion The version of Azure Functions runtime for which to download the latest tooling release.
+     * @return A Result wrapping the path to the latest Azure Functions tooling release.
+     */
+    suspend fun downloadLatestFunctionsToolingRelease(functionsRuntimeVersion: String): Result<Path> {
+        downloadAndSaveReleaseFeed().onFailure { error ->
+            LOG.warn("Unable to download Function tooling release feed", error)
+            return Result.failure(error)
+        }
+
+        val toolingRelease = getLatestFunctionsToolingRelease(functionsRuntimeVersion)
+            ?: return Result.failure(IllegalStateException("Unable to obtain latest function tooling release"))
+        val toolingReleasePath = getPathForLatestFunctionsToolingRelease(toolingRelease)
+            ?: return Result.failure(IllegalStateException("Unable to path to download function tooling release"))
+
+        val coreToolsExecutablePath = toolingReleasePath.resolveFunctionCoreToolsExecutable()
+        if (coreToolsExecutablePath.exists()) {
+            LOG.trace { "The release $toolingRelease is already downloaded" }
+            return Result.success(toolingReleasePath)
+        }
+
+        return downloadAndExtractFunctionsToolingRelease(
+            toolingRelease,
+            toolingReleasePath,
+            coreToolsExecutablePath
+        )
+    }
+
+    /**
+     * Retrieves a list of Azure Functions tooling releases for the specified Azure Functions runtime versions.
+     *
+     * @param functionsRuntimeVersions List of Azure Functions runtime versions.
+     * @return List of tooling releases corresponding to the given versions, or null if the release feed could not be downloaded.
+     */
+    suspend fun getFunctionsToolingReleaseForVersions(functionsRuntimeVersions: List<String>): List<FunctionsToolingRelease>? {
+        downloadAndSaveReleaseFeed().onFailure { exception ->
+            LOG.warn("Unable to download Function tooling release feed", exception)
+            return null
+        }
+
+        return functionsRuntimeVersions.mapNotNull { getLatestFunctionsToolingRelease(it) }
+    }
+
     /**
      * Downloads and saves the Azure Functions tooling release feed if the release cache is empty.
      *
      * @return Result wrapping any exception encountered during the execution.
      */
-    suspend fun downloadAndSaveReleaseFeed() = kotlin.runCatching {
-        if (releaseCache.isNotEmpty()) return@runCatching
+    private suspend fun downloadAndSaveReleaseFeed(): Result<Unit> {
+        if (releaseCache.isNotEmpty()) return Result.success(Unit)
 
         releaseCacheMutex.withLock {
-            if (releaseCache.isNotEmpty()) return@withLock
+            if (releaseCache.isNotEmpty()) return Result.success(Unit)
 
             LOG.trace("Downloading Functions tooling release feed")
 
-            val feed = getReleaseFeed()
+            val feedResult = downloadFunctionsToolingReleaseFeed().onFailure { error ->
+                return Result.failure(error)
+            }
+
+            val feed = feedResult.getOrNull()
+                ?: return Result.failure(IllegalStateException("Unable to download Function tooling release feed"))
             val releaseTags = feed.tags
                 .toSortedMap()
                 .filterValues { !it.releaseQuality.isNullOrEmpty() && !it.release.isNullOrEmpty() && !it.hidden }
@@ -105,93 +155,74 @@ class FunctionsToolingFeedService : Disposable {
                     FunctionsToolingRelease(releaseKey, releaseFromTag, coreToolsRelease.downloadLink ?: "")
                 )
             }
+
+            return Result.success(Unit)
         }
     }
 
-    /**
-     * Downloads the latest Azure Functions tooling release for the specified Azure Functions runtime version.
-     *
-     * This method fetches the release information, determines if the release has already been downloaded,
-     * and if not, it downloads the release, extracts it to the appropriate directory and cleans up any temporary files.
-     *
-     * @param functionsRuntimeVersion The version of Azure Functions runtime for which to download the latest tooling release.
-     * @return A Result wrapping the path to the latest Azure Functions tooling release.
-     */
-    suspend fun downloadLatestFunctionsToolingRelease(functionsRuntimeVersion: String): Result<Path> {
-        downloadAndSaveReleaseFeed().onFailure { exception ->
-            LOG.warn("Unable to download Function tooling release feed", exception)
-            return Result.failure(exception)
-        }
+    private suspend fun downloadFunctionsToolingReleaseFeed(): Result<ReleaseFeed> = runCatching {
+        val feedUrl = Registry.get("azure.function_app.core_tools.feed.url").asString()
+        LOG.trace { "Functions tooling release feed: $feedUrl" }
 
-        val toolingRelease = getLatestFunctionsToolingRelease(functionsRuntimeVersion)
-        if (toolingRelease == null) {
-            return Result.failure(IllegalStateException("Unable to obtain latest function tooling release"))
-        }
-        val toolingReleasePath = getPathForLatestFunctionsToolingRelease(toolingRelease)
-        if (toolingReleasePath == null) {
-            return Result.failure(IllegalStateException("Unable to path to download function tooling release"))
+        val temporaryFeedFile = FileUtil.createTempFile(
+            File(FileUtil.getTempDirectory()),
+            "AzureFunctionsToolingFeed",
+            ".json",
+            true,
+            false
+        )
+        val temporaryFeedPath = temporaryFeedFile.toPath()
+
+        LOG.trace { "Created a temporary feed file: ${temporaryFeedPath.absolutePathString()}" }
+
+        withContext(Dispatchers.IO) {
+            client.prepareGet(feedUrl).execute { httpResponse ->
+                val channel: ByteReadChannel = httpResponse.body()
+                channel.copyAndClose(temporaryFeedFile.writeChannel())
+            }
         }
-        val coreToolsExecutablePath = toolingReleasePath.resolveFunctionCoreToolsExecutable()
-        if (coreToolsExecutablePath.exists()) {
-            LOG.trace { "The release $toolingRelease is already downloaded" }
-            return Result.success(toolingReleasePath)
+
+        LOG.trace { "Downloaded Functions tooling feed to the ${temporaryFeedPath.absolutePathString()}" }
+
+        val feed = withContext(Dispatchers.IO) {
+            json.decodeFromStream<ReleaseFeed>(temporaryFeedPath.inputStream())
         }
 
-        return downloadAndExtractFunctionsToolingRelease(
-            toolingRelease,
-            toolingReleasePath,
-            coreToolsExecutablePath
-        )
+        temporaryFeedPath.deleteIfExists()
+
+        return Result.success(feed)
     }
 
+
     private suspend fun downloadAndExtractFunctionsToolingRelease(
         toolingRelease: FunctionsToolingRelease,
         toolingReleasePath: Path,
         coreToolsExecutablePath: Path,
     ): Result<Path> {
+        if (coreToolsExecutablePath.exists()) {
+            LOG.trace { "The release $toolingRelease is already downloaded" }
+            return Result.success(toolingReleasePath)
+        }
+
         functionsToolingReleaseMutex.withLock {
             if (coreToolsExecutablePath.exists()) {
                 LOG.trace { "The release $toolingRelease is already downloaded" }
                 return Result.success(toolingReleasePath)
             }
 
             try {
-                val tempFile = FileUtil.createTempFile(
-                    File(FileUtil.getTempDirectory()),
-                    "AzureFunctions-${toolingRelease.functionsVersion}-${toolingRelease.releaseTag}",
-                    ".zip",
-                    true,
-                    true
-                )
-
-                LOG.trace { "Created a temporary file: ${tempFile.absolutePath}" }
-
-                withContext(Dispatchers.IO) {
-                    client.prepareGet(toolingRelease.artifactUrl).execute { httpResponse ->
-                        val channel: ByteReadChannel = httpResponse.body()
-                        while (!channel.isClosedForRead) {
-                            val packet = channel.readRemaining(DEFAULT_BUFFER_SIZE.toLong())
-                            while (!packet.isEmpty) {
-                                val bytes = packet.readBytes()
-                                tempFile.appendBytes(bytes)
-                            }
-                        }
-                    }
-                }
+                val temporaryArchive = downloadFunctionsToolingArchive(toolingRelease)
 
-                LOG.trace { "Downloaded core tooling archive to the ${tempFile.absolutePath}" }
+                if (!toolingReleasePath.exists()) toolingReleasePath.createDirectories()
 
-                if (!toolingReleasePath.exists())
-                    toolingReleasePath.createDirectories()
+                LOG.trace { "Extracting from ${temporaryArchive.absolutePathString()} to $toolingReleasePath" }
+                ZipUtil.extract(temporaryArchive, toolingReleasePath, null, true)
 
-                LOG.trace { "Extracting from ${tempFile.absolutePath} to $toolingReleasePath" }
-                ZipUtil.extract(tempFile.toPath(), toolingReleasePath, null, true)
+                temporaryArchive.deleteIfExists()
 
-                if (tempFile.exists())
-                    tempFile.delete()
-
-                if (!coreToolsExecutablePath.isExecutable() && !SystemInfo.isWindows)
+                if (!coreToolsExecutablePath.isExecutable() && !SystemInfo.isWindows) {
                     setExecutablePermissionsForCoreTools(coreToolsExecutablePath)
+                }
 
                 return Result.success(toolingReleasePath)
             } catch (e: Exception) {
@@ -202,30 +233,28 @@ class FunctionsToolingFeedService : Disposable {
         }
     }
 
-    /**
-     * Retrieves a list of Azure Functions tooling releases for the specified Azure Functions runtime versions.
-     *
-     * @param functionsRuntimeVersions List of Azure Functions runtime versions.
-     * @return List of tooling releases corresponding to the given versions, or null if the release feed could not be downloaded.
-     */
-    suspend fun getFunctionsToolingReleaseForVersions(functionsRuntimeVersions: List<String>): List<FunctionsToolingRelease>? {
-        downloadAndSaveReleaseFeed().onFailure { exception ->
-            LOG.warn("Unable to download Function tooling release feed", exception)
-            return null
-        }
-
-        return functionsRuntimeVersions.mapNotNull { getLatestFunctionsToolingRelease(it) }
-    }
+    private suspend fun downloadFunctionsToolingArchive(toolingRelease: FunctionsToolingRelease): Path {
+        val temporaryArchive = FileUtil.createTempFile(
+            File(FileUtil.getTempDirectory()),
+            "AzureFunctions-${toolingRelease.functionsVersion}-${toolingRelease.releaseTag}",
+            ".zip",
+            true,
+            false
+        )
+        val temporaryArchivePath = temporaryArchive.toPath()
 
-    private suspend fun getReleaseFeed(): ReleaseFeed {
-        val feedUrl = Registry.get("azure.function_app.core_tools.feed.url").asString()
-        LOG.trace { "Functions tooling release feed: $feedUrl" }
+        LOG.trace { "Created a temporary file: ${temporaryArchivePath.absolutePathString()}" }
 
-        val response = withContext(Dispatchers.IO) {
-            client.get(feedUrl)
+        withContext(Dispatchers.IO) {
+            client.prepareGet(toolingRelease.artifactUrl).execute { httpResponse ->
+                val channel: ByteReadChannel = httpResponse.body()
+                channel.copyAndClose(temporaryArchive.writeChannel())
+            }
         }
 
-        return response.body<ReleaseFeed>()
+        LOG.trace { "Downloaded Functions tooling archive to the ${temporaryArchivePath.absolutePathString()}" }
+
+        return temporaryArchivePath
     }
 
     private fun getLatestFunctionsToolingRelease(functionsRuntimeVersion: String): FunctionsToolingRelease? {
@@ -284,4 +313,4 @@ class FunctionsToolingFeedService : Disposable {
     }
 
     override fun dispose() = client.close()
-}
+}
diff --git a/PluginsAndFeatures/azure-toolkit-for-rider/gradle.properties b/PluginsAndFeatures/azure-toolkit-for-rider/gradle.properties
@@ -4,7 +4,7 @@ pluginGroup = com.jetbrains
 pluginName = azure-toolkit-for-rider
 pluginRepositoryUrl = https://github.com/JetBrains/azure-tools-for-intellij
 # SemVer format -> https://semver.org
-pluginVersion = 4.3.9
+pluginVersion = 4.3.10
 
 # Supported build number ranges and IntelliJ Platform versions -> https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
 pluginSinceBuild = 243
