Add ability to write resolved version of SDK into the output variable (#324)

* update to use pwsh if it is available

* fix spacing

* update install script

* Update src/installer.ts

Co-authored-by: Ivan <98037481+IvanZosimov@users.noreply.github.com>

* update index.js

* fix format

Co-authored-by: Ivan <98037481+IvanZosimov@users.noreply.github.com>

.github/workflows/check-dist.yml

@@ -21,15 +21,16 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
-      - name: Set Node.js 12.x
-        uses: actions/setup-node@v1
+      - name: Set Node.js 16
+        uses: actions/setup-node@v3
         with:
-          node-version: 12.x
+          node-version: 16.x
+          cache: npm
 
       - name: Install dependencies
-        run: npm ci
+        run: npm ci --ignore-scripts
 
       - name: Rebuild the dist/ directory
         run: npm run build
@@ -44,7 +45,7 @@ jobs:
         id: diff
 
       # If index.js was different than expected, upload the expected version as an artifact
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v3
         if: ${{ failure() && steps.diff.conclusion == 'failure' }}
         with:
           name: dist

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,70 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '23 19 * * 0'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/licensed.yml

@@ -7,18 +7,19 @@ on:
   pull_request:
     branches:
       - main
+  workflow_dispatch:
 
 jobs:
   test:
     runs-on: ubuntu-latest
     name: Check licenses
     steps:
-      - uses: actions/checkout@v2
-      - run: npm ci
+      - uses: actions/checkout@v3
+      - run: npm ci --ignore-scripts
       - name: Install licensed
         run: |
           cd $RUNNER_TEMP
-          curl -Lfs -o licensed.tar.gz https://github.com/github/licensed/releases/download/2.12.2/licensed-2.12.2-linux-x64.tar.gz
+          curl -Lfs -o licensed.tar.gz https://github.com/github/licensed/releases/download/3.4.4/licensed-3.4.4-linux-x64.tar.gz
           sudo tar -xzf licensed.tar.gz
           sudo mv licensed /usr/local/bin/licensed
       - run: licensed status

.github/workflows/release-new-action-version.yml

@@ -22,7 +22,7 @@ jobs:
     steps:
     - name: Update the ${{ env.TAG_NAME }} tag
       id: update-major-tag
-      uses: actions/publish-action@v0.1.0
+      uses: actions/publish-action@v0.2.0
       with:
         source-tag: ${{ env.TAG_NAME }}
-        slack-webhook: ${{ secrets.SLACK_WEBHOOK }}
+        slack-webhook: ${{ secrets.SLACK_WEBHOOK }}

.github/workflows/test-dotnet.yml

@@ -21,7 +21,7 @@ jobs:
         dotnet-version: ['2.1', '2.2', '3.0', '3.1', '5.0']
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Clear toolcache
         shell: pwsh
         run: __tests__/clear-toolcache.ps1 ${{ runner.os }}

.github/workflows/workflow.yml

@@ -20,12 +20,13 @@ jobs:
         operating-system: [ubuntu-latest, windows-latest, macOS-latest]
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
-    - name: Set Node.js 12
-      uses: actions/setup-node@v1
+      uses: actions/checkout@v3
+    - name: Set Node.js 16
+      uses: actions/setup-node@v3
       with:
-        node-version: 12.x
-    - run: npm ci
+        node-version: 16.x
+        cache: npm
+    - run: npm ci --ignore-scripts
     - run: npm run build
     - run: npm run format-check
     - run: npm test
@@ -33,6 +34,29 @@ jobs:
       if: runner.os != 'windows'
       run: __tests__/verify-no-unstaged-changes.sh
 
+  test-setup-multiple-versions:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      - name: Setup dotnet 2.2.402 and 3.1.404
+        uses: ./
+        with:
+          dotnet-version: |
+            2.2.402
+            3.1.404
+            3.0.x
+      - name: Verify dotnet
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 2.2.402 3.1.404 '3.0'
+
   test-setup-full-version:
     runs-on: ${{ matrix.operating-system }}
     strategy:
@@ -41,7 +65,7 @@ jobs:
         operating-system: [ubuntu-latest, windows-latest, macOS-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Clear toolcache
         shell: pwsh
         run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
@@ -54,7 +78,7 @@ jobs:
         uses: ./
         with:
           dotnet-version: 3.1.201
-          # We are including this veriable to force the generation of the nuget config file to verify that it is created in the correct place
+          # We are including this variable to force the generation of the nuget config file to verify that it is created in the correct place
           source-url: https://api.nuget.org/v3/index.json
         env:
           NUGET_AUTH_TOKEN: NOTATOKEN
@@ -74,7 +98,7 @@ jobs:
         operating-system: [ubuntu-latest, windows-latest, macOS-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Clear toolcache
         shell: pwsh
         run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
@@ -90,7 +114,31 @@ jobs:
       - name: Verify dotnet
         shell: pwsh
         run: __tests__/verify-dotnet.ps1 3.1 2.2
-  
+
+  test-setup-prerelease-version:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      - name: Setup dotnet '2.2'
+        uses: ./
+        with:
+          dotnet-version: '2.2'
+      - name: Setup dotnet '3.1.100-preview1-014459'
+        uses: ./
+        with:
+          dotnet-version: '3.1.100-preview1-014459'
+      - name: Verify dotnet
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 3.1.100-preview1-014459
+
   test-setup-latest-patch-version:
     runs-on: ${{ matrix.operating-system }}
     strategy:
@@ -99,7 +147,7 @@ jobs:
         operating-system: [ubuntu-latest, windows-latest, macOS-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Clear toolcache
         shell: pwsh
         run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
@@ -107,13 +155,13 @@ jobs:
         uses: ./
         with:
           dotnet-version: 3.1.x
-      - name: Setup dotnet 2.2.x
+      - name: Setup dotnet 2.2.X
         uses: ./
         with:
-          dotnet-version: 2.2.x
+          dotnet-version: 2.2.X
       - name: Verify dotnet
         shell: pwsh
-        run: __tests__/verify-dotnet.ps1 3.1 2.2
+        run: __tests__/verify-dotnet.ps1 '2.2' '3.1'
 
   test-setup-with-wildcard:
     runs-on: ${{ matrix.operating-system }}
@@ -123,7 +171,7 @@ jobs:
         operating-system: [ubuntu-latest, windows-latest, macOS-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Clear toolcache
         shell: pwsh
         run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
@@ -139,6 +187,111 @@ jobs:
         shell: pwsh
         run: __tests__/verify-dotnet.ps1 3.1 2.2
 
+  test-setup-global-json-specified-and-version:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      - name: Write global.json
+        shell: bash
+        run: |
+          mkdir subdirectory
+          echo '{"sdk":{"version": "2.2","rollForward": "latestFeature"}}' > ./subdirectory/global.json
+      - name: Setup dotnet
+        uses: ./
+        with:
+          dotnet-version: 3.1
+          global-json-file: ./subdirectory/global.json
+      - name: Verify dotnet
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 2.2 3.1
+
+  test-setup-with-dotnet-quality:
+      runs-on: ${{ matrix.operating-system }}
+      strategy:
+        fail-fast: false
+        matrix:
+          operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+      steps:
+        - name: Checkout
+          uses: actions/checkout@v3
+        - name: Clear toolcache
+          shell: pwsh
+          run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+               
+        - name: Setup dotnet 7.0 with preview quality
+          uses: ./
+          with:
+            dotnet-version: "7.0"
+            dotnet-quality: "preview"
+        - name: Verify preview version
+          shell: pwsh
+          run: |
+            $version = & dotnet --version
+            Write-Host "Installed version: $version"
+            if (-not ($version.Contains("preview") -or $version.Contains("rc"))) { throw "Unexpected version" }
+  
+  test-dotnet-version-output-during-single-version-installation:
+      runs-on: ${{ matrix.operating-system }}
+      strategy:
+        fail-fast: false
+        matrix:
+          operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+      steps:
+        - name: Checkout
+          uses: actions/checkout@v3
+        - name: Clear toolcache
+          shell: pwsh
+          run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+               
+        - name: Setup dotnet 6.0.401
+          uses: ./
+          id: step1
+          with:
+            dotnet-version: "6.0.401"
+
+        - name: Verify value of the dotnet-version output
+          shell: pwsh
+          run: |
+            $version = & dotnet --version
+            Write-Host "Installed version: $version"
+            if (-not ($version -eq '${{steps.step1.outputs.dotnet-version}}')) { throw "Unexpected output value" }
+  
+  test-dotnet-version-output-during-multiple-version-installation:
+      runs-on: ${{ matrix.operating-system }}
+      strategy:
+        fail-fast: false
+        matrix:
+          operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+      steps:
+        - name: Checkout
+          uses: actions/checkout@v3
+        - name: Clear toolcache
+          shell: pwsh
+          run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+               
+        - name: Setup dotnet 6.0.401, 5.0.408, 7.0.100-rc.1.22431.12
+          uses: ./
+          id: step2
+          with:
+            dotnet-version: |
+              7.0.100-rc.1.22431.12
+              6.0.401
+              5.0.408
+
+        - name: Verify value of the dotnet-version output
+          shell: pwsh
+          run: |
+            $version = "7.0.100-rc.1.22431.12"
+            if (-not ($version -eq '${{steps.step2.outputs.dotnet-version}}')) { throw "Unexpected output value" }
+
   test-proxy:
     runs-on: ubuntu-latest
     container:
@@ -154,7 +307,7 @@ jobs:
       http_proxy: http://squid-proxy:3128
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Clear tool cache
         run: rm -rf "/usr/share/dotnet"
       - name: Install curl
@@ -178,7 +331,7 @@ jobs:
       no_proxy: github.com,dotnetcli.blob.core.windows.net,download.visualstudio.microsoft.com,api.nuget.org,dotnetcli.azureedge.net
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Clear tool cache
         run: rm -rf "/usr/share/dotnet"
       - name: Setup dotnet 3.1.201

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm run format

.husky/pre-push

@@ -0,0 +1,5 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+# Tests are not run at push time since they can take 2-4 minutes to complete
+npm run format-check

.licenses/npm/@actions/core.dep.yml

@@ -1,6 +1,6 @@
 ---
 name: "@actions/core"
-version: 1.2.6
+version: 1.9.1
 type: npm
 summary: Actions core lib
 homepage: https://github.com/actions/toolkit/tree/main/packages/core

.licenses/npm/@actions/exec.dep.yml

@@ -1,30 +1,20 @@
 ---
 name: "@actions/exec"
-version: 1.0.4
+version: 1.1.1
 type: npm
 summary: Actions exec lib
-homepage: https://github.com/actions/toolkit/tree/master/packages/exec
+homepage: https://github.com/actions/toolkit/tree/main/packages/exec
 license: mit
 licenses:
-- sources: Auto-generated MIT license text
-  text: |
-    MIT License
+- sources: LICENSE.md
+  text: |-
+    The MIT License (MIT)
 
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
+    Copyright 2019 GitHub
 
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
+    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE.
+    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 notices: []

.licenses/npm/@actions/http-client.dep.yml

@@ -1,9 +1,9 @@
 ---
 name: "@actions/http-client"
-version: 1.0.8
+version: 2.0.1
 type: npm
 summary: Actions Http Client
-homepage: https://github.com/actions/http-client#readme
+homepage: https://github.com/actions/toolkit/tree/main/packages/http-client
 license: mit
 licenses:
 - sources: LICENSE

.licenses/npm/@actions/io.dep.yml

@@ -1,30 +1,20 @@
 ---
 name: "@actions/io"
-version: 1.0.2
+version: 1.1.2
 type: npm
 summary: Actions io lib
-homepage: https://github.com/actions/toolkit/tree/master/packages/io
+homepage: https://github.com/actions/toolkit/tree/main/packages/io
 license: mit
 licenses:
-- sources: Auto-generated MIT license text
-  text: |
-    MIT License
+- sources: LICENSE.md
+  text: |-
+    The MIT License (MIT)
 
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
+    Copyright 2019 GitHub
 
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
+    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE.
+    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 notices: []

.licenses/npm/node-fetch.dep.yml

@@ -1,6 +1,6 @@
 ---
 name: node-fetch
-version: 2.6.1
+version: 2.6.7
 type: npm
 summary: A light-weight module that brings window.fetch to node.js
 homepage: https://github.com/bitinn/node-fetch

.licenses/npm/tr46.dep.yml

@@ -0,0 +1,30 @@
+---
+name: tr46
+version: 0.0.3
+type: npm
+summary: An implementation of the Unicode TR46 spec
+homepage: https://github.com/Sebmaster/tr46.js#readme
+license: mit
+licenses:
+- sources: Auto-generated MIT license text
+  text: |
+    MIT License
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+notices: []

.licenses/npm/uuid.dep.yml

@@ -0,0 +1,20 @@
+---
+name: uuid
+version: 8.3.2
+type: npm
+summary: RFC4122 (v1, v4, and v5) UUIDs
+homepage: 
+license: mit
+licenses:
+- sources: LICENSE.md
+  text: |
+    The MIT License (MIT)
+
+    Copyright (c) 2010-2020 Robert Kieffer and other contributors
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+notices: []

.licenses/npm/webidl-conversions.dep.yml

@@ -0,0 +1,23 @@
+---
+name: webidl-conversions
+version: 3.0.1
+type: npm
+summary: Implements the WebIDL algorithms for converting to and from JavaScript values
+homepage: 
+license: bsd-2-clause
+licenses:
+- sources: LICENSE.md
+  text: |
+    # The BSD 2-Clause License
+
+    Copyright (c) 2014, Domenic Denicola
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+notices: []

.licenses/npm/whatwg-url.dep.yml

@@ -0,0 +1,32 @@
+---
+name: whatwg-url
+version: 5.0.0
+type: npm
+summary: An implementation of the WHATWG URL Standard's URL API and parsing machinery
+homepage: 
+license: mit
+licenses:
+- sources: LICENSE.txt
+  text: |
+    The MIT License (MIT)
+
+    Copyright (c) 2015–2016 Sebastian Mayr
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.
+notices: []

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at opensource+actions/setup-dotnet@github.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

README.md

@@ -1,48 +1,89 @@
 # setup-dotnet
 
-<p align="left">
-  <a href="https://github.com/actions/setup-dotnet"><img alt="GitHub Actions status" src="https://github.com/actions/setup-dotnet/workflows/Main%20workflow/badge.svg"></a>
-</p>
+[![GitHub Actions Status](https://github.com/actions/setup-dotnet/workflows/Main%20workflow/badge.svg)](https://github.com/actions/setup-dotnet)
 
-This action sets up a [dotnet core cli](https://github.com/dotnet/cli) environment for use in actions by:
+This action sets up a [.NET CLI](https://github.com/dotnet/sdk) environment for use in actions by:
 
-- optionally downloading and caching a version of dotnet by SDK version and adding to PATH
+- optionally downloading and caching a version(s) of dotnet by SDK version(s) and adding to PATH
 - registering problem matchers for error output
 - setting up authentication to private package sources like GitHub Packages
 
-Please Note: GitHub hosted runners have some versions of the .NET SDK
+> **Note**: GitHub hosted runners have some versions of the .NET SDK
 preinstalled. Installed versions are subject to change. Please refer to the
 documentation
 [software installed on github hosted runners](https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#supported-software)
 for .NET SDK versions that are currently available.
 
-# Usage
+## Usage
 
 See [action.yml](action.yml)
 
-Basic:
+**Basic**:
 ```yaml
 steps:
-- uses: actions/checkout@v2
-- uses: actions/setup-dotnet@v1
+- uses: actions/checkout@v3
+- uses: actions/setup-dotnet@v3
   with:
-    dotnet-version: '3.1.x' # SDK Version to use; x will use the latest version of the 3.1 channel
+    dotnet-version: '3.1.x'
 - run: dotnet build <my project>
 ```
 
-Preview version:
+**Multiple version installation**:
 ```yml
 steps:
-- uses: actions/checkout@v2
-- uses: actions/setup-dotnet@v1
+- uses: actions/checkout@v3
+- name: Setup dotnet
+  uses: actions/setup-dotnet@v3
+  with:
+    dotnet-version: | 
+      3.1.x
+      5.0.x
+- run: dotnet build <my project>
+```
+> **Note**: In case multiple versions are installed, the latest .NET version will be used by default unless another version is specified in the `global.json` file.
+
+## Supported version syntax
+
+The `dotnet-version` input supports following syntax:
+
+- **A.B.C** (e.g 6.0.400, 7.0.100-preview.7.22377.5) - installs exact version of .NET SDK
+- **A.B** or **A.B.x** (e.g. 3.1, 3.1.x) - installs the latest patch version of .NET SDK on the channel `3.1`, including prerelease versions (preview, rc)
+- **A** or **A.x** (e.g. 3, 3.x) - installs the latest minor version of the specified major tag, including prerelease versions (preview, rc)
+
+
+## Using the `dotnet-quality` input
+This input sets up the action to install the latest build of the specified quality in the channel. The possible values of `dotnet-quality` are: **daily**, **signed**, **validated**, **preview**, **ga**.
+
+> **Note**: `dotnet-quality` input can be used only with .NET SDK version in 'A.B', 'A.B.x', 'A' and 'A.x' formats where the major version is higher than 5. In other cases, `dotnet-quality` input will be ignored.
+
+```yml
+steps:
+- uses: actions/checkout@v3
+- uses: actions/setup-dotnet@v3
   with:
     dotnet-version: '6.0.x'
-    include-prerelease: true
+    dotnet-quality: 'preview'
 - run: dotnet build <my project>
 ```
 
-Matrix Testing:
-```yaml
+## Using the `global-json-file` input
+`setup-dotnet` action can read .NET SDK version from a `global.json` file. Input `global-json-file` is used for specifying the path to the `global.json`. If the file that was supplied to `global-json-file` input doesn't exist, the action will fail with error.
+
+>**Note**: In case both `dotnet-version` and `global-json-file` inputs are used, versions from both inputs will be installed.
+
+```yml
+steps:
+- uses: actions/checkout@v3
+- uses: actions/setup-dotnet@v3
+  with:
+    global-json-file: csharp/global.json
+- run: dotnet build <my project>
+  working-directory: csharp
+```
+
+## Matrix Testing
+Using `setup-dotnet` it's possible to use [matrix syntax](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstrategymatrix) to install several versions of .NET SDK:
+```yml
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -51,42 +92,22 @@ jobs:
         dotnet: [ '2.1.x', '3.1.x', '5.0.x' ]
     name: Dotnet ${{ matrix.dotnet }} sample
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Setup dotnet
-        uses: actions/setup-dotnet@v1
+        uses: actions/setup-dotnet@v3
         with:
           dotnet-version: ${{ matrix.dotnet }}
       - run: dotnet build <my project>
 ```
+## Setting up authentication for nuget feeds
 
-Side by Side Testing:
-```yaml
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    name: Dotnet Side by Side testing sample
-    steps:
-      - uses: actions/checkout@v2
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: '2.1.x'
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: '3.1.x'
-      - run: dotnet build <my project>
-      - run: dotnet test <my project>
-```
-
-Authentication for nuget feeds:
-```yaml
+### Github Package Registry (GPR)
+```yml
 steps:
-- uses: actions/checkout@v2
-# Authenticates packages to push to GPR
-- uses: actions/setup-dotnet@v1
+- uses: actions/checkout@v3
+- uses: actions/setup-dotnet@v3
   with:
-    dotnet-version: '3.1.x' # SDK Version to use.
+    dotnet-version: '3.1.x'
     source-url: https://nuget.pkg.github.com/<owner>/index.json
   env:
     NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
@@ -95,19 +116,22 @@ steps:
   run: dotnet pack --configuration Release <my project>
 - name: Publish the package to GPR
   run: dotnet nuget push <my project>/bin/Release/*.nupkg
+```
 
-# Authenticates packages to push to Azure Artifacts
-- uses: actions/setup-dotnet@v1
+### Azure Artifacts
+```yml
+- uses: actions/setup-dotnet@v3
   with:
     source-url: https://pkgs.dev.azure.com/<your-organization>/_packaging/<your-feed-name>/nuget/v3/index.json
   env:
     NUGET_AUTH_TOKEN: ${{secrets.AZURE_DEVOPS_PAT}} # Note, create a secret with this name in Settings
 - name: Publish the package to Azure Artifacts
   run: dotnet nuget push <my project>/bin/Release/*.nupkg
+```
 
-# Authenticates packages to push to nuget.org.
-# It's only the way to push a package to nuget.org feed for macOS/Linux machines due to API key config store limitations.
-- uses: actions/setup-dotnet@v1
+### nuget.org
+```yml
+- uses: actions/setup-dotnet@v3
   with:
     dotnet-version: 3.1.x
 - name: Publish the package to nuget.org
@@ -115,32 +139,83 @@ steps:
   env:
     NUGET_AUTH_TOKEN: ${{ secrets.NUGET_TOKEN }}
 ```
+> **Note**: It's the only way to push a package to nuget.org feed for macOS/Linux machines due to API key config store limitations.
 
-## Environment Variables to use with dotnet
+# Outputs and environment variables
+
+## Outputs
+
+### `dotnet-version`
+
+Using the **dotnet-version** output it's possible to get the installed by the action .NET SDK version. 
+
+**Single version installation**
+
+In case of a single version installation, the `dotnet-version` output contains the version that is installed by the action.
+
+```yaml
+    - uses: actions/setup-dotnet@v3
+      id: cp310
+      with:
+        dotnet-version: 3.1.422
+    - run: echo '${{ steps.cp310.outputs.dotnet-version }}' # outputs 3.1.422
+```
+
+**Multiple version installation**
+
+In case of a multiple version installation, the `dotnet-version` output contains the latest version that is installed by the action.
+
+```yaml
+    - uses: actions/setup-dotnet@v3
+      id: cp310
+      with:
+        dotnet-version: | 
+          3.1.422
+          5.0.408
+    - run: echo '${{ steps.cp310.outputs.dotnet-version }}' # outputs 5.0.408
+```
+**Installation from global.json**
+
+When the `dotnet-version` input is used along with the `global-json-file` input, the `dotnet-version` output contains the version resolved from the `global.json`.
+
+```yaml
+    - uses: actions/setup-dotnet@v3
+      id: cp310
+      with:
+        dotnet-version: | 
+          3.1.422
+          5.0.408
+        global-json-file: "./global.json" # contains version 2.2.207
+    - run: echo '${{ steps.cp310.outputs.dotnet-version }}' # outputs 2.2.207
+```
+
+## Environment variables
 
 Some environment variables may be necessary for your particular case or to improve logging. Some examples are listed below, but the full list with complete details can be found here: https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-environment-variables
 
-- DOTNET_NOLOGO - removes logo and telemetry message from first run of dotnet cli (default: false)
-- DOTNET_CLI_TELEMETRY_OPTOUT - opt-out of telemetry being sent to Microsoft (default: false)
-- DOTNET_MULTILEVEL_LOOKUP - configures whether the global install location is used as a fall-back (default: true)
+| **Env.variable**      | **Description** | **Default value** |
+| ----------- | ----------- | ----------- |
+| DOTNET_NOLOGO      |Removes logo and telemetry message from first run of dotnet cli|*false*|
+| DOTNET_CLI_TELEMETRY_OPTOUT   |Opt-out of telemetry being sent to Microsoft|*false*|
+| DOTNET_MULTILEVEL_LOOKUP   |Configures whether the global install location is used as a fall-back|*true*|
 
-Example usage:
-```yaml
+**Example usage**:
+```yml
 build:
   runs-on: ubuntu-latest
   env:
     DOTNET_NOLOGO: true
   steps:
     - uses: actions/checkout@main
-    - uses: actions/setup-dotnet@v1
+    - uses: actions/setup-dotnet@v3
       with:
-        dotnet-version: '3.1.x' # SDK Version to use.
+        dotnet-version: '3.1.x'
 ```
 
-# License
+## License
 
 The scripts and documentation in this project are released under the [MIT License](LICENSE)
 
-# Contributions
+## Contributions
 
-Contributions are welcome!  See [Contributor's Guide](docs/contributors.md)
+Contributions are welcome! See [Contributor's Guide](docs/contributors.md)

__tests__/authutil.test.ts

@@ -1,6 +1,6 @@
-import io = require('@actions/io');
-import fs = require('fs');
-import path = require('path');
+import * as io from '@actions/io';
+import fs from 'fs';
+import path from 'path';
 
 const fakeSourcesDirForTesting = path.join(
   __dirname,

__tests__/csc.test.ts

@@ -1,5 +1,3 @@
-import fs = require('fs');
-
 describe('csc tests', () => {
   it('Valid regular expression', async () => {
     var cscFile = require('../.github/csc.json');

__tests__/installer.test.ts

@@ -1,37 +1,79 @@
-import io = require('@actions/io');
-import fs = require('fs');
-import os = require('os');
-import path = require('path');
-import hc = require('@actions/http-client');
+import * as io from '@actions/io';
+import * as os from 'os';
+import fs from 'fs';
+import path from 'path';
+import each from 'jest-each';
+import * as hc from '@actions/http-client';
+import * as installer from '../src/installer';
+import {QualityOptions} from '../src/setup-dotnet';
 
-const toolDir = path.join(__dirname, 'runner', 'tools');
+import {IS_WINDOWS} from '../src/utils';
+import {IS_LINUX} from '../src/utils';
+
+let toolDir: string;
+
+if (IS_WINDOWS) {
+  toolDir = path.join(process.env['PROGRAMFILES'] + '', 'dotnet');
+} else if (IS_LINUX) {
+  toolDir = '/usr/share/dotnet';
+} else {
+  toolDir = path.join(process.env['HOME'] + '', '.dotnet');
+}
 const tempDir = path.join(__dirname, 'runner', 'temp');
 
 process.env['RUNNER_TOOL_CACHE'] = toolDir;
 process.env['RUNNER_TEMP'] = tempDir;
-import * as installer from '../src/installer';
 
-const IS_WINDOWS = process.platform === 'win32';
-
-describe('installer tests', () => {
+describe('DotnetCoreInstaller tests', () => {
   beforeAll(async () => {
     process.env.RUNNER_TOOL_CACHE = toolDir;
     process.env.DOTNET_INSTALL_DIR = toolDir;
     process.env.RUNNER_TEMP = tempDir;
     process.env.DOTNET_ROOT = '';
-    await io.rmRF(toolDir);
-    await io.rmRF(tempDir);
-  });
-
-  afterAll(async () => {
     try {
-      await io.rmRF(toolDir);
-      await io.rmRF(tempDir);
-    } catch {
-      console.log('Failed to remove test directories');
+      await io.rmRF(`${toolDir}/*`);
+      await io.rmRF(`${tempDir}/*`);
+    } catch (err) {
+      console.log(
+        `Failed to remove test directories, check the error message:${os.EOL}`,
+        err.message
+      );
     }
   }, 30000);
 
+  afterEach(async () => {
+    try {
+      await io.rmRF(`${toolDir}/*`);
+      await io.rmRF(`${tempDir}/*`);
+    } catch (err) {
+      console.log(
+        `Failed to remove test directories, check the error message:${os.EOL}`,
+        err.message
+      );
+    }
+  }, 30000);
+
+  it('Aquires multiple versions of dotnet', async () => {
+    const versions = ['2.2.207', '3.1.120'];
+
+    for (const version of versions) {
+      await getDotnet(version);
+    }
+    expect(fs.existsSync(path.join(toolDir, 'sdk', '2.2.207'))).toBe(true);
+    expect(fs.existsSync(path.join(toolDir, 'sdk', '3.1.120'))).toBe(true);
+
+    if (IS_WINDOWS) {
+      expect(fs.existsSync(path.join(toolDir, 'dotnet.exe'))).toBe(true);
+    } else {
+      expect(fs.existsSync(path.join(toolDir, 'dotnet'))).toBe(true);
+    }
+
+    expect(process.env.DOTNET_ROOT).toBeDefined;
+    expect(process.env.PATH).toBeDefined;
+    expect(process.env.DOTNET_ROOT).toBe(toolDir);
+    expect(process.env.PATH?.startsWith(toolDir)).toBe(true);
+  }, 600000);
+
   it('Acquires version of dotnet if no matching version is installed', async () => {
     await getDotnet('3.1.201');
     expect(fs.existsSync(path.join(toolDir, 'sdk', '3.1.201'))).toBe(true);
@@ -65,14 +107,19 @@ describe('installer tests', () => {
     expect(process.env.PATH?.startsWith(toolDir)).toBe(true);
   }, 600000); //This needs some time to download on "slower" internet connections
 
+  it('Returns string with installed SDK version', async () => {
+    const version = '3.1.120';
+    let installedVersion: string;
+
+    installedVersion = await getDotnet(version);
+
+    expect(installedVersion).toBe('3.1.120');
+  }, 600000);
+
   it('Throws if no location contains correct dotnet version', async () => {
-    let thrown = false;
-    try {
+    await expect(async () => {
       await getDotnet('1000.0.0');
-    } catch {
-      thrown = true;
-    }
-    expect(thrown).toBe(true);
+    }).rejects.toThrow();
   }, 30000);
 
   it('Uses an up to date bash download script', async () => {
@@ -116,6 +163,112 @@ describe('installer tests', () => {
   }, 30000);
 });
 
+describe('DotnetVersionResolver tests', () => {
+  each([
+    '3.1',
+    '3.x',
+    '3.1.x',
+    '3.1.*',
+    '3.1.X',
+    '3.1.2',
+    '3.1.0-preview1'
+  ]).test(
+    "if valid version: '%s' is supplied, it should return version object with some value",
+    async version => {
+      const dotnetVersionResolver = new installer.DotnetVersionResolver(
+        version
+      );
+      const versionObject = await dotnetVersionResolver.createDotNetVersion();
+
+      expect(!!versionObject.value).toBeTruthy;
+    }
+  );
+
+  each([
+    '.',
+    '..',
+    ' . ',
+    '. ',
+    ' .',
+    ' . . ',
+    ' .. ',
+    ' .  ',
+    '-1.-1',
+    '-1',
+    '-1.-1.-1',
+    '..3',
+    '1..3',
+    '1..',
+    '.2.3',
+    '.2.x',
+    '*.',
+    '1.2.',
+    '1.2.-abc',
+    'a.b',
+    'a.b.c',
+    'a.b.c-preview',
+    ' 0 . 1 . 2 ',
+    'invalid'
+  ]).test(
+    "if invalid version: '%s' is supplied, it should throw",
+    async version => {
+      const dotnetVersionResolver = new installer.DotnetVersionResolver(
+        version
+      );
+
+      await expect(
+        async () => await dotnetVersionResolver.createDotNetVersion()
+      ).rejects.toThrow();
+    }
+  );
+
+  each(['3.1', '3.1.x', '3.1.*', '3.1.X']).test(
+    "if version: '%s' that can be resolved to 'channel' option is supplied, it should set quality flag to 'true' and type to 'channel' in version object",
+    async version => {
+      const dotnetVersionResolver = new installer.DotnetVersionResolver(
+        version
+      );
+      const versionObject = await dotnetVersionResolver.createDotNetVersion();
+
+      expect(versionObject.type.toLowerCase().includes('channel')).toBeTruthy;
+      expect(versionObject.qualityFlag).toBeTruthy;
+    }
+  );
+
+  each(['3.1.2', '3.1.0-preview1']).test(
+    "if version: '%s' that can be resolved to 'version' option is supplied, it should set quality flag to 'false' and type to 'version' in version object",
+    async version => {
+      const dotnetVersionResolver = new installer.DotnetVersionResolver(
+        version
+      );
+      const versionObject = await dotnetVersionResolver.createDotNetVersion();
+
+      expect(versionObject.type.toLowerCase().includes('version')).toBeTruthy;
+      expect(versionObject.qualityFlag).toBeFalsy;
+    }
+  );
+
+  each(['3.1.2', '3.1']).test(
+    'it should create proper line arguments for powershell/bash installation scripts',
+    async version => {
+      const dotnetVersionResolver = new installer.DotnetVersionResolver(
+        version
+      );
+      const versionObject = await dotnetVersionResolver.createDotNetVersion();
+      const windowsRegEx = new RegExp(/^-[VC]/);
+      const nonWindowsRegEx = new RegExp(/^--[vc]/);
+
+      if (IS_WINDOWS) {
+        expect(windowsRegEx.test(versionObject.type)).toBeTruthy;
+        expect(nonWindowsRegEx.test(versionObject.type)).toBeFalsy;
+      } else {
+        expect(nonWindowsRegEx.test(versionObject.type)).toBeTruthy;
+        expect(windowsRegEx.test(versionObject.type)).toBeFalsy;
+      }
+    }
+  );
+});
+
 function normalizeFileContents(contents: string): string {
   return contents
     .trim()
@@ -123,7 +276,15 @@ function normalizeFileContents(contents: string): string {
     .replace(new RegExp('\r', 'g'), '\n');
 }
 
-async function getDotnet(version: string): Promise<void> {
-  const dotnetInstaller = new installer.DotnetCoreInstaller(version);
-  await dotnetInstaller.installDotnet();
+async function getDotnet(
+  version: string,
+  quality: string = ''
+): Promise<string> {
+  const dotnetInstaller = new installer.DotnetCoreInstaller(
+    version,
+    quality as QualityOptions
+  );
+  const installedVersion = await dotnetInstaller.installDotnet();
+  installer.DotnetCoreInstaller.addToPath();
+  return installedVersion;
 }

__tests__/sample-csproj/sample.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp3.1;netcoreapp2.2</TargetFrameworks>
+    <TargetFrameworks>netcoreapp3.1;netcoreapp3.0;netcoreapp2.2</TargetFrameworks>
     <RootNamespace>sample_csproj</RootNamespace>
 
     <IsPackable>false</IsPackable>

__tests__/setup-dotnet.test.ts

@@ -1,31 +1,52 @@
-import io = require('@actions/io');
-import fs = require('fs');
-import os = require('os');
-import path = require('path');
-
-const toolDir = path.join(__dirname, 'runner', 'tools2');
-const tempDir = path.join(__dirname, 'runner', 'temp2');
+import * as io from '@actions/io';
+import * as core from '@actions/core';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
 
 import * as setup from '../src/setup-dotnet';
-import * as dotnetInstaller from '../src/installer';
+import {IS_WINDOWS} from '../src/utils';
+import {IS_LINUX} from '../src/utils';
 
-const IS_WINDOWS = process.platform === 'win32';
+let toolDir: string;
+
+if (IS_WINDOWS) {
+  toolDir = path.join(process.env['PROGRAMFILES'] + '', 'dotnet');
+} else if (IS_LINUX) {
+  toolDir = '/usr/share/dotnet';
+} else {
+  toolDir = path.join(process.env['HOME'] + '', '.dotnet');
+}
+
+const tempDir = path.join(__dirname, 'runner', 'temp2');
 
 describe('setup-dotnet tests', () => {
+  let getInputSpy = jest.spyOn(core, 'getInput');
+  let getMultilineInputSpy = jest.spyOn(core, 'getMultilineInput');
+  let setOutputSpy = jest.spyOn(core, 'setOutput');
+
+  let inputs = {} as any;
+
   beforeAll(async () => {
     process.env.RUNNER_TOOL_CACHE = toolDir;
     process.env.DOTNET_INSTALL_DIR = toolDir;
     process.env.RUNNER_TEMP = tempDir;
-    await io.rmRF(toolDir);
-    await io.rmRF(tempDir);
-  });
+    try {
+      await io.rmRF(`${toolDir}/*`);
+      await io.rmRF(`${tempDir}/*`);
+    } catch (err) {
+      console.log(err.message);
+      console.log('Failed to remove test directories');
+    }
+  }, 30000);
 
   afterEach(async () => {
     try {
       await io.rmRF(path.join(process.cwd(), 'global.json'));
-      await io.rmRF(toolDir);
-      await io.rmRF(tempDir);
-    } catch {
+      await io.rmRF(`${toolDir}/*`);
+      await io.rmRF(`${tempDir}/*`);
+    } catch (err) {
+      console.log(err.message);
       console.log('Failed to remove test directories');
     }
   }, 30000);
@@ -46,25 +67,32 @@ describe('setup-dotnet tests', () => {
     }
   }, 400000);
 
-  it('Acquires version of dotnet from global.json with rollForward option, install the latest patch', async () => {
+  it("Sets output with the latest installed by action version if global.json file isn't specified", async () => {
+    inputs['dotnet-version'] = ['3.1.201', '6.0.401'];
+
+    getMultilineInputSpy.mockImplementation(input => inputs[input]);
+
+    await setup.run();
+
+    expect(setOutputSpy).toBeCalledWith('dotnet-version', '6.0.401');
+  }, 400000);
+
+  it("Sets output with the version specified in global.json, if it's present", async () => {
     const globalJsonPath = path.join(process.cwd(), 'global.json');
-    const jsonContents = `{${os.EOL}"sdk": {${os.EOL}"version":"3.1.201",${os.EOL}"rollForward":"latestFeature"${os.EOL}}${os.EOL}}`;
+    const jsonContents = `{${os.EOL}"sdk": {${os.EOL}"version": "3.0.103"${os.EOL}}${os.EOL}}`;
     if (!fs.existsSync(globalJsonPath)) {
       fs.writeFileSync(globalJsonPath, jsonContents);
     }
 
-    const version = '3.1';
-    const installer = new dotnetInstaller.DotnetCoreInstaller(version);
-    const patchVersion = await installer.resolveVersion(
-      new dotnetInstaller.DotNetVersionInfo(version)
-    );
+    inputs['dotnet-version'] = ['3.1.201', '6.0.401'];
+    inputs['global-json-file'] = './global.json';
+
+    getMultilineInputSpy.mockImplementation(input => inputs[input]);
+
+    getInputSpy.mockImplementation(input => inputs[input]);
+
     await setup.run();
 
-    expect(fs.existsSync(path.join(toolDir, 'sdk', patchVersion))).toBe(true);
-    if (IS_WINDOWS) {
-      expect(fs.existsSync(path.join(toolDir, 'dotnet.exe'))).toBe(true);
-    } else {
-      expect(fs.existsSync(path.join(toolDir, 'dotnet'))).toBe(true);
-    }
+    expect(setOutputSpy).toBeCalledWith('dotnet-version', '3.0.103');
   }, 400000);
 });

__tests__/verify-dotnet.ps1

@@ -6,12 +6,15 @@ if (!$args[0])
 $dotnet = Get-Command dotnet | Select-Object -First 1 | ForEach-Object { $_.Path }
 Write-Host "Found '$dotnet'"
 
-$version = & $dotnet --version | Out-String | ForEach-Object { $_.Trim() }
-Write-Host "Version $version"
-if (-not ($version.StartsWith($args[0].ToString())))
+if($args.count -eq 1)
 {
-  Write-Host "PATH='$env:PATH'"
-  throw "Unexpected version"
+  $version = & $dotnet --version | Out-String | ForEach-Object { $_.Trim() }
+  Write-Host "Version $version"
+  if (-not ($version.StartsWith($args[0].ToString())))
+  {
+    Write-Host "PATH='$env:PATH'"
+    throw "Unexpected version"
+  }
 }
 
 if ($args[1])
@@ -19,16 +22,17 @@ if ($args[1])
   # SDKs are listed on multiple lines with the path afterwards in square brackets
   $versions = & $dotnet --list-sdks | ForEach-Object { $_.SubString(0, $_.IndexOf('[')).Trim() }
   Write-Host "Installed versions: $versions"
-  $isInstalledVersion = $false
-  foreach ($version in $versions)
-  {
-    if ($version.StartsWith($args[1].ToString())) 
+  $InstalledVersionCount = 0
+  foreach($arg in $args){
+    foreach ($version in $versions)
     {
-      $isInstalledVersion = $true
-      break
+      if ($version.StartsWith($arg.ToString())) 
+      {
+        $InstalledVersionCount++
+      }
     }
-  }
-  if (-not $isInstalledVersion)
+   }
+  if ( $InstalledVersionCount -ne $args.Count)
   {
     Write-Host "PATH='$env:PATH'"
     throw "Unexpected version"
@@ -53,6 +57,13 @@ if ($args[1])
     throw "Unexpected output"
   }
 }
+if ($args[2])
+{
+  if ($sample_output -notlike "*Test Run Successful.*Test Run Successful.*Test Run Successful.*")
+  {
+    throw "Unexpected output"
+  }
+}
 else
 {
   if ($sample_output -notlike "*Test Run Successful.*")

__tests__/verify-no-unstaged-changes.sh

@@ -1,17 +1,7 @@
 #!/bin/bash
 
-if [[ "$(git status --porcelain)" != "" ]]; then
-    echo ----------------------------------------
-    echo git status
-    echo ----------------------------------------
-    git status
-    echo ----------------------------------------
-    echo git diff
-    echo ----------------------------------------
+if [ "$(git diff --ignore-space-at-eol dist/ | wc -l)" -gt "0" ]; then
+    echo "Detected uncommitted changes after build.  See status below:"
     git diff
-    echo ----------------------------------------
-    echo Troubleshooting
-    echo ----------------------------------------
-    echo "::error::Unstaged changes detected. Locally try running: git clean -ffdx && npm ci && npm run pre-checkin"
     exit 1
 fi

__tests__/versionutil.test.ts

@@ -1,91 +0,0 @@
-import each from 'jest-each';
-import * as installer from '../src/installer';
-
-describe('version tests', () => {
-  each(['3.1.999', '3.1.101-preview.3']).test(
-    "Exact version '%s' should be the same",
-    vers => {
-      let versInfo = new installer.DotNetVersionInfo(vers);
-
-      expect(versInfo.isExactVersion()).toBe(true);
-      expect(versInfo.version()).toBe(vers);
-    }
-  );
-
-  each([
-    ['3.x', '3.x'],
-    ['3.*', '3.*'],
-    ['3.1.x', '3.1'],
-    ['1.1.*', '1.1'],
-    ['2.0', '2.0']
-  ]).test("Generic version '%s' should be '%s'", (vers, resVers) => {
-    let versInfo = new installer.DotNetVersionInfo(vers);
-
-    expect(versInfo.isExactVersion()).toBe(false);
-    expect(versInfo.version()).toBe(resVers);
-  });
-
-  each([
-    '',
-    '.',
-    '..',
-    ' . ',
-    '. ',
-    ' .',
-    ' . . ',
-    ' .. ',
-    ' .  ',
-    '-1.-1',
-    '-1',
-    '-1.-1.-1',
-    '..3',
-    '1..3',
-    '1..',
-    '.2.3',
-    '.2.x',
-    '1',
-    '*.*.1',
-    '*.1',
-    '*.',
-    '1.2.',
-    '1.2.-abc',
-    'a.b',
-    'a.b.c',
-    'a.b.c-preview',
-    ' 0 . 1 . 2 '
-  ]).test("Malformed version '%s' should throw", vers => {
-    expect(() => new installer.DotNetVersionInfo(vers)).toThrow();
-  });
-
-  each([
-    ['3.1.x', '3.1.'],
-    ['3.1.*', '3.1.'],
-    ['3.1', '3.1.'],
-    ['5.0.0-preview.6', '5.0.0-preview.6'],
-    ['3.1.201', '3.1.201']
-  ]).test(
-    "Resolving version '%s' as '%s'",
-    async (input, expectedVersion) => {
-      const dotnetInstaller = new installer.DotnetCoreInstaller(input);
-      let versInfo = await dotnetInstaller.resolveVersion(
-        new installer.DotNetVersionInfo(input)
-      );
-      console.log(versInfo);
-
-      expect(versInfo.startsWith(expectedVersion));
-    },
-    100000
-  );
-
-  it('Resolving a nonexistent generic version fails', async () => {
-    const dotnetInstaller = new installer.DotnetCoreInstaller('999.1.x');
-    try {
-      await dotnetInstaller.resolveVersion(
-        new installer.DotNetVersionInfo('999.1.x')
-      );
-      fail();
-    } catch {
-      expect(true);
-    }
-  }, 100000);
-});

action.yml

@@ -6,16 +6,20 @@ branding:
   color: green
 inputs:
   dotnet-version:
-    description: 'Optional SDK version to use. If not provided, will install global.json version when available. Examples: 2.2.104, 3.1, 3.1.x'
+    description: 'Optional SDK version(s) to use. If not provided, will install global.json version when available. Examples: 2.2.104, 3.1, 3.1.x, 3.x'
+  dotnet-quality:
+    description: 'Optional quality of the build. The possible values are: daily, signed, validated, preview, ga.'
+  global-json-file:
+    description: 'Optional global.json location, if your global.json isn''t located in the root of the repo.'
   source-url:
     description: 'Optional package source for which to set up authentication. Will consult any existing NuGet.config in the root of the repo and provide a temporary NuGet.config using the NUGET_AUTH_TOKEN environment variable as a ClearTextPassword'
   owner:
     description: 'Optional OWNER for using packages from GitHub Package Registry organizations/users other than the current repository''s owner. Only used if a GPR URL is also provided in source-url'
   config-file:
     description: 'Optional NuGet.config location, if your NuGet.config isn''t located in the root of the repo.'
-  include-prerelease:
-    description: 'Whether prerelease versions should be matched with non-exact versions (for example 5.0.0-preview.6 being matched by 5, 5.0, 5.x or 5.0.x). Defaults to false if not provided.'
-    required: False
+outputs:
+  dotnet-version:
+    description: 'Contains the installed by action .NET SDK version for reuse.'
 runs:
-  using: 'node12'
+  using: 'node16'
   main: 'dist/index.js'

docs/adrs/v3-setup-dotnet.md

@@ -0,0 +1,57 @@
+# v3 setup-dotnet
+
+Date: 2022-08-25  
+Status: Accepted
+
+# Context
+- GitHub-hosted Ubuntu and Windows runners have .NET versions pre-installed in system directories
+  - Ubuntu:`/usr/share/dotnet`
+  - Windows:`C:\Program Files\dotnet`
+- V1 version of Action installs .NET to the user's directory
+  - Ubuntu:`/home/runner/.dotnet`
+  - Windows: `C:\Users\runneradmin\AppData\Local\Microsoft\dotnet`
+- It means that action always downloads and installs .NET version even if it is pre-installed. Also after using the action all pre-installed .NET versions are unavailable because `DOTNET_ROOT` is overridden to the user's directory.
+The behavior is different for macOS runners because the pre-installation directory matches the one that is used by action. It means action can use pre-installed versions if they exist, which speeds up the customer's workflow.
+
+- The different behavior of the setup task on Ubuntu, Windows and macOS runners is unclear and confusing for customers.
+
+- .NET supports installing and using multiple versions of .NET SDK and .NET runtime side-by-side. .NET CLI will use the latest installed .NET SDK and .NET runtime versions if there is no global.json file containing a different version. This behavior is defined by .NET design (https://docs.microsoft.com/en-us/dotnet/core/versions/selection).
+
+- The action contains logic to handle inputs with wildcards, for example `5.0.x`, `5.0.*`, `5.x` or `5.*`. This logic uses metadata from `https://dotnetcli.blob.core.windows.net/dotnet/release-metadata/releases-index.json` to retrieve the list of available releases and get the latest release version for the specified major and/or minor version from the input. After that, installer script (`dotnet-install.ps1` for Windows or `dotnet-install.sh` for Linux and macOS) installs the required SDK using exact version as a parameter.
+
+# Proposal
+
+- Change .NET installation path for Windows and Ubuntu images to match the location of pre-installed versions by using `-InstallDir` (Windows) and `--install-dir` (Ubuntu) properties for installer scripts:
+https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-install-script
+
+- Simplify and in some cases fully get rid of logic for resolving wildcard versions and start relying on [official installer scripts provided by .NET Core team](https://github.com/dotnet/install-scripts).  
+The execution `dotnet-install.ps1 -Channel 5.0` installs the latest patch version for 5.0 SDK. If SDK is in the prerelease phase, the latest prerelease version (preview or rc) will be installed.
+
+Inputs with wildcards in the patch tag (`5.0.x` or `5.0.*`) can be handled by passing major and minor versions to the installer script directly as a `channel` parameter. This parameter supports two-part version in `X.Y` format as input value ([see installer scripts documentation](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-install-script)).
+
+Inputs with wildcards in the minor tag (`3.x` or `3.*`) can be handled like that:
+1. The request is sent to MS dist and the `releases.json` file is got
+2. The action gets the latest possible channel version out of retrieved `releases.json` that satisfies input major tag (e.g. for `3.x` nowadays it's `3.1`) 
+3. Retrieved channel version is passed to installer script directly as `channel` parameter.
+
+> **Note:** Using the `channel` parameter of the MS .NET installer scripts will allow us to use the `quality` parameter as well. This functionality is also asked for by our customers.
+
+# Breaking changes
+- The presence of pre-installed .NET versions that are higher than the version that the users specify in the setup task can be breaking for some customers, who expect only one installed .NET version on the runner after using the setup task. If a user doesn't have .NET version specified in project file, the `dotnet` will use the latest installed version instead of provided in the setup task.  
+> **Note:** It is the biggest deal in this ADR.
+
+Previously, when a user would specify a .NET version, this exact version was used by the `dotnet` command by default (because it was installed in a separate folder and there were no other.NET versions in that folder)  
+In the proposal, the specified version will be installed on the machine but the latest version will be used by the `dotnet` command by default (because specified version will be installed alongside with pre-installed .NET versions).  
+Based on [official .NET documentation](https://docs.microsoft.com/en-us/dotnet/core/versions/selection), it is expected behavior and how it works on user's local machine with multiple installed .NET versions but some customer's workflows could be broken because they already rely on current behavior.
+
+To avoid breaking customers, we will need to release a new major task version (v3).
+
+# v3-preview
+There will be a v3-preview branch that will be created for development and testing. Any changes will first be merged into the v3-preview branch. After a period of testing & verification, the v3-preview branch will be merged into the main branch and a v3 tag will be created. Any GitHub public documentation and starter workflows that mention setup-dotnet will then be updated to use v3 instead of v2:
+- [README.md](https://github.com/actions/setup-dotnet/blob/main/README.md)
+- [action.yml](https://github.com/actions/setup-dotnet/blob/main/action.yml)
+- [GitHub docs](https://docs.github.com/en/actions/guides/building-and-testing-net#using-a-specific-net-version)
+- Starter-workflow yamls: [#1](https://github.com/actions/starter-workflows/blob/main/ci/dotnet.yml#L17), [#2](https://github.com/actions/starter-workflows/blob/main/ci/dotnet-desktop.yml#L72)
+
+# Consequences
+- Customers will be able to use pre-installed .NET versions with setup-dotnet action on Windows and Ubuntu

docs/contributors.md

@@ -1,34 +1,113 @@
 # Contributors
 
-Thank you for contributing! This action is targetted around setting up the dotnet cli and related sdks for GitHub actions. As part of that we use proxy settings (for self-hosted runners) and set-up nuget authentication for private feeds.
+Thank you for contributing!
 
-If you would like to contribute there are a few things to consider:
+We have prepared a short guide so that the process of making your contribution is as simple and clear as possible. Please check it out before you contribute!
 
-## Commands to use
+## How can I contribute...
 
-- npm run build - Compiles the action into a single js file at dist/index.js (Please check in the changes made by this command)
-- npm run test - Runs all tests under __tests__
-- npm run format - Runs formatting required to pass the lint test (Please check in the changes made by this command)
-- npm run update-installers - Updates the install-dotnet scripts in externals (Please check in the changes made by this command)
+* [Contribute Documentation:green_book:](#contribute-documentation)
 
-## To check in or not to check in
+* [Contribute Code :computer:](#contribute-code)
 
-- Do check in source (src)
-- Do check in index file (dist)
-- Do check in updates to install-dotnet scripts (externals)
-- Do not check in build output (lib)
-- Do not check in runtime (node_modules)
+* [Provide Support on Issues:pencil:](#provide-support-on-issues)
 
-## Writing tests
+* [Review Pull Requests:mag:](#review-pull-requests)
 
-With any contribution please take time to consider how this can be tested to maintain high quality. Current tests can be found in the folder __tests__ for examples.
+## Contribute documentation
 
-## Creating new version
+Documentation is a super important, critical part of this project. Docs are how we keep track of what we're doing, how, and why. It's how we stay on the same page about our policies and how we tell others everything they need to be able to use this project or contribute to it. 
 
-Details on versioning can be found here: https://github.com/actions/toolkit/blob/main/docs/action-versioning.md
-Create a new release using the UI. Version format should be `v1.x.x`. Creating a new major version requires reaction from users and should be done only with breaking changes.
-Once the new release is created, the v1 tag needs to be updated as well.
-```
-git tag -fa v1 -m "Update v1 tag"
-git push origin v1 --force
-```
+Documentation contributions of any size are welcome! Feel free to contribute even if you're just rewording a sentence to be more clear, or fixing a spelling mistake!
+
+**How to contribute:**
+
+Pull requests are the easiest way to contribute changes to git repos at GitHub. They are the preferred contribution method, as they offer a convenient way of commenting and amending the proposed changes.
+
+- Please check that no one else has already created a pull request with these or similar changes
+- Use a "feature branch" for your changes. That separates the changes in the pull request from your other changes and makes it easy to edit/amend commits in the pull request 
+- Make sure your changes are formatted properly and consistently with the rest of the documentation
+- Re-read what you wrote, and run a spellchecker on it to make sure you didn't miss anything
+- If your pull request is connected to an open issue, please, leave a link to this issue in the `Related issue:` section
+- If you later need to add new commits to the pull request, you can simply commit the changes to the local branch and then push them. The pull request gets automatically updated
+
+**Once you've filed the pull request:**
+
+- Maintainers will review your pull request
+- If a maintainer requests changes, first of all, try to think about this request critically and only after that implement and request another review
+- If your PR gets accepted, it will soon be merged into the main branch. But your contribution will take effect only after the release of a new version of the action and updating the major tag
+> Sometimes maintainers reject pull requests and that's ok! Usually, along with rejection, we supply the reason for it. Nonetheless, we still really appreciate you taking the time to do it, and we don't take that lightly :heart:
+
+## Contribute code
+
+We like code commits a lot! They're super handy, and they keep the project going and doing the work it needs to do to be useful to others.
+
+Code contributions of just about any size are acceptable!
+
+The main difference between code contributions and documentation contributions is that contributing code requires the inclusion of relevant tests for the code being added or changed. Contributions without accompanying tests will be held off until a test is added unless the maintainers consider the specific tests to be either impossible or way too much of a burden for such a contribution.
+
+**How to contribute:**
+
+Pull requests are the easiest way to contribute changes to git repos at GitHub. They are the preferred contribution method, as they offer a convenient way of commenting and amending the proposed changes.
+
+- Please check that no one else has already created a pull request with these or similar changes
+- Use a "feature branch" for your changes. That separates the changes in the pull request from your other changes and makes it easy to edit/amend commits in the pull request
+-  Format, build and test changes
+- Make sure your changes are well formatted and that all tests are passing
+- If your pull request is connected to an open issue, please, leave a link to this issue in the `Related issue:` section
+- If you later need to add new commits to the pull request, you can simply commit the changes to the local branch and then push them. The pull request gets automatically updated
+
+**Learn more about how to work with the repository:**
+
+- To implement new features or fix bugs, you need to make changes to the `.ts` files, which are located in the `src` folder
+- To comply with the code style, **you need to run the `format` script**
+- To transpile source code to `javascript` we use [NCC](https://github.com/vercel/ncc). **It is very important to run the `build` script after making changes**, otherwise your changes will not get into the final `javascript` build
+
+**Learn more about how to implement tests:**
+
+Adding or changing tests is an integral part of making a change to the code. 
+Unit tests are in the `__tests__` folder, and end-to-end tests are in the `workflows` folder, particularly in the [workflow.yml](https://github.com/actions/setup-dotnet/blob/main/.github/workflows/workflow.yml).
+
+- The contributor can add various types of tests (like unit tests or end-to-end tests), which, in his opinion, will be necessary and sufficient for testing new or changed functionality
+- Tests should cover a successful execution, as well as some edge cases and possible errors
+- As already mentioned, pull requests without tests will be considered more carefully by maintainers. If you are sure that in this situation the tests are not needed or cannot be implemented with a commensurate effort - please add this clarification message to your pull request
+
+**Once you've filed the pull request:**
+
+- CI will start automatically with some checks. Wait until the end of the execution and make sure that all checks passed successfully. If some checks fail, you can open them one by one, try to find the reason for failing and make changes to your code to resolve the problem
+> Sometimes you may need to update the installers you can do this with the `npm run update-installers` command
+- Maintainers will review your pull request
+- If a maintainer requests changes, first of all, try to think about his request critically and only after that implement and request another review
+- If your PR gets accepted, it will soon be merged into the main branch. But your contribution will take effect only after the release of a new version of the action and updating the major tag
+> Sometimes maintainers reject pull requests and that's ok! Usually, along with rejection, we supply the reason for it. Nonetheless, we still really appreciate you taking the time to do it, and we don't take that lightly :heart:
+
+## Provide support on issues
+
+Helping out other users with their questions is an awesome way of contributing to any community. It's not uncommon for most of the issues on open source projects to be support-related questions by users trying to understand something they ran into or find their way around a known bug.
+
+**To help other folks out with their questions:**
+
+- Go to the [issue tracker](https://github.com/actions/setup-dotnet/issues)
+- Read through the list until you find something that you're familiar enough with to answer to
+- Respond to the issue with whatever details are needed to clarify the question, or get more details about what's going on
+- Once the discussion wraps up and things are clarified, ask the original issue filer (or a maintainer) to close it for you
+ 
+*Some notes on picking up support issues:*
+
+- Avoid responding to issues you don't know you can answer accurately
+- Try to refer to past issues with accepted answers as much as possible. Link to them from your replies
+- Be kind and patient with users. Often, folks who have run into confusing things might be upset or impatient. This is natural. If you feel uncomfortable in conversation with them, it's better to stay away or withdraw from the issue.
+
+ > If some user is violating our code of conduct [standards](https://github.com/actions/setup-dotnet/blob/main/CODE_OF_CONDUCT.md#our-standards), refer to the [Enforcement](https://github.com/actions/setup-dotnet/blob/main/CODE_OF_CONDUCT.md#enforcement) section of the Code of Conduct to resolve the conflict
+ 
+## Review pull requests
+ 
+Another great way to contribute is to review pull request. Please, be extra kind: people who submit code/doc contributions are putting themselves in a pretty vulnerable position, and have put time and care into what they've done (even if that's not obvious to you!) Please, always respond with respect, and be understanding, but don't feel like you need to sacrifice your standards for their sake, either.
+ 
+**How to review:**
+
+- Go to the [pull requests](https://github.com/actions/setup-dotnet/pulls)
+- Make sure you're familiar with the code or documentation is updated, unless it's a minor change (spellchecking, minor formatting, etc.)
+- Review changes using the GitHub functionality. You can ask a clarifying question, point out an error or suggest an alternative. 
+> Note: You may ask for minor changes - "nitpicks", but consider whether they are real blockers to merging or not
+- Submit your review, which may include comments, an approval, or a changes request

externals/install-dotnet.sh

@@ -135,6 +135,31 @@ get_legacy_os_name_from_platform() {
     return 1
 }
 
+get_legacy_os_name() {
+    eval $invocation
+
+    local uname=$(uname)
+    if [ "$uname" = "Darwin" ]; then
+        echo "osx"
+        return 0
+    elif [ -n "$runtime_id" ]; then
+        echo $(get_legacy_os_name_from_platform "${runtime_id%-*}" || echo "${runtime_id%-*}")
+        return 0
+    else
+        if [ -e /etc/os-release ]; then
+            . /etc/os-release
+            os=$(get_legacy_os_name_from_platform "$ID${VERSION_ID:+.${VERSION_ID}}" || echo "")
+            if [ -n "$os" ]; then
+                echo "$os"
+                return 0
+            fi
+        fi
+    fi
+
+    say_verbose "Distribution specific OS name and version could not be detected: UName = $uname"
+    return 1
+}
+
 get_linux_platform_name() {
     eval $invocation
 
@@ -174,8 +199,8 @@ get_current_os_name() {
         echo "freebsd"
         return 0
     elif [ "$uname" = "Linux" ]; then
-        local linux_platform_name
-        linux_platform_name="$(get_linux_platform_name)" || { echo "linux" && return 0 ; }
+        local linux_platform_name=""
+        linux_platform_name="$(get_linux_platform_name)" || true
 
         if [ "$linux_platform_name" = "rhel.6" ]; then
             echo $linux_platform_name
@@ -196,39 +221,13 @@ get_current_os_name() {
     return 1
 }
 
-get_legacy_os_name() {
-    eval $invocation
-
-    local uname=$(uname)
-    if [ "$uname" = "Darwin" ]; then
-        echo "osx"
-        return 0
-    elif [ -n "$runtime_id" ]; then
-        echo $(get_legacy_os_name_from_platform "${runtime_id%-*}" || echo "${runtime_id%-*}")
-        return 0
-    else
-        if [ -e /etc/os-release ]; then
-            . /etc/os-release
-            os=$(get_legacy_os_name_from_platform "$ID${VERSION_ID:+.${VERSION_ID}}" || echo "")
-            if [ -n "$os" ]; then
-                echo "$os"
-                return 0
-            fi
-        fi
-    fi
-
-    say_verbose "Distribution specific OS name and version could not be detected: UName = $uname"
-    return 1
-}
-
 machine_has() {
     eval $invocation
 
-    hash "$1" > /dev/null 2>&1
+    command -v "$1" > /dev/null 2>&1
     return $?
 }
 
-
 check_min_reqs() {
     local hasMinimum=false
     if machine_has "curl"; then
@@ -307,6 +306,10 @@ get_machine_architecture() {
             echo "arm64"
             return 0
             ;;
+        s390x)
+            echo "s390x"
+            return 0
+            ;;
         esac
     fi
 
@@ -321,11 +324,13 @@ get_normalized_architecture_from_architecture() {
     eval $invocation
 
     local architecture="$(to_lowercase "$1")"
+
+    if [[ $architecture == \<auto\> ]]; then
+        echo "$(get_machine_architecture)"
+        return 0
+    fi
+
     case "$architecture" in
-        \<auto\>)
-            echo "$(get_normalized_architecture_from_architecture "$(get_machine_architecture)")"
-            return 0
-            ;;
         amd64|x64)
             echo "x64"
             return 0
@@ -338,12 +343,58 @@ get_normalized_architecture_from_architecture() {
             echo "arm64"
             return 0
             ;;
+        s390x)
+            echo "s390x"
+            return 0
+            ;;
     esac
 
     say_err "Architecture \`$architecture\` not supported. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues"
     return 1
 }
 
+# args:
+# version - $1
+# channel - $2
+# architecture - $3
+get_normalized_architecture_for_specific_sdk_version() {
+    eval $invocation
+
+    local is_version_support_arm64="$(is_arm64_supported "$1")"
+    local is_channel_support_arm64="$(is_arm64_supported "$2")"
+    local architecture="$3";
+    local osname="$(get_current_os_name)"
+
+    if [ "$osname" == "osx" ] && [ "$architecture" == "arm64" ] && { [ "$is_version_support_arm64" = false ] || [ "$is_channel_support_arm64" = false ]; }; then
+        #check if rosetta is installed
+        if [ "$(/usr/bin/pgrep oahd >/dev/null 2>&1;echo $?)" -eq 0 ]; then 
+            say_verbose "Changing user architecture from '$architecture' to 'x64' because .NET SDKs prior to version 6.0 do not support arm64." 
+            echo "x64"
+            return 0;
+        else
+            say_err "Architecture \`$architecture\` is not supported for .NET SDK version \`$version\`. Please install Rosetta to allow emulation of the \`$architecture\` .NET SDK on this platform"
+            return 1
+        fi
+    fi
+
+    echo "$architecture"
+    return 0
+}
+
+# args:
+# version or channel - $1
+is_arm64_supported() {
+    #any channel or version that starts with the specified versions
+    case "$1" in
+        ( "1"* | "2"* | "3"*  | "4"* | "5"*) 
+            echo false
+            return 0
+    esac
+
+    echo true
+    return 0
+}
+
 # args:
 # user_defined_os - $1
 get_normalized_os() {
@@ -425,6 +476,7 @@ get_normalized_channel() {
 get_normalized_product() {
     eval $invocation
 
+    local product=""
     local runtime="$(to_lowercase "$1")"
     if [[ "$runtime" == "dotnet" ]]; then
         product="dotnet-runtime"
@@ -446,7 +498,7 @@ get_normalized_product() {
 
 # args:
 # version_text - stdin
-get_version_from_version_info() {
+get_version_from_latestversion_file_content() {
     eval $invocation
 
     cat | tail -n 1 | sed 's/\r$//'
@@ -478,7 +530,7 @@ is_dotnet_package_installed() {
 # azure_feed - $1
 # channel - $2
 # normalized_architecture - $3
-get_latest_version_info() {
+get_version_from_latestversion_file() {
     eval $invocation
 
     local azure_feed="$1"
@@ -487,24 +539,24 @@ get_latest_version_info() {
 
     local version_file_url=null
     if [[ "$runtime" == "dotnet" ]]; then
-        version_file_url="$uncached_feed/Runtime/$channel/latest.version"
+        version_file_url="$azure_feed/Runtime/$channel/latest.version"
     elif [[ "$runtime" == "aspnetcore" ]]; then
-        version_file_url="$uncached_feed/aspnetcore/Runtime/$channel/latest.version"
+        version_file_url="$azure_feed/aspnetcore/Runtime/$channel/latest.version"
     elif [ -z "$runtime" ]; then
-         version_file_url="$uncached_feed/Sdk/$channel/latest.version"
+         version_file_url="$azure_feed/Sdk/$channel/latest.version"
     else
         say_err "Invalid value for \$runtime"
         return 1
     fi
-    say_verbose "get_latest_version_info: latest url: $version_file_url"
+    say_verbose "get_version_from_latestversion_file: latest url: $version_file_url"
 
-    download "$version_file_url"
-    return $?
+    download "$version_file_url" || return $?
+    return 0
 }
 
 # args:
 # json_file - $1
-parse_jsonfile_for_version() {
+parse_globaljson_file_for_version() {
     eval $invocation
 
     local json_file="$1"
@@ -513,7 +565,7 @@ parse_jsonfile_for_version() {
         return 1
     fi
 
-    sdk_section=$(cat $json_file | awk '/"sdk"/,/}/')
+    sdk_section=$(cat $json_file | tr -d "\r" | awk '/"sdk"/,/}/')
     if [ -z "$sdk_section" ]; then
         say_err "Unable to parse the SDK node in \`$json_file\`"
         return 1
@@ -560,9 +612,9 @@ get_specific_version_from_version() {
     if [ -z "$json_file" ]; then
         if [[ "$version" == "latest" ]]; then
             local version_info
-            version_info="$(get_latest_version_info "$azure_feed" "$channel" "$normalized_architecture" false)" || return 1
+            version_info="$(get_version_from_latestversion_file "$azure_feed" "$channel" "$normalized_architecture" false)" || return 1
             say_verbose "get_specific_version_from_version: version_info=$version_info"
-            echo "$version_info" | get_version_from_version_info
+            echo "$version_info" | get_version_from_latestversion_file_content
             return 0
         else
             echo "$version"
@@ -570,7 +622,7 @@ get_specific_version_from_version() {
         fi
     else
         local version_info
-        version_info="$(parse_jsonfile_for_version "$json_file")" || return 1
+        version_info="$(parse_globaljson_file_for_version "$json_file")" || return 1
         echo "$version_info"
         return 0
     fi
@@ -635,14 +687,16 @@ get_specific_product_version() {
 
         if machine_has "curl"
         then
-            specific_product_version=$(curl -s --fail "${download_link}${feed_credential}")
-            if [ $? = 0 ]; then
+            if ! specific_product_version=$(curl -s --fail "${download_link}${feed_credential}" 2>&1); then
+                continue
+            else
                 echo "${specific_product_version//[$'\t\r\n']}"
                 return 0
             fi
+
         elif machine_has "wget"
         then
-            specific_product_version=$(wget -qO- "${download_link}${feed_credential}")
+            specific_product_version=$(wget -qO- "${download_link}${feed_credential}" 2>&1)
             if [ $? = 0 ]; then
                 echo "${specific_product_version//[$'\t\r\n']}"
                 return 0
@@ -907,7 +961,7 @@ get_http_header_curl() {
     fi
 
     curl_options="-I -sSL --retry 5 --retry-delay 2 --connect-timeout 15 "
-    curl $curl_options "$remote_path_with_credential" || return 1
+    curl $curl_options "$remote_path_with_credential" 2>&1 || return 1
     return 0
 }
 
@@ -918,15 +972,25 @@ get_http_header_wget() {
     eval $invocation
     local remote_path="$1"
     local disable_feed_credential="$2"
+    local wget_options="-q -S --spider --tries 5 "
+
+    local wget_options_extra=''
+
+    # Test for options that aren't supported on all wget implementations.
+    if [[ $(wget -h 2>&1 | grep -E 'waitretry|connect-timeout') ]]; then
+        wget_options_extra="--waitretry 2 --connect-timeout 15 "
+    else
+        say "wget extra options are unavailable for this environment"
+    fi
 
     remote_path_with_credential="$remote_path"
     if [ "$disable_feed_credential" = false ]; then
         remote_path_with_credential+="$feed_credential"
     fi
 
-    wget_options="-q -S --spider --tries 5 --waitretry 2 --connect-timeout 15 "
-    wget $wget_options "$remote_path_with_credential" 2>&1 || return 1
-    return 0
+    wget $wget_options $wget_options_extra "$remote_path_with_credential" 2>&1
+
+    return $?
 }
 
 # args:
@@ -966,8 +1030,6 @@ download() {
         sleep $((attempts*10))
     done
 
-
-
     if [ "$failed" = true ]; then
         say_verbose "Download failed: $remote_path"
         return 1
@@ -986,19 +1048,27 @@ downloadcurl() {
     # Avoid passing URI with credentials to functions: note, most of them echoing parameters of invocation in verbose output.
     local remote_path_with_credential="${remote_path}${feed_credential}"
     local curl_options="--retry 20 --retry-delay 2 --connect-timeout 15 -sSL -f --create-dirs "
-    local failed=false
+    local curl_exit_code=0;
     if [ -z "$out_path" ]; then
-        curl $curl_options "$remote_path_with_credential" || failed=true
+        curl $curl_options "$remote_path_with_credential" 2>&1
+        curl_exit_code=$?
     else
-        curl $curl_options -o "$out_path" "$remote_path_with_credential" || failed=true
+        curl $curl_options -o "$out_path" "$remote_path_with_credential" 2>&1
+        curl_exit_code=$?
     fi
-    if [ "$failed" = true ]; then
-        local disable_feed_credential=false
-        local response=$(get_http_header_curl $remote_path $disable_feed_credential)
-        http_code=$( echo "$response" | awk '/^HTTP/{print $2}' | tail -1 )
+    
+    if [ $curl_exit_code -gt 0 ]; then
         download_error_msg="Unable to download $remote_path."
-        if  [[ $http_code != 2* ]]; then
-            download_error_msg+=" Returned HTTP status code: $http_code."
+        # Check for curl timeout codes
+        if [[ $curl_exit_code == 7 || $curl_exit_code == 28 ]]; then
+            download_error_msg+=" Failed to reach the server: connection timeout."
+        else
+            local disable_feed_credential=false
+            local response=$(get_http_header_curl $remote_path $disable_feed_credential)
+            http_code=$( echo "$response" | awk '/^HTTP/{print $2}' | tail -1 )
+            if  [[ ! -z $http_code && $http_code != 2* ]]; then
+                download_error_msg+=" Returned HTTP status code: $http_code."
+            fi
         fi
         say_verbose "$download_error_msg"
         return 1
@@ -1016,28 +1086,45 @@ downloadwget() {
     local out_path="${2:-}"
     # Append feed_credential as late as possible before calling wget to avoid logging feed_credential
     local remote_path_with_credential="${remote_path}${feed_credential}"
-    local wget_options="--tries 20 --waitretry 2 --connect-timeout 15 "
-    local failed=false
-    if [ -z "$out_path" ]; then
-        wget -q $wget_options -O - "$remote_path_with_credential" || failed=true
+    local wget_options="--tries 20 "
+
+    local wget_options_extra=''
+    local wget_result=''
+
+    # Test for options that aren't supported on all wget implementations.
+    if [[ $(wget -h 2>&1 | grep -E 'waitretry|connect-timeout') ]]; then
+        wget_options_extra="--waitretry 2 --connect-timeout 15 "
     else
-        wget $wget_options -O "$out_path" "$remote_path_with_credential" || failed=true
+        say "wget extra options are unavailable for this environment"
     fi
-    if [ "$failed" = true ]; then
+
+    if [ -z "$out_path" ]; then
+        wget -q $wget_options $wget_options_extra -O - "$remote_path_with_credential" 2>&1
+        wget_result=$?
+    else
+        wget $wget_options $wget_options_extra -O "$out_path" "$remote_path_with_credential" 2>&1
+        wget_result=$?
+    fi
+
+    if [[ $wget_result != 0 ]]; then
         local disable_feed_credential=false
         local response=$(get_http_header_wget $remote_path $disable_feed_credential)
         http_code=$( echo "$response" | awk '/^  HTTP/{print $2}' | tail -1 )
         download_error_msg="Unable to download $remote_path."
-        if  [[ $http_code != 2* ]]; then
+        if  [[ ! -z $http_code && $http_code != 2* ]]; then
             download_error_msg+=" Returned HTTP status code: $http_code."
+        # wget exit code 4 stands for network-issue
+        elif [[ $wget_result == 4 ]]; then
+            download_error_msg+=" Failed to reach the server: connection timeout."
         fi
         say_verbose "$download_error_msg"
         return 1
     fi
+
     return 0
 }
 
-get_download_link_from_aka_ms() {    
+get_download_link_from_aka_ms() {
     eval $invocation
 
     #quality is not supported for LTS or current channel
@@ -1090,11 +1177,202 @@ get_download_link_from_aka_ms() {
     fi
 }
 
+get_feeds_to_use()
+{
+    feeds=(
+    "https://dotnetcli.azureedge.net/dotnet"
+    "https://dotnetbuilds.azureedge.net/public"
+    )
+
+    if [[ -n "$azure_feed" ]]; then
+        feeds=("$azure_feed")
+    fi
+
+    if [[ "$no_cdn" == "true" ]]; then
+        feeds=(
+        "https://dotnetcli.blob.core.windows.net/dotnet"
+        "https://dotnetbuilds.blob.core.windows.net/public"
+        )
+
+        if [[ -n "$uncached_feed" ]]; then
+            feeds=("$uncached_feed")
+        fi
+    fi
+}
+
+# THIS FUNCTION MAY EXIT (if the determined version is already installed).
+generate_download_links() {
+
+    download_links=()
+    specific_versions=()
+    effective_versions=()
+    link_types=()
+
+    # If generate_akams_links returns false, no fallback to old links. Just terminate.
+    # This function may also 'exit' (if the determined version is already installed).
+    generate_akams_links || return
+
+    # Check other feeds only if we haven't been able to find an aka.ms link.
+    if [[ "${#download_links[@]}" -lt 1 ]]; then
+        for feed in ${feeds[@]}
+        do
+            # generate_regular_links may also 'exit' (if the determined version is already installed).
+            generate_regular_links $feed || return
+        done
+    fi
+
+    if [[ "${#download_links[@]}" -eq 0 ]]; then
+        say_err "Failed to resolve the exact version number."
+        return 1
+    fi
+
+    say_verbose "Generated ${#download_links[@]} links."
+    for link_index in ${!download_links[@]}
+    do
+        say_verbose "Link $link_index: ${link_types[$link_index]}, ${effective_versions[$link_index]}, ${download_links[$link_index]}"
+    done
+}
+
+# THIS FUNCTION MAY EXIT (if the determined version is already installed).
+generate_akams_links() {
+    local valid_aka_ms_link=true;
+
+    normalized_version="$(to_lowercase "$version")"
+    if [[ "$normalized_version" != "latest" ]] && [ -n "$normalized_quality" ]; then
+        say_err "Quality and Version options are not allowed to be specified simultaneously. See https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-install-script#options for details."
+        return 1
+    fi
+
+    if [[ -n "$json_file" || "$normalized_version" != "latest" ]]; then
+        # aka.ms links are not needed when exact version is specified via command or json file
+        return
+    fi
+
+    get_download_link_from_aka_ms || valid_aka_ms_link=false
+
+    if [[ "$valid_aka_ms_link" == true ]]; then
+        say_verbose "Retrieved primary payload URL from aka.ms link: '$aka_ms_download_link'."
+        say_verbose "Downloading using legacy url will not be attempted."
+
+        download_link=$aka_ms_download_link
+
+        #get version from the path
+        IFS='/'
+        read -ra pathElems <<< "$download_link"
+        count=${#pathElems[@]}
+        specific_version="${pathElems[count-2]}"
+        unset IFS;
+        say_verbose "Version: '$specific_version'."
+
+        #Retrieve effective version
+        effective_version="$(get_specific_product_version "$azure_feed" "$specific_version" "$download_link")"
+
+        # Add link info to arrays
+        download_links+=($download_link)
+        specific_versions+=($specific_version)
+        effective_versions+=($effective_version)
+        link_types+=("aka.ms")
+
+        #  Check if the SDK version is already installed.
+        if [[ "$dry_run" != true ]] && is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then
+            say "$asset_name with version '$effective_version' is already installed."
+            exit 0
+        fi
+
+        return 0
+    fi
+
+    # if quality is specified - exit with error - there is no fallback approach
+    if [ ! -z "$normalized_quality" ]; then
+        say_err "Failed to locate the latest version in the channel '$normalized_channel' with '$normalized_quality' quality for '$normalized_product', os: '$normalized_os', architecture: '$normalized_architecture'."
+        say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support."
+        return 1
+    fi
+    say_verbose "Falling back to latest.version file approach."
+}
+
+# THIS FUNCTION MAY EXIT (if the determined version is already installed)
+# args:
+# feed - $1
+generate_regular_links() {
+    local feed="$1"
+    local valid_legacy_download_link=true
+
+    specific_version=$(get_specific_version_from_version "$feed" "$channel" "$normalized_architecture" "$version" "$json_file") || specific_version='0'
+
+    if [[ "$specific_version" == '0' ]]; then
+        say_verbose "Failed to resolve the specific version number using feed '$feed'"
+        return
+    fi
+
+    effective_version="$(get_specific_product_version "$feed" "$specific_version")"
+    say_verbose "specific_version=$specific_version"
+
+    download_link="$(construct_download_link "$feed" "$channel" "$normalized_architecture" "$specific_version" "$normalized_os")"
+    say_verbose "Constructed primary named payload URL: $download_link"
+
+    # Add link info to arrays
+    download_links+=($download_link)
+    specific_versions+=($specific_version)
+    effective_versions+=($effective_version)
+    link_types+=("primary")
+
+    legacy_download_link="$(construct_legacy_download_link "$feed" "$channel" "$normalized_architecture" "$specific_version")" || valid_legacy_download_link=false
+
+    if [ "$valid_legacy_download_link" = true ]; then
+        say_verbose "Constructed legacy named payload URL: $legacy_download_link"
+    
+        download_links+=($legacy_download_link)
+        specific_versions+=($specific_version)
+        effective_versions+=($effective_version)
+        link_types+=("legacy")
+    else
+        legacy_download_link=""
+        say_verbose "Cound not construct a legacy_download_link; omitting..."
+    fi
+
+    #  Check if the SDK version is already installed.
+    if [[ "$dry_run" != true ]] && is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then
+        say "$asset_name with version '$effective_version' is already installed."
+        exit 0
+    fi
+}
+
+print_dry_run() {
+
+    say "Payload URLs:"
+
+    for link_index in "${!download_links[@]}"
+        do
+            say "URL #$link_index - ${link_types[$link_index]}: ${download_links[$link_index]}"
+    done
+
+    resolved_version=${specific_versions[0]}
+    repeatable_command="./$script_name --version "\""$resolved_version"\"" --install-dir "\""$install_root"\"" --architecture "\""$normalized_architecture"\"" --os "\""$normalized_os"\"""
+    
+    if [ ! -z "$normalized_quality" ]; then
+        repeatable_command+=" --quality "\""$normalized_quality"\"""
+    fi
+
+    if [[ "$runtime" == "dotnet" ]]; then
+        repeatable_command+=" --runtime "\""dotnet"\"""
+    elif [[ "$runtime" == "aspnetcore" ]]; then
+        repeatable_command+=" --runtime "\""aspnetcore"\"""
+    fi
+
+    repeatable_command+="$non_dynamic_parameters"
+
+    if [ -n "$feed_credential" ]; then
+        repeatable_command+=" --feed-credential "\""<feed_credential>"\"""
+    fi
+
+    say "Repeatable invocation: $repeatable_command"
+}
+
 calculate_vars() {
     eval $invocation
-    valid_legacy_download_link=true
 
-    #normalize input variables
+    script_name=$(basename "$0")
     normalized_architecture="$(get_normalized_architecture_from_architecture "$architecture")"
     say_verbose "Normalized architecture: '$normalized_architecture'."
     normalized_os="$(get_normalized_os "$user_defined_os")"
@@ -1105,76 +1383,10 @@ calculate_vars() {
     say_verbose "Normalized channel: '$normalized_channel'."
     normalized_product="$(get_normalized_product "$runtime")"
     say_verbose "Normalized product: '$normalized_product'."
-
-    #try to get download location from aka.ms link
-    #not applicable when exact version is specified via command or json file
-    normalized_version="$(to_lowercase "$version")"
-    if [[ -z "$json_file" && "$normalized_version" == "latest" ]]; then
-
-            valid_aka_ms_link=true;
-            get_download_link_from_aka_ms || valid_aka_ms_link=false
-            
-            if [ "$valid_aka_ms_link" == false ]; then
-                # if quality is specified - exit with error - there is no fallback approach
-                if [ ! -z "$normalized_quality" ]; then
-                    say_err "Failed to locate the latest version in the channel '$normalized_channel' with '$normalized_quality' quality for '$normalized_product', os: '$normalized_os', architecture: '$normalized_architecture'."
-                    say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support."
-                    return 1
-                fi
-                say_verbose "Falling back to latest.version file approach."
-            else
-                say_verbose "Retrieved primary payload URL from aka.ms link: '$aka_ms_download_link'."
-                download_link=$aka_ms_download_link
-
-                say_verbose "Downloading using legacy url will not be attempted."
-                valid_legacy_download_link=false
-
-                #get version from the path
-                IFS='/'
-                read -ra pathElems <<< "$download_link"
-                count=${#pathElems[@]}
-                specific_version="${pathElems[count-2]}"
-                unset IFS;
-                say_verbose "Version: '$specific_version'."
-
-                #Retrieve product specific version
-                specific_product_version="$(get_specific_product_version "$azure_feed" "$specific_version" "$download_link")"
-                say_verbose "Product specific version: '$specific_product_version'."
-  
-                install_root="$(resolve_installation_path "$install_dir")"
-                say_verbose "InstallRoot: '$install_root'."
-                return 
-            fi
-    fi
-
-    specific_version="$(get_specific_version_from_version "$azure_feed" "$channel" "$normalized_architecture" "$version" "$json_file")"
-    specific_product_version="$(get_specific_product_version "$azure_feed" "$specific_version")"
-    say_verbose "specific_version=$specific_version"
-    if [ -z "$specific_version" ]; then
-        say_err "Could not resolve version information."
-        return 1
-    fi
-
-    download_link="$(construct_download_link "$azure_feed" "$channel" "$normalized_architecture" "$specific_version" "$normalized_os")"
-    say_verbose "Constructed primary named payload URL: $download_link"
-
-    legacy_download_link="$(construct_legacy_download_link "$azure_feed" "$channel" "$normalized_architecture" "$specific_version")" || valid_legacy_download_link=false
-
-    if [ "$valid_legacy_download_link" = true ]; then
-        say_verbose "Constructed legacy named payload URL: $legacy_download_link"
-    else
-        say_verbose "Cound not construct a legacy_download_link; omitting..."
-    fi
-
     install_root="$(resolve_installation_path "$install_dir")"
-    say_verbose "InstallRoot: $install_root"
-}
+    say_verbose "InstallRoot: '$install_root'."
 
-install_dotnet() {
-    eval $invocation
-    local download_failed=false
-    local asset_name=''
-    local asset_relative_path=''
+    normalized_architecture="$(get_normalized_architecture_for_specific_sdk_version "$version" "$normalized_channel" "$normalized_architecture")"
 
     if [[ "$runtime" == "dotnet" ]]; then
         asset_relative_path="shared/Microsoft.NETCore.App"
@@ -1185,84 +1397,52 @@ install_dotnet() {
     elif [ -z "$runtime" ]; then
         asset_relative_path="sdk"
         asset_name=".NET Core SDK"
-    else
-        say_err "Invalid value for \$runtime"
-        return 1
     fi
 
-    #  Check if the SDK version is already installed.
-    if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$specific_version"; then
-        say "$asset_name version $specific_version is already installed."
-        return 0
-    fi
+    get_feeds_to_use
+}
+
+install_dotnet() {
+    eval $invocation
+    local download_failed=false
+    local download_completed=false
 
     mkdir -p "$install_root"
     zip_path="$(mktemp "$temporary_file_template")"
     say_verbose "Zip path: $zip_path"
 
+    for link_index in "${!download_links[@]}"
+    do
+        download_link="${download_links[$link_index]}"
+        specific_version="${specific_versions[$link_index]}"
+        effective_version="${effective_versions[$link_index]}"
+        link_type="${link_types[$link_index]}"
 
-    # Failures are normal in the non-legacy case for ultimately legacy downloads.
-    # Do not output to stderr, since output to stderr is considered an error.
-    say "Downloading primary link $download_link"
+        say "Attempting to download using $link_type link $download_link"
 
-    # The download function will set variables $http_code and $download_error_msg in case of failure.
-    download "$download_link" "$zip_path" 2>&1 || download_failed=true
+        # The download function will set variables $http_code and $download_error_msg in case of failure.
+        download_failed=false
+        download "$download_link" "$zip_path" 2>&1 || download_failed=true
 
-    #  if the download fails, download the legacy_download_link
-    if [ "$download_failed" = true ]; then
-        primary_path_http_code="$http_code"; primary_path_download_error_msg="$download_error_msg"
-        case $primary_path_http_code in
-        404)
-            say "The resource at $download_link is not available."
-            ;;
-        *)
-            say "$primary_path_download_error_msg"
-            ;;
-        esac
-        rm -f "$zip_path" 2>&1 && say_verbose "Temporary zip file $zip_path was removed"
-        if [ "$valid_legacy_download_link" = true ]; then
-            download_failed=false
-            download_link="$legacy_download_link"
-            zip_path="$(mktemp "$temporary_file_template")"
-            say_verbose "Legacy zip path: $zip_path"
-
-            say "Downloading legacy link $download_link"
-
-            # The download function will set variables $http_code and $download_error_msg in case of failure.
-            download "$download_link" "$zip_path" 2>&1 || download_failed=true
-
-            if [ "$download_failed" = true ]; then
-                legacy_path_http_code="$http_code";  legacy_path_download_error_msg="$download_error_msg"
-                case $legacy_path_http_code in
-                404)
-                    say "The resource at $download_link is not available."
-                    ;;
-                *)
-                    say "$legacy_path_download_error_msg"
-                    ;;
-                esac
-                rm -f "$zip_path" 2>&1 && say_verbose "Temporary zip file $zip_path was removed"
-            fi
-        fi
-    fi
-
-    if [ "$download_failed" = true ]; then
-        if [[ "$primary_path_http_code" = "404" && ( "$valid_legacy_download_link" = false || "$legacy_path_http_code" = "404") ]]; then
-            say_err "Could not find \`$asset_name\` with version = $specific_version"
-            say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support"
+        if [ "$download_failed" = true ]; then
+            case $http_code in
+            404)
+                say "The resource at $link_type link '$download_link' is not available."
+                ;;
+            *)
+                say "Failed to download $link_type link '$download_link': $download_error_msg"
+                ;;
+            esac
+            rm -f "$zip_path" 2>&1 && say_verbose "Temporary zip file $zip_path was removed"
         else
-            say_err "Could not download: \`$asset_name\` with version = $specific_version"
-            # 404-NotFound is an expected response if it goes from only one of the links, do not show that error.
-            # If primary path is available (not 404-NotFound) then show the primary error else show the legacy error.
-            if [ "$primary_path_http_code" != "404" ]; then
-                say_err "$primary_path_download_error_msg"
-                return 1
-            fi
-            if [[ "$valid_legacy_download_link" = true  && "$legacy_path_http_code" != "404" ]]; then
-                say_err "$legacy_path_download_error_msg"
-                return 1
-            fi
+            download_completed=true
+            break
         fi
+    done
+
+    if [[ "$download_completed" == false ]]; then
+        say_err "Could not find \`$asset_name\` with version = $specific_version"
+        say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support"
         return 1
     fi
 
@@ -1278,19 +1458,21 @@ install_dotnet() {
         unset IFS;
         say_verbose "Checking installation: version = $release_version"
         if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$release_version"; then
+            say "Installed version is $effective_version"
             return 0
         fi
     fi
 
     #  Check if the standard SDK version is installed.
-    say_verbose "Checking installation: version = $specific_product_version"
-    if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$specific_product_version"; then
+    say_verbose "Checking installation: version = $effective_version"
+    if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then
+        say "Installed version is $effective_version"
         return 0
     fi
 
     # Version verification failed. More likely something is wrong either with the downloaded content or with the verification algorithm.
     say_err "Failed to verify the version of installed \`$asset_name\`.\nInstallation source: $download_link.\nInstallation location: $install_root.\nReport the bug at https://github.com/dotnet/install-scripts/issues."
-    say_err "\`$asset_name\` with version = $specific_product_version failed to install with an unknown error."
+    say_err "\`$asset_name\` with version = $effective_version failed to install with an error."
     return 1
 }
 
@@ -1308,8 +1490,8 @@ architecture="<auto>"
 dry_run=false
 no_path=false
 no_cdn=false
-azure_feed="https://dotnetcli.azureedge.net/dotnet"
-uncached_feed="https://dotnetcli.blob.core.windows.net/dotnet"
+azure_feed=""
+uncached_feed=""
 feed_credential=""
 verbose=false
 runtime=""
@@ -1434,11 +1616,11 @@ do
             echo "          - 3-part version in a format A.B.Cxx - represents a specific SDK release"
             echo "              examples: 5.0.1xx, 5.0.2xx."
             echo "              Supported since 5.0 release"
-            echo "          Note: The version parameter overrides the channel parameter when any version other than `latest` is used."
+            echo "          Note: The version parameter overrides the channel parameter when any version other than 'latest' is used."
             echo "  -v,--version <VERSION>         Use specific VERSION, Defaults to \`$version\`."
             echo "      -Version"
             echo "          Possible values:"
-            echo "          - latest - most latest build on specific channel"
+            echo "          - latest - the latest build on specific channel"
             echo "          - 3-part version in a format A.B.C - represents specific version of build"
             echo "              examples: 2.0.0-preview2-006120; 1.1.0"
             echo "  -q,--quality <quality>         Download the latest build of specified quality in the channel."
@@ -1447,7 +1629,7 @@ do
             echo "          Works only in combination with channel. Not applicable for current and LTS channels and will be ignored if those channels are used." 
             echo "          For SDK use channel in A.B.Cxx format. Using quality for SDK together with channel in A.B format is not supported." 
             echo "          Supported since 5.0 release." 
-            echo "          Note: The version parameter overrides the channel parameter when any version other than `latest` is used, and therefore overrides the quality."
+            echo "          Note: The version parameter overrides the channel parameter when any version other than 'latest' is used, and therefore overrides the quality."
             echo "  --internal,-Internal               Download internal builds. Requires providing credentials via --feed-credential parameter."
             echo "  --feed-credential <FEEDCREDENTIAL> Token to access Azure feed. Used as a query string to append to the Azure feed."
             echo "      -FeedCredential                This parameter typically is not specified."
@@ -1455,7 +1637,7 @@ do
             echo "      -InstallDir"
             echo "  --architecture <ARCHITECTURE>      Architecture of dotnet binaries to be installed, Defaults to \`$architecture\`."
             echo "      --arch,-Architecture,-Arch"
-            echo "          Possible values: x64, arm, and arm64"
+            echo "          Possible values: x64, arm, arm64 and s390x"
             echo "  --os <system>                    Specifies operating system to be used when selecting the installer."
             echo "          Overrides the OS determination approach used by the script. Supported values: osx, linux, linux-musl, freebsd, rhel.6."
             echo "          In case any other value is provided, the platform will be determined by the script based on machine configuration."
@@ -1469,8 +1651,12 @@ do
             echo "  --dry-run,-DryRun                  Do not perform installation. Display download link."
             echo "  --no-path, -NoPath                 Do not set PATH for the current process."
             echo "  --verbose,-Verbose                 Display diagnostics information."
-            echo "  --azure-feed,-AzureFeed            Azure feed location. Defaults to $azure_feed, This parameter typically is not changed by the user."
-            echo "  --uncached-feed,-UncachedFeed      Uncached feed location. This parameter typically is not changed by the user."
+            echo "  --azure-feed,-AzureFeed            For internal use only."
+            echo "                                     Allows using a different storage to download SDK archives from."
+            echo "                                     This parameter is only used if --no-cdn is false."
+            echo "  --uncached-feed,-UncachedFeed      For internal use only."
+            echo "                                     Allows using a different storage to download SDK archives from."
+            echo "                                     This parameter is only used if --no-cdn is true."
             echo "  --skip-non-versioned-files         Skips non-versioned files if they already exist, such as the dotnet executable."
             echo "      -SkipNonVersionedFiles"
             echo "  --no-cdn,-NoCdn                    Disable downloading from the Azure CDN, and use the uncached feed directly."
@@ -1478,14 +1664,6 @@ do
             echo "                                     Note: global.json must have a value for 'SDK:Version'"
             echo "  -?,--?,-h,--help,-Help             Shows this help message"
             echo ""
-            echo "Obsolete parameters:"
-            echo "  --shared-runtime                   The recommended alternative is '--runtime dotnet'."
-            echo "                                     This parameter is obsolete and may be removed in a future version of this script."
-            echo "                                     Installs just the shared runtime bits, not the entire SDK."
-            echo "  --runtime-id                       Installs the .NET Tools for the given platform (use linux-x64 for portable linux)."
-            echo "      -RuntimeId"                    The parameter is obsolete and may be removed in a future version of this script. Should be used only for versions below 2.1.
-            echo "                                     For primary links to override OS or/and architecture, use --os and --architecture option instead."
-            echo ""
             echo "Install Location:"
             echo "  Location is chosen in following order:"
             echo "    - --install-dir option"
@@ -1502,10 +1680,6 @@ do
     shift
 done
 
-if [ "$no_cdn" = true ]; then
-    azure_feed="$uncached_feed"
-fi
-
 say "Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:"
 say "- The SDK needs to be installed without user interaction and without admin rights."
 say "- The SDK installation doesn't need to persist across multiple CI runs."
@@ -1523,33 +1697,11 @@ fi
 
 check_min_reqs
 calculate_vars
-script_name=$(basename "$0")
+# generate_regular_links call below will 'exit' if the determined version is already installed.
+generate_download_links
 
-if [ "$dry_run" = true ]; then
-    say "Payload URLs:"
-    say "Primary named payload URL: ${download_link}"
-    if [ "$valid_legacy_download_link" = true ]; then
-        say "Legacy named payload URL: ${legacy_download_link}"
-    fi
-    repeatable_command="./$script_name --version "\""$specific_version"\"" --install-dir "\""$install_root"\"" --architecture "\""$normalized_architecture"\"" --os "\""$normalized_os"\"""
-    
-    if [ ! -z "$normalized_quality" ]; then
-        repeatable_command+=" --quality "\""$normalized_quality"\"""
-    fi
-
-    if [[ "$runtime" == "dotnet" ]]; then
-        repeatable_command+=" --runtime "\""dotnet"\"""
-    elif [[ "$runtime" == "aspnetcore" ]]; then
-        repeatable_command+=" --runtime "\""aspnetcore"\"""
-    fi
-
-    repeatable_command+="$non_dynamic_parameters"
-
-    if [ -n "$feed_credential" ]; then
-        repeatable_command+=" --feed-credential "\""<feed_credential>"\"""
-    fi
-
-    say "Repeatable invocation: $repeatable_command"
+if [[ "$dry_run" = true ]]; then
+    print_dry_run
     exit 0
 fi
 
@@ -1565,4 +1717,4 @@ fi
 
 say "Note that the script does not resolve dependencies during installation."
 say "To check the list of dependencies, go to https://docs.microsoft.com/dotnet/core/install, select your operating system and check the \"Dependencies\" section."
-say "Installation finished successfully."
+say "Installation finished successfully."

package.json

@@ -1,6 +1,6 @@
 {
   "name": "setup-dotnet",
-  "version": "1.0.0",
+  "version": "3.0.0",
   "private": true,
   "description": "setup dotnet action",
   "main": "lib/setup-dotnet.js",
@@ -8,16 +8,10 @@
     "build": "tsc && ncc build",
     "format": "prettier --write **/*.ts",
     "format-check": "prettier --check **/*.ts",
-    "test": "jest",
+    "prepare": "husky install",
+    "test": "jest --coverage --config ./jest.config.js",
     "update-installers": "nwget https://dot.net/v1/dotnet-install.ps1 -O externals/install-dotnet.ps1 && nwget https://dot.net/v1/dotnet-install.sh -O externals/install-dotnet.sh"
   },
-  "husky": {
-    "hooks": {
-      "//": "Tests are not run at push time since they can take 2-4 minutes to complete",
-      "pre-commit": "npm run format",
-      "pre-push": "npm run format-check"
-    }
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/actions/setup-dotnet.git"
@@ -30,25 +24,25 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.2.6",
+    "@actions/core": "^1.9.1",
     "@actions/exec": "^1.0.4",
     "@actions/github": "^1.1.0",
-    "@actions/http-client": "^1.0.8",
+    "@actions/http-client": "^2.0.1",
     "@actions/io": "^1.0.2",
     "fast-xml-parser": "^3.15.1",
     "semver": "^6.3.0",
     "xmlbuilder": "^13.0.2"
   },
   "devDependencies": {
-    "@types/jest": "^25.2.3",
-    "@types/node": "^12.12.62",
+    "@types/jest": "^27.0.2",
+    "@types/node": "^16.11.25",
     "@types/semver": "^6.2.2",
-    "@zeit/ncc": "^0.21.1",
-    "husky": "^4.3.0",
-    "jest": "^26.4.2",
-    "jest-circus": "^26.4.2",
+    "@vercel/ncc": "^0.33.4",
+    "husky": "^8.0.1",
+    "jest": "^27.2.5",
+    "jest-circus": "^27.2.5",
     "prettier": "^1.19.1",
-    "ts-jest": "^26.4.0",
+    "ts-jest": "^27.0.5",
     "typescript": "^3.9.7",
     "wget-improved": "^3.2.1"
   },

src/authutil.ts

@@ -4,7 +4,6 @@ import * as core from '@actions/core';
 import * as github from '@actions/github';
 import * as xmlbuilder from 'xmlbuilder';
 import * as xmlParser from 'fast-xml-parser';
-import {ProcessEnvOptions} from 'child_process';
 
 export function configAuthentication(
   feedUrl: string,
@@ -47,7 +46,7 @@ function writeFeedToFile(
   existingFileLocation: string,
   tempFileLocation: string
 ) {
-  console.log(
+  core.info(
     `dotnet-auth: Finding any source references in ${existingFileLocation}, writing a new temporary configuration file with credentials to ${tempFileLocation}`
   );
   let xml: xmlbuilder.XMLElement;
@@ -58,7 +57,7 @@ function writeFeedToFile(
     owner = github.context.repo.owner;
   }
 
-  if (!process.env.NUGET_AUTH_TOKEN || process.env.NUGET_AUTH_TOKEN == '') {
+  if (!process.env.NUGET_AUTH_TOKEN) {
     throw new Error(
       'The NUGET_AUTH_TOKEN environment variable was not provided. In this step, add the following: \r\nenv:\r\n  NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}'
     );
@@ -67,22 +66,22 @@ function writeFeedToFile(
   if (fs.existsSync(existingFileLocation)) {
     // get key from existing NuGet.config so NuGet/dotnet can match credentials
     const curContents: string = fs.readFileSync(existingFileLocation, 'utf8');
-    var json = xmlParser.parse(curContents, {ignoreAttributes: false});
+    const json = xmlParser.parse(curContents, {ignoreAttributes: false});
 
-    if (typeof json.configuration == 'undefined') {
+    if (typeof json.configuration === 'undefined') {
       throw new Error(`The provided NuGet.config seems invalid.`);
     }
     if (typeof json.configuration.packageSources != 'undefined') {
       if (typeof json.configuration.packageSources.add != 'undefined') {
         // file has at least one <add>
-        if (typeof json.configuration.packageSources.add[0] == 'undefined') {
+        if (typeof json.configuration.packageSources.add[0] === 'undefined') {
           // file has only one <add>
           if (
             json.configuration.packageSources.add['@_value']
               .toLowerCase()
               .includes(feedUrl.toLowerCase())
           ) {
-            let key = json.configuration.packageSources.add['@_key'];
+            const key = json.configuration.packageSources.add['@_key'];
             sourceKeys.push(key);
             core.debug(`Found a URL with key ${key}`);
           }
@@ -97,7 +96,7 @@ function writeFeedToFile(
             const value = source['@_value'];
             core.debug(`source '${value}'`);
             if (value.toLowerCase().includes(feedUrl.toLowerCase())) {
-              let key = source['@_key'];
+              const key = source['@_key'];
               sourceKeys.push(key);
               core.debug(`Found a URL with key ${key}`);
             }
@@ -114,7 +113,7 @@ function writeFeedToFile(
     .up()
     .up();
 
-  if (sourceKeys.length == 0) {
+  if (!sourceKeys.length) {
     let keystring = 'Source';
     xml = xml
       .ele('packageSources')
@@ -150,6 +149,6 @@ function writeFeedToFile(
   //             ? '%NUGET_AUTH_TOKEN%'
   //             : '$NUGET_AUTH_TOKEN'
 
-  var output = xml.end({pretty: true});
+  const output = xml.end({pretty: true});
   fs.writeFileSync(tempFileLocation, output);
 }

src/installer.ts

@@ -2,293 +2,274 @@
 import * as core from '@actions/core';
 import * as exec from '@actions/exec';
 import * as io from '@actions/io';
-import hc = require('@actions/http-client');
+import * as hc from '@actions/http-client';
 import {chmodSync} from 'fs';
-import * as path from 'path';
-import {ExecOptions} from '@actions/exec/lib/interfaces';
-import * as semver from 'semver';
+import {readdir} from 'fs/promises';
+import path from 'path';
+import semver from 'semver';
+import {IS_LINUX, IS_WINDOWS, IS_MAC} from './utils';
+import {QualityOptions} from './setup-dotnet';
 
-const IS_WINDOWS = process.platform === 'win32';
+export interface DotnetVersion {
+  type: string;
+  value: string;
+  qualityFlag: boolean;
+}
 
-/**
- * Represents the inputted version information
- */
-export class DotNetVersionInfo {
-  public inputVersion: string;
-  private fullversion: string;
-  private isExactVersionSet: boolean = false;
+export class DotnetVersionResolver {
+  private inputVersion: string;
+  private resolvedArgument: DotnetVersion;
 
   constructor(version: string) {
-    this.inputVersion = version;
-
-    // Check for exact match
-    if (semver.valid(semver.clean(version) || '') != null) {
-      this.fullversion = semver.clean(version) as string;
-      this.isExactVersionSet = true;
-
-      return;
-    }
-
-    const parts: string[] = version.split('.');
-
-    if (parts.length < 2 || parts.length > 3) this.throwInvalidVersionFormat();
-
-    if (parts.length == 3 && parts[2] !== 'x' && parts[2] !== '*') {
-      this.throwInvalidVersionFormat();
-    }
-
-    const major = this.getVersionNumberOrThrow(parts[0]);
-    const minor = ['x', '*'].includes(parts[1])
-      ? parts[1]
-      : this.getVersionNumberOrThrow(parts[1]);
-
-    this.fullversion = major + '.' + minor;
+    this.inputVersion = version.trim();
+    this.resolvedArgument = {type: '', value: '', qualityFlag: false};
   }
 
-  private getVersionNumberOrThrow(input: string): number {
-    try {
-      if (!input || input.trim() === '') this.throwInvalidVersionFormat();
+  private async resolveVersionInput(): Promise<void> {
+    if (!semver.validRange(this.inputVersion)) {
+      throw new Error(
+        `'dotnet-version' was supplied in invalid format: ${this.inputVersion}! Supported syntax: A.B.C, A.B, A.B.x, A, A.x`
+      );
+    }
+    if (semver.valid(this.inputVersion)) {
+      this.resolvedArgument.type = 'version';
+      this.resolvedArgument.value = this.inputVersion;
+    } else {
+      const [major, minor] = this.inputVersion.split('.');
 
-      let number = Number(input);
-
-      if (Number.isNaN(number) || number < 0) this.throwInvalidVersionFormat();
-
-      return number;
-    } catch {
-      this.throwInvalidVersionFormat();
-      return -1;
+      if (this.isNumericTag(major)) {
+        this.resolvedArgument.type = 'channel';
+        if (this.isNumericTag(minor)) {
+          this.resolvedArgument.value = `${major}.${minor}`;
+        } else {
+          const httpClient = new hc.HttpClient('actions/setup-dotnet', [], {
+            allowRetries: true,
+            maxRetries: 3
+          });
+          this.resolvedArgument.value = await this.getLatestVersion(
+            httpClient,
+            [major, minor]
+          );
+        }
+      }
+      this.resolvedArgument.qualityFlag = +major >= 6 ? true : false;
     }
   }
 
-  private throwInvalidVersionFormat() {
-    throw new Error(
-      'Invalid version format! Supported: 1.2.3, 1.2, 1.2.x, 1.2.*'
+  private isNumericTag(versionTag): boolean {
+    return /^\d+$/.test(versionTag);
+  }
+
+  public async createDotNetVersion(): Promise<{
+    type: string;
+    value: string;
+    qualityFlag: boolean;
+  }> {
+    await this.resolveVersionInput();
+    if (!this.resolvedArgument.type) {
+      return this.resolvedArgument;
+    }
+    if (IS_WINDOWS) {
+      this.resolvedArgument.type =
+        this.resolvedArgument.type === 'channel' ? '-Channel' : '-Version';
+    } else {
+      this.resolvedArgument.type =
+        this.resolvedArgument.type === 'channel' ? '--channel' : '--version';
+    }
+    return this.resolvedArgument;
+  }
+
+  private async getLatestVersion(
+    httpClient: hc.HttpClient,
+    versionParts: string[]
+  ): Promise<string> {
+    const response = await httpClient.getJson<any>(
+      DotnetVersionResolver.DotNetCoreIndexUrl
     );
+    const result = response.result || {};
+    let releasesInfo: any[] = result['releases-index'];
+
+    let releaseInfo = releasesInfo.find(info => {
+      let sdkParts: string[] = info['channel-version'].split('.');
+      return sdkParts[0] === versionParts[0];
+    });
+
+    if (!releaseInfo) {
+      throw new Error(
+        `Could not find info for version ${versionParts.join('.')} at ${
+          DotnetVersionResolver.DotNetCoreIndexUrl
+        }`
+      );
+    }
+
+    return releaseInfo['channel-version'];
   }
 
-  /**
-   * If true exacatly one version should be resolved
-   */
-  public isExactVersion(): boolean {
-    return this.isExactVersionSet;
-  }
-
-  public version(): string {
-    return this.fullversion;
-  }
+  static DotNetCoreIndexUrl: string =
+    'https://dotnetcli.blob.core.windows.net/dotnet/release-metadata/releases-index.json';
 }
 
 export class DotnetCoreInstaller {
-  constructor(version: string, includePrerelease: boolean = false) {
-    this.version = version;
-    this.includePrerelease = includePrerelease;
-  }
-
-  public async installDotnet() {
-    let output = '';
-    let resultCode = 0;
-
-    let calculatedVersion = await this.resolveVersion(
-      new DotNetVersionInfo(this.version)
-    );
-
-    var envVariables: {[key: string]: string} = {};
-    for (let key in process.env) {
-      if (process.env[key]) {
-        let value: any = process.env[key];
-        envVariables[key] = value;
-      }
-    }
-    if (IS_WINDOWS) {
-      let escapedScript = path
-        .join(__dirname, '..', 'externals', 'install-dotnet.ps1')
-        .replace(/'/g, "''");
-      let command = `& '${escapedScript}'`;
-      if (calculatedVersion) {
-        command += ` -Version ${calculatedVersion}`;
-      }
-      if (process.env['https_proxy'] != null) {
-        command += ` -ProxyAddress ${process.env['https_proxy']}`;
-      }
-      // This is not currently an option
-      if (process.env['no_proxy'] != null) {
-        command += ` -ProxyBypassList ${process.env['no_proxy']}`;
-      }
-
-      // process.env must be explicitly passed in for DOTNET_INSTALL_DIR to be used
-      const powershellPath = await io.which('powershell', true);
-
-      var options: ExecOptions = {
-        listeners: {
-          stdout: (data: Buffer) => {
-            output += data.toString();
-          }
-        },
-        env: envVariables
-      };
-
-      resultCode = await exec.exec(
-        `"${powershellPath}"`,
-        [
-          '-NoLogo',
-          '-Sta',
-          '-NoProfile',
-          '-NonInteractive',
-          '-ExecutionPolicy',
-          'Unrestricted',
-          '-Command',
-          command
-        ],
-        options
-      );
-    } else {
-      let escapedScript = path
-        .join(__dirname, '..', 'externals', 'install-dotnet.sh')
-        .replace(/'/g, "''");
-      chmodSync(escapedScript, '777');
-
-      const scriptPath = await io.which(escapedScript, true);
-
-      let scriptArguments: string[] = [];
-      if (calculatedVersion) {
-        scriptArguments.push('--version', calculatedVersion);
-      }
-
-      // process.env must be explicitly passed in for DOTNET_INSTALL_DIR to be used
-      resultCode = await exec.exec(`"${scriptPath}"`, scriptArguments, {
-        listeners: {
-          stdout: (data: Buffer) => {
-            output += data.toString();
-          }
-        },
-        env: envVariables
-      });
-    }
+  private version: string;
+  private quality: QualityOptions;
+  private static readonly installationDirectoryWindows = path.join(
+    process.env['PROGRAMFILES'] + '',
+    'dotnet'
+  );
+  private static readonly installationDirectoryLinux = '/usr/share/dotnet';
+  private static readonly installationDirectoryMac = path.join(
+    process.env['HOME'] + '',
+    '.dotnet'
+  );
 
+  static addToPath() {
     if (process.env['DOTNET_INSTALL_DIR']) {
       core.addPath(process.env['DOTNET_INSTALL_DIR']);
       core.exportVariable('DOTNET_ROOT', process.env['DOTNET_INSTALL_DIR']);
     } else {
       if (IS_WINDOWS) {
-        // This is the default set in install-dotnet.ps1
-        core.addPath(
-          path.join(process.env['LocalAppData'] + '', 'Microsoft', 'dotnet')
-        );
+        core.addPath(DotnetCoreInstaller.installationDirectoryWindows);
         core.exportVariable(
           'DOTNET_ROOT',
-          path.join(process.env['LocalAppData'] + '', 'Microsoft', 'dotnet')
+          DotnetCoreInstaller.installationDirectoryWindows
+        );
+      } else if (IS_LINUX) {
+        core.addPath(DotnetCoreInstaller.installationDirectoryLinux);
+        core.exportVariable(
+          'DOTNET_ROOT',
+          DotnetCoreInstaller.installationDirectoryLinux
         );
       } else {
         // This is the default set in install-dotnet.sh
-        core.addPath(path.join(process.env['HOME'] + '', '.dotnet'));
+        core.addPath(DotnetCoreInstaller.installationDirectoryMac);
         core.exportVariable(
           'DOTNET_ROOT',
-          path.join(process.env['HOME'] + '', '.dotnet')
+          DotnetCoreInstaller.installationDirectoryMac
         );
       }
     }
+  }
 
-    console.log(process.env['PATH']);
+  constructor(version: string, quality: QualityOptions) {
+    this.version = version;
+    this.quality = quality;
+  }
 
-    if (resultCode != 0) {
-      throw new Error(`Failed to install dotnet ${resultCode}. ${output}`);
+  private setQuality(
+    dotnetVersion: DotnetVersion,
+    scriptArguments: string[]
+  ): void {
+    const option = IS_WINDOWS ? '-Quality' : '--quality';
+    if (dotnetVersion.qualityFlag) {
+      scriptArguments.push(option, this.quality);
+    } else {
+      core.warning(
+        `'dotnet-quality' input can be used only with .NET SDK version in A.B, A.B.x, A and A.x formats where the major tag is higher than 5. You specified: ${this.version}. 'dotnet-quality' input is ignored.`
+      );
     }
   }
 
-  // versionInfo - versionInfo of the SDK/Runtime
-  async resolveVersion(versionInfo: DotNetVersionInfo): Promise<string> {
-    if (versionInfo.isExactVersion()) {
-      return versionInfo.version();
-    }
+  public async installDotnet(): Promise<string> {
+    const windowsDefaultOptions = [
+      '-NoLogo',
+      '-Sta',
+      '-NoProfile',
+      '-NonInteractive',
+      '-ExecutionPolicy',
+      'Unrestricted',
+      '-Command'
+    ];
+    const scriptName = IS_WINDOWS ? 'install-dotnet.ps1' : 'install-dotnet.sh';
+    const escapedScript = path
+      .join(__dirname, '..', 'externals', scriptName)
+      .replace(/'/g, "''");
+    let scriptArguments: string[];
+    let scriptPath = '';
 
-    const httpClient = new hc.HttpClient('actions/setup-dotnet', [], {
-      allowRetries: true,
-      maxRetries: 3
-    });
+    const versionResolver = new DotnetVersionResolver(this.version);
+    const dotnetVersion = await versionResolver.createDotNetVersion();
 
-    const releasesJsonUrl: string = await this.getReleasesJsonUrl(
-      httpClient,
-      versionInfo.version().split('.')
-    );
+    if (IS_WINDOWS) {
+      scriptArguments = ['&', `'${escapedScript}'`];
 
-    const releasesResponse = await httpClient.getJson<any>(releasesJsonUrl);
-    const releasesResult = releasesResponse.result || {};
-    let releasesInfo: any[] = releasesResult['releases'];
-    releasesInfo = releasesInfo.filter((releaseInfo: any) => {
-      return (
-        semver.satisfies(releaseInfo['sdk']['version'], versionInfo.version(), {
-          includePrerelease: this.includePrerelease
-        }) ||
-        semver.satisfies(
-          releaseInfo['sdk']['version-display'],
-          versionInfo.version(),
-          {
-            includePrerelease: this.includePrerelease
-          }
-        )
-      );
-    });
-
-    // Exclude versions that are newer than the latest if using not exact
-    let latestSdk: string = releasesResult['latest-sdk'];
-
-    releasesInfo = releasesInfo.filter((releaseInfo: any) =>
-      semver.lte(releaseInfo['sdk']['version'], latestSdk, {
-        includePrerelease: this.includePrerelease
-      })
-    );
-
-    // Sort for latest version
-    releasesInfo = releasesInfo.sort((a, b) =>
-      semver.rcompare(a['sdk']['version'], b['sdk']['version'], {
-        includePrerelease: this.includePrerelease
-      })
-    );
-
-    if (releasesInfo.length == 0) {
-      throw new Error(
-        `Could not find dotnet core version. Please ensure that specified version ${versionInfo.inputVersion} is valid.`
-      );
-    }
-
-    let release = releasesInfo[0];
-    return release['sdk']['version'];
-  }
-
-  private async getReleasesJsonUrl(
-    httpClient: hc.HttpClient,
-    versionParts: string[]
-  ): Promise<string> {
-    const response = await httpClient.getJson<any>(DotNetCoreIndexUrl);
-    const result = response.result || {};
-    let releasesInfo: any[] = result['releases-index'];
-
-    releasesInfo = releasesInfo.filter((info: any) => {
-      // channel-version is the first 2 elements of the version (e.g. 2.1), filter out versions that don't match 2.1.x.
-      const sdkParts: string[] = info['channel-version'].split('.');
-      if (
-        versionParts.length >= 2 &&
-        !(versionParts[1] == 'x' || versionParts[1] == '*')
-      ) {
-        return versionParts[0] == sdkParts[0] && versionParts[1] == sdkParts[1];
+      if (dotnetVersion.type) {
+        scriptArguments.push(dotnetVersion.type, dotnetVersion.value);
       }
-      return versionParts[0] == sdkParts[0];
-    });
 
-    if (releasesInfo.length === 0) {
-      throw new Error(
-        `Could not find info for version ${versionParts.join(
-          '.'
-        )} at ${DotNetCoreIndexUrl}`
+      if (this.quality) {
+        this.setQuality(dotnetVersion, scriptArguments);
+      }
+
+      if (process.env['https_proxy'] != null) {
+        scriptArguments.push(`-ProxyAddress ${process.env['https_proxy']}`);
+      }
+      // This is not currently an option
+      if (process.env['no_proxy'] != null) {
+        scriptArguments.push(`-ProxyBypassList ${process.env['no_proxy']}`);
+      }
+
+      scriptArguments.push(
+        '-InstallDir',
+        `'${DotnetCoreInstaller.installationDirectoryWindows}'`
       );
+      // process.env must be explicitly passed in for DOTNET_INSTALL_DIR to be used
+      scriptPath =
+        (await io.which('pwsh', false)) || (await io.which('powershell', true));
+      scriptArguments = windowsDefaultOptions.concat(scriptArguments);
+    } else {
+      chmodSync(escapedScript, '777');
+      scriptPath = await io.which(escapedScript, true);
+      scriptArguments = [];
+
+      if (dotnetVersion.type) {
+        scriptArguments.push(dotnetVersion.type, dotnetVersion.value);
+      }
+
+      if (this.quality) {
+        this.setQuality(dotnetVersion, scriptArguments);
+      }
+
+      if (IS_LINUX) {
+        scriptArguments.push(
+          '--install-dir',
+          DotnetCoreInstaller.installationDirectoryLinux
+        );
+      }
+
+      if (IS_MAC) {
+        scriptArguments.push(
+          '--install-dir',
+          DotnetCoreInstaller.installationDirectoryMac
+        );
+      }
+    }
+    const {exitCode, stdout} = await exec.getExecOutput(
+      `"${scriptPath}"`,
+      scriptArguments,
+      {ignoreReturnCode: true}
+    );
+    if (exitCode) {
+      throw new Error(`Failed to install dotnet ${exitCode}. ${stdout}`);
     }
 
-    return releasesInfo[0]['releases.json'];
+    return this.outputDotnetVersion(
+      dotnetVersion.value,
+      scriptArguments[scriptArguments.length - 1]
+    );
   }
 
-  private version: string;
-  private includePrerelease: boolean;
-}
+  private async outputDotnetVersion(
+    version,
+    installationPath
+  ): Promise<string> {
+    let versionsOnRunner: string[] = await readdir(
+      path.join(installationPath.replace(/'/g, ''), 'sdk')
+    );
 
-const DotNetCoreIndexUrl: string =
-  'https://dotnetcli.blob.core.windows.net/dotnet/release-metadata/releases-index.json';
+    let installedVersion = semver.maxSatisfying(versionsOnRunner, version, {
+      includePrerelease: true
+    })!;
+
+    return installedVersion;
+  }
+}

src/setup-dotnet.ts

@@ -1,38 +1,71 @@
 import * as core from '@actions/core';
-import * as installer from './installer';
+import {DotnetCoreInstaller} from './installer';
 import * as fs from 'fs';
-import * as path from 'path';
+import path from 'path';
+import semver from 'semver';
 import * as auth from './authutil';
 
+const qualityOptions = [
+  'daily',
+  'signed',
+  'validated',
+  'preview',
+  'ga'
+] as const;
+
+export type QualityOptions = typeof qualityOptions[number];
+
 export async function run() {
   try {
     //
     // dotnet-version is optional, but needs to be provided for most use cases.
     // If supplied, install / use from the tool cache.
+    // global-version-file may be specified to point to a specific global.json
+    // and will be used to install an additional version.
     // If not supplied, look for version in ./global.json.
     // If a valid version still can't be identified, nothing will be installed.
     // Proxy, auth, (etc) are still set up, even if no version is identified
     //
-    let version = core.getInput('dotnet-version');
-    if (!version) {
+    const versions = core.getMultilineInput('dotnet-version');
+    const installedDotnetVersions: string[] = [];
+
+    const globalJsonFileInput = core.getInput('global-json-file');
+    if (globalJsonFileInput) {
+      const globalJsonPath = path.join(process.cwd(), globalJsonFileInput);
+      if (!fs.existsSync(globalJsonPath)) {
+        throw new Error(
+          `The specified global.json file '${globalJsonFileInput}' does not exist`
+        );
+      }
+      versions.push(getVersionFromGlobalJson(globalJsonPath));
+    }
+
+    if (!versions.length) {
       // Try to fall back to global.json
       core.debug('No version found, trying to find version from global.json');
       const globalJsonPath = path.join(process.cwd(), 'global.json');
       if (fs.existsSync(globalJsonPath)) {
-        version = getVersionFromGlobalJson(globalJsonPath);
+        versions.push(getVersionFromGlobalJson(globalJsonPath));
       }
     }
 
-    if (version) {
-      const includePrerelease: boolean =
-        (core.getInput('include-prerelease') || 'false').toLowerCase() ===
-        'true';
+    if (versions.length) {
+      const quality = core.getInput('dotnet-quality') as QualityOptions;
 
-      const dotnetInstaller = new installer.DotnetCoreInstaller(
-        version,
-        includePrerelease
-      );
-      await dotnetInstaller.installDotnet();
+      if (quality && !qualityOptions.includes(quality)) {
+        throw new Error(
+          `${quality} is not a supported value for 'dotnet-quality' option. Supported values are: daily, signed, validated, preview, ga.`
+        );
+      }
+
+      let dotnetInstaller: DotnetCoreInstaller;
+      const uniqueVersions = new Set<string>(versions);
+      for (const version of uniqueVersions) {
+        dotnetInstaller = new DotnetCoreInstaller(version, quality);
+        const installedVersion = await dotnetInstaller.installDotnet();
+        installedDotnetVersions.push(installedVersion);
+      }
+      DotnetCoreInstaller.addToPath();
     }
 
     const sourceUrl: string = core.getInput('source-url');
@@ -41,8 +74,22 @@ export async function run() {
       auth.configAuthentication(sourceUrl, configFile);
     }
 
+    const comparisonRange: string = globalJsonFileInput
+      ? versions[versions.length - 1]!
+      : '*';
+
+    const versionToOutput = semver.maxSatisfying(
+      installedDotnetVersions,
+      comparisonRange,
+      {
+        includePrerelease: true
+      }
+    );
+
+    core.setOutput('dotnet-version', versionToOutput);
+
     const matchersPath = path.join(__dirname, '..', '.github');
-    console.log(`##[add-matcher]${path.join(matchersPath, 'csc.json')}`);
+    core.info(`##[add-matcher]${path.join(matchersPath, 'csc.json')}`);
   } catch (error) {
     core.setFailed(error.message);
   }

src/utils.ts

@@ -0,0 +1,3 @@
+export const IS_WINDOWS = process.platform === 'win32';
+export const IS_LINUX = process.platform === 'linux';
+export const IS_MAC = process.platform === 'darwin';