Add @actions/virtual-environments-owners to CODEOWNERS file

Update installer scripts

.gitattributes

@@ -0,0 +1 @@
+.licenses/** -diff linguist-generated=true

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @actions/virtual-environments-owners

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,32 @@
+---
+name: Bug report
+about: Create a bug report
+title: ''
+labels: bug, needs triage
+assignees: ''
+
+---
+
+**Description:**
+A clear and concise description of what the bug is.
+
+**Task version:**
+Specify the task version
+
+**Platform:**
+- [ ] Ubuntu
+- [ ] macOS
+- [ ] Windows
+
+**Runner type:**
+- [ ] Hosted
+- [ ] Self-hosted
+
+**Repro steps:**  
+A description with steps to reproduce the issue. If your have a public example or repo to share, please provide the link.
+
+**Expected behavior:**
+A description of what you expected to happen.
+
+**Actual behavior:**
+A description of what is actually happening.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: .NET issues
+    url: https://github.com/dotnet/runtime#filing-issues
+    about: Issues with the runtime, class libraries, frameworks, and SDK should be addressed directly with the .NET team. Documentation on filing issues can be found here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,16 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: feature request, needs triage
+assignees: ''
+---
+
+**Description:**
+Describe your proposal.
+
+**Justification:**
+Justification or a use case for your proposal.
+
+**Are you willing to submit a PR?**
+<!--- We accept contributions! -->

.github/pull_request_template.md

@@ -0,0 +1,9 @@
+**Description:**
+Describe your changes.
+
+**Related issue:**
+Add link to the related issue.
+
+**Check list:**
+- [ ] Mark if documentation changes are required.
+- [ ] Mark if tests were added or updated to cover the changes.

.github/workflows/licensed.yml

@@ -0,0 +1,20 @@
+name: Licensed
+
+on:
+  push: {branches: main}
+  pull_request: {branches: main}
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    name: Check licenses
+    steps:
+      - uses: actions/checkout@v2
+      - run: npm ci
+      - 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
+          sudo tar -xzf licensed.tar.gz
+          sudo mv licensed /usr/local/bin/licensed
+      - run: licensed status

.github/workflows/test-dotnet.yml

@@ -0,0 +1,37 @@
+name: Validate dotnet
+
+on:
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  push:
+    branches:
+      - main
+      - releases/*
+    paths-ignore:
+      - '**.md'
+
+jobs:
+  setup-version:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+        dotnet-version: ['2.1', '2.2', '3.0', '3.1', '5.0']
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      - name: Setup dotnet ${{ matrix.dotnet-version }}
+        uses: ./
+        with:
+          dotnet-version: ${{ matrix.dotnet-version }}
+      - name: Check installed version
+        shell: pwsh
+        run: |
+          $version = & dotnet --version
+          Write-Host "Installed version: $version"
+          if (-not $version.StartsWith("${{ matrix.dotnet-version }}")) { throw "Unexpected version" }

.github/workflows/workflow.yml

@@ -2,15 +2,20 @@ name: Main workflow
 
 on:
   pull_request:
+    paths-ignore:
+      - '**.md'
   push:
     branches:
-      - master
+      - main
       - releases/*
+    paths-ignore:
+      - '**.md'
 
 jobs:
   build:
     runs-on: ${{ matrix.operating-system }}
     strategy:
+      fail-fast: false
       matrix:
         operating-system: [ubuntu-latest, windows-latest, macOS-latest]
     steps:
@@ -19,7 +24,7 @@ jobs:
     - name: Set Node.js 12
       uses: actions/setup-node@v1
       with:
-        version: 12.x
+        node-version: 12.x
     - run: npm ci
     - run: npm run build
     - run: npm run format-check
@@ -28,26 +33,111 @@ jobs:
       if: runner.os != 'windows'
       run: __tests__/verify-no-unstaged-changes.sh
 
-  test:
+  test-setup-full-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@v2
-      - name: Clear tool cache
+      - name: Clear toolcache
-        run: mv "${{ runner.tool_cache }}" "${{ runner.tool_cache }}.old"
+        shell: pwsh
-      - name: Setup dotnet 3.0.100
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      # Side-by-side install of 2.2 and 3.1 used for the test project
+      - name: Setup dotnet 2.2.402
         uses: ./
         with:
-          dotnet-version: 3.0.100
+          dotnet-version: 2.2.402
+      - name: Setup dotnet 3.1.201
+        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
+          source-url: https://api.nuget.org/v3/index.json
+        env:
+          NUGET_AUTH_TOKEN: NOTATOKEN
+      - name: Verify nuget config file
+        shell: pwsh
+        run: |
+          if (-Not (Test-Path "../nuget.config")) { throw "nuget file not generated correctly" }
       - name: Verify dotnet
-        if: runner.os != 'windows'
+        shell: pwsh
-        run: __tests__/verify-dotnet.sh 3.0.100
+        run: __tests__/verify-dotnet.ps1 3.1.201 2.2.402
-      - name: Verify dotnet (Windows)
+
-        if: runner.os == 'windows'
+  test-setup-without-patch-version:
-        run: __tests__/verify-dotnet.ps1 3.0.100
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      # 2.0, 3.0, 5.0 needs to be in single quotes to interpret as a string instead of as an integer
+      - name: Setup dotnet '3.1'
+        uses: ./
+        with:
+          dotnet-version: '3.1'
+      - name: Setup dotnet '2.2'
+        uses: ./
+        with:
+          dotnet-version: '2.2'
+      - name: Verify dotnet
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 3.1 2.2
+  
+  test-setup-latest-patch-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@v2
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      - name: Setup dotnet 3.1.x
+        uses: ./
+        with:
+          dotnet-version: 3.1.x
+      - name: Setup dotnet 2.2.x
+        uses: ./
+        with:
+          dotnet-version: 2.2.x
+      - name: Verify dotnet
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 3.1 2.2
+
+  test-setup-with-wildcard:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      - name: Setup dotnet 3.1.*
+        uses: ./
+        with:
+          dotnet-version: 3.1.*
+      - name: Setup dotnet 2.2.*
+        uses: ./
+        with:
+          dotnet-version: 2.2.*
+      - name: Verify dotnet
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 3.1 2.2
 
   test-proxy:
     runs-on: ubuntu-latest
@@ -61,31 +151,42 @@ jobs:
           - 3128:3128
     env:
       https_proxy: http://squid-proxy:3128
+      http_proxy: http://squid-proxy:3128
     steps:
       - name: Checkout
         uses: actions/checkout@v2
       - name: Clear tool cache
-        run: rm -rf $RUNNER_TOOL_CACHE/*
+        run: rm -rf "/usr/share/dotnet"
-      - name: Setup dotnet 3.0.100
+      - name: Install curl
+        run: |
+          apt update
+          apt -y install curl
+      - name: Setup dotnet 3.1.201
         uses: ./
         with:
-          dotnet-version: 3.0.100
+          dotnet-version: 3.1.201
+          source-url: https://api.nuget.org/v3/index.json
+        env:
+          NUGET_AUTH_TOKEN: NOTATOKEN
       - name: Verify dotnet
-        run: __tests__/verify-dotnet.sh 3.0.100
+        run: __tests__/verify-dotnet.sh 3.1.201
 
   test-bypass-proxy:
     runs-on: ubuntu-latest
     env:
       https_proxy: http://no-such-proxy:3128
-      no_proxy: github.com,dotnetcli.blob.core.windows.net,download.visualstudio.microsoft.com,api.nuget.org
+      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
       - name: Clear tool cache
-        run: mv "${{ runner.tool_cache }}" "${{ runner.tool_cache }}.old"
+        run: rm -rf "/usr/share/dotnet"
-      - name: Setup dotnet 3.0.100
+      - name: Setup dotnet 3.1.201
         uses: ./
         with:
-          dotnet-version: 3.0.100
+          dotnet-version: 3.1.201
+          source-url: https://api.nuget.org/v3/index.json
+        env:
+          NUGET_AUTH_TOKEN: NOTATOKEN
       - name: Verify dotnet
-        run: __tests__/verify-dotnet.sh 3.0.100
+        run: __tests__/verify-dotnet.sh 3.1.201

.gitignore

@@ -95,4 +95,5 @@ typings/
 # DynamoDB Local files
 .dynamodb/
 
-.vscode/*
+# Ignore .vscode files
+.vscode/

.licensed.yml

@@ -0,0 +1,14 @@
+sources:
+  npm: true
+
+allowed:
+  - apache-2.0
+  - bsd-2-clause
+  - bsd-3-clause
+  - isc
+  - mit
+  - cc0-1.0
+  - unlicense
+
+reviewed:
+  npm:

README.md

@@ -10,6 +10,12 @@ This action sets up a [dotnet core cli](https://github.com/dotnet/cli) environme
 - 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
+preinstalled. Installed versions are subject to change. Please refer to the
+documentation
+[software installed on github hosted runners](https://help.github.com/en/actions/reference/software-installed-on-github-hosted-runners)
+for .NET SDK versions that are currently available.
+
 # Usage
 
 See [action.yml](action.yml)
@@ -17,7 +23,7 @@ See [action.yml](action.yml)
 Basic:
 ```yaml
 steps:
-- uses: actions/checkout@master
+- uses: actions/checkout@main
 - uses: actions/setup-dotnet@v1
   with:
     dotnet-version: '3.1.x' # SDK Version to use; x will use the latest version of the 3.1 channel
@@ -28,13 +34,13 @@ Matrix Testing:
 ```yaml
 jobs:
   build:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-latest
     strategy:
       matrix:
         dotnet: [ '2.2.103', '3.0', '3.1.x' ]
     name: Dotnet ${{ matrix.dotnet }} sample
     steps:
-      - uses: actions/checkout@master
+      - uses: actions/checkout@v2
       - name: Setup dotnet
         uses: actions/setup-dotnet@v1
         with:
@@ -42,10 +48,30 @@ jobs:
       - run: dotnet build <my project>
 ```
 
+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.2.103'
+      - 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
 steps:
-- uses: actions/checkout@master
+- uses: actions/checkout@v2
 # Authenticates packages to push to GPR
 - uses: actions/setup-dotnet@v1
   with:
@@ -69,6 +95,27 @@ steps:
   run: dotnet nuget push <my project>/bin/Release/*.nupkg
 ```
 
+## Environment Variables to use with dotnet
+
+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)
+
+Example usage:
+```yaml
+build:
+  runs-on: ubuntu-latest
+  env:
+    DOTNET_NOLOGO: true
+  steps:
+    - uses: actions/checkout@main
+    - uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: '3.1.100' # SDK Version to use.
+```
+
 # License
 
 The scripts and documentation in this project are released under the [MIT License](LICENSE)

__tests__/authutil.test.ts

@@ -75,14 +75,17 @@ const azureartifactsnugetorgNuGetConfig: string = `<?xml version="1.0" encoding=
 const nugetConfigFile = path.join(fakeSourcesDirForTesting, '../nuget.config');
 
 process.env['GITHUB_REPOSITORY'] = 'OwnerName/repo';
-process.env['RUNNER_TEMP'] = fakeSourcesDirForTesting;
 import * as auth from '../src/authutil';
 
 describe('authutil tests', () => {
   beforeEach(async () => {
     await io.rmRF(fakeSourcesDirForTesting);
     await io.mkdirP(fakeSourcesDirForTesting);
-  }, 100000);
+  }, 30000);
+
+  afterAll(async () => {
+    await io.rmRF(fakeSourcesDirForTesting);
+  }, 30000);
 
   beforeEach(() => {
     if (fs.existsSync(nugetConfigFile)) {
@@ -95,7 +98,9 @@ describe('authutil tests', () => {
   it('No existing config, sets up a full NuGet.config with URL and user/PAT for GPR', async () => {
     process.env['NUGET_AUTH_TOKEN'] = 'TEST_FAKE_AUTH_TOKEN';
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/OwnerName/index.json'
+      'https://nuget.pkg.github.com/OwnerName/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -107,7 +112,9 @@ describe('authutil tests', () => {
     let thrown = false;
     try {
       await auth.configAuthentication(
-        'https://nuget.pkg.github.com/OwnerName/index.json'
+        'https://nuget.pkg.github.com/OwnerName/index.json',
+        '',
+        fakeSourcesDirForTesting
       );
     } catch {
       thrown = true;
@@ -119,7 +126,9 @@ describe('authutil tests', () => {
     process.env['NUGET_AUTH_TOKEN'] = 'TEST_FAKE_AUTH_TOKEN';
     process.env['INPUT_OWNER'] = 'otherorg';
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/otherorg/index.json'
+      'https://nuget.pkg.github.com/otherorg/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -137,7 +146,9 @@ describe('authutil tests', () => {
     let thrown = false;
     try {
       await auth.configAuthentication(
-        'https://nuget.pkg.github.com/OwnerName/index.json'
+        'https://nuget.pkg.github.com/OwnerName/index.json',
+        '',
+        fakeSourcesDirForTesting
       );
     } catch {
       thrown = true;
@@ -153,7 +164,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, emptyNuGetConfig);
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/OwnerName/index.json'
+      'https://nuget.pkg.github.com/OwnerName/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -169,7 +182,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, nugetorgNuGetConfig);
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/OwnerName/index.json'
+      'https://nuget.pkg.github.com/OwnerName/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -185,7 +200,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, gprNuGetConfig);
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/OwnerName/index.json'
+      'https://nuget.pkg.github.com/OwnerName/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -201,7 +218,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, gprnugetorgNuGetConfig);
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/OwnerName/index.json'
+      'https://nuget.pkg.github.com/OwnerName/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -216,7 +235,11 @@ describe('authutil tests', () => {
       'nuget.config'
     );
     fs.writeFileSync(inputNuGetConfigPath, twogprNuGetConfig);
-    await auth.configAuthentication('https://nuget.pkg.github.com');
+    await auth.configAuthentication(
+      'https://nuget.pkg.github.com',
+      '',
+      fakeSourcesDirForTesting
+    );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
       fs.readFileSync(nugetConfigFile, {encoding: 'utf8'})
@@ -233,7 +256,9 @@ describe('authutil tests', () => {
     let thrown = false;
     try {
       await auth.configAuthentication(
-        'https://nuget.pkg.github.com/OwnerName/index.json'
+        'https://nuget.pkg.github.com/OwnerName/index.json',
+        '',
+        fakeSourcesDirForTesting
       );
     } catch {
       thrown = true;
@@ -255,7 +280,8 @@ describe('authutil tests', () => {
     fs.writeFileSync(inputNuGetConfigPath, gprNuGetConfig);
     await auth.configAuthentication(
       'https://nuget.pkg.github.com/OwnerName/index.json',
-      'subfolder/nuget.config'
+      'subfolder/nuget.config',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -271,7 +297,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, azureartifactsNuGetConfig);
     await auth.configAuthentication(
-      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json'
+      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -287,7 +315,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, azureartifactsnugetorgNuGetConfig);
     await auth.configAuthentication(
-      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json'
+      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -298,7 +328,9 @@ describe('authutil tests', () => {
   it('No existing config, sets up a full NuGet.config with URL and token for other source', async () => {
     process.env['NUGET_AUTH_TOKEN'] = 'TEST_FAKE_AUTH_TOKEN';
     await auth.configAuthentication(
-      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json'
+      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(

__tests__/clear-toolcache.ps1

@@ -0,0 +1,13 @@
+$dotnetPaths = @{
+    Linux = @("/usr/share/dotnet")
+    macOS = @("$env:HOME/.dotnet")
+    Windows = @("$env:ProgramFiles\dotnet/*",
+                  "$env:LocalAppData\Microsoft\dotnet/*")
+}
+
+foreach ($path in $dotnetPaths[$args[0]]) {
+    if (Test-Path $path) {
+        Write-Host "Clear $path path"
+        Remove-Item $path -Recurse -Force
+    }
+}

__tests__/csc.test.ts

@@ -0,0 +1,23 @@
+import fs = require('fs');
+
+describe('csc tests', () => {
+  it('Valid regular expression', async () => {
+    var cscFile = require('../.github/csc.json');
+    var regex = cscFile['problemMatcher'][0]['pattern'][0]['regexp'];
+
+    console.log(regex);
+    var re = new RegExp(regex);
+
+    // Ideally we would verify that this
+    var stringsToMatch = [
+      'Program.cs(10,79): error CS1002: ; expected [/Users/zacharyeisinger/Documents/repo/setup-dotnet/__tests__/sample-broken-csproj/sample.csproj]',
+      "S:\\Msbuild\\src\\Build\\Evaluation\\ExpressionShredder.cs(33,7): error CS1003: Syntax error, ',' expected [S:\\msbuild\\src\\Build\\Microsoft.Build.csproj > Properties:prop]"
+    ];
+
+    stringsToMatch.forEach(string => {
+      var matchStr = string.match(re);
+      console.log(matchStr);
+      expect(matchStr).toEqual(expect.anything());
+    });
+  }, 10000);
+});

__tests__/installer.test.ts

@@ -4,75 +4,21 @@ import os = require('os');
 import path = require('path');
 import hc = require('@actions/http-client');
 
-import each from 'jest-each';
-
 const toolDir = path.join(__dirname, 'runner', 'tools');
 const tempDir = path.join(__dirname, 'runner', 'temp');
 
 process.env['RUNNER_TOOL_CACHE'] = toolDir;
 process.env['RUNNER_TEMP'] = tempDir;
-import * as setup from '../src/setup-dotnet';
 import * as installer from '../src/installer';
 
 const IS_WINDOWS = process.platform === 'win32';
 
-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.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',
-    '2.x',
-    '*.*.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();
-  });
-});
-
 describe('installer 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);
   });
@@ -84,83 +30,40 @@ describe('installer tests', () => {
     } catch {
       console.log('Failed to remove test directories');
     }
-  }, 100000);
+  }, 30000);
-
-  it('Resolving a normal generic version works', async () => {
-    const dotnetInstaller = new installer.DotnetCoreInstaller('3.1.x');
-    let versInfo = await dotnetInstaller.resolveInfos(
-      ['win-x64'],
-      new installer.DotNetVersionInfo('3.1.x')
-    );
-
-    expect(versInfo.resolvedVersion.startsWith('3.1.'));
-  }, 100000);
-
-  it('Resolving a nonexistent generic version fails', async () => {
-    const dotnetInstaller = new installer.DotnetCoreInstaller('999.1.x');
-    try {
-      await dotnetInstaller.resolveInfos(
-        ['win-x64'],
-        new installer.DotNetVersionInfo('999.1.x')
-      );
-      fail();
-    } catch {
-      expect(true);
-    }
-  }, 100000);
-
-  it('Resolving a exact stable version works', async () => {
-    const dotnetInstaller = new installer.DotnetCoreInstaller('3.1.201');
-    let versInfo = await dotnetInstaller.resolveInfos(
-      ['win-x64'],
-      new installer.DotNetVersionInfo('3.1.201')
-    );
-
-    expect(versInfo.resolvedVersion).toBe('3.1.201');
-  }, 100000);
-
-  it('Resolving a exact preview version works', async () => {
-    const dotnetInstaller = new installer.DotnetCoreInstaller(
-      '5.0.0-preview.4'
-    );
-    let versInfo = await dotnetInstaller.resolveInfos(
-      ['win-x64'],
-      new installer.DotNetVersionInfo('5.0.0-preview.4')
-    );
-
-    expect(versInfo.resolvedVersion).toBe('5.0.0-preview.4');
-  }, 100000);
 
   it('Acquires version of dotnet if no matching version is installed', async () => {
-    await getDotnet('2.2.205');
+    await getDotnet('3.1.201');
-    const dotnetDir = path.join(toolDir, 'dncs', '2.2.205', os.arch());
+    expect(fs.existsSync(path.join(toolDir, 'sdk', '3.1.201'))).toBe(true);
-
-    expect(fs.existsSync(`${dotnetDir}.complete`)).toBe(true);
     if (IS_WINDOWS) {
-      expect(fs.existsSync(path.join(dotnetDir, 'dotnet.exe'))).toBe(true);
+      expect(fs.existsSync(path.join(toolDir, 'dotnet.exe'))).toBe(true);
     } else {
-      expect(fs.existsSync(path.join(dotnetDir, 'dotnet'))).toBe(true);
+      expect(fs.existsSync(path.join(toolDir, 'dotnet'))).toBe(true);
     }
-  }, 400000); //This needs some time to download on "slower" internet connections
 
-  it('Acquires version of dotnet if no matching version is installed', async () => {
+    expect(process.env.DOTNET_ROOT).toBeDefined;
-    const dotnetDir = path.join(toolDir, 'dncs', '2.2.105', os.arch());
+    expect(process.env.PATH).toBeDefined;
+    expect(process.env.DOTNET_ROOT).toBe(toolDir);
+    expect(process.env.PATH?.startsWith(toolDir)).toBe(true);
+  }, 600000); //This needs some time to download on "slower" internet connections
 
-    const globalJsonPath = path.join(process.cwd(), 'global.json');
+  it('Acquires generic version of dotnet if no matching version is installed', async () => {
-    const jsonContents = `{${os.EOL}"sdk": {${os.EOL}"version": "2.2.105"${os.EOL}}${os.EOL}}`;
+    await getDotnet('3.1');
-    if (!fs.existsSync(globalJsonPath)) {
+    var directory = fs
-      fs.writeFileSync(globalJsonPath, jsonContents);
+      .readdirSync(path.join(toolDir, 'sdk'))
-    }
+      .filter(fn => fn.startsWith('3.1.'));
-    await setup.run();
+    expect(directory.length > 0).toBe(true);
-
-    expect(fs.existsSync(`${dotnetDir}.complete`)).toBe(true);
     if (IS_WINDOWS) {
-      expect(fs.existsSync(path.join(dotnetDir, 'dotnet.exe'))).toBe(true);
+      expect(fs.existsSync(path.join(toolDir, 'dotnet.exe'))).toBe(true);
     } else {
-      expect(fs.existsSync(path.join(dotnetDir, 'dotnet'))).toBe(true);
+      expect(fs.existsSync(path.join(toolDir, 'dotnet'))).toBe(true);
     }
-    fs.unlinkSync(globalJsonPath);
+
-  }, 100000);
+    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); //This needs some time to download on "slower" internet connections
 
   it('Throws if no location contains correct dotnet version', async () => {
     let thrown = false;
@@ -170,30 +73,7 @@ describe('installer tests', () => {
       thrown = true;
     }
     expect(thrown).toBe(true);
-  }, 100000);
+  }, 30000);
-
-  it('Uses version of dotnet installed in cache', async () => {
-    const dotnetDir: string = path.join(toolDir, 'dncs', '250.0.0', os.arch());
-    await io.mkdirP(dotnetDir);
-    fs.writeFileSync(`${dotnetDir}.complete`, 'hello');
-    // This will throw if it doesn't find it in the cache (because no such version exists)
-    await getDotnet('250.0.0');
-    return;
-  });
-
-  it('Doesnt use version of dotnet that was only partially installed in cache', async () => {
-    const dotnetDir: string = path.join(toolDir, 'dncs', '251.0.0', os.arch());
-    await io.mkdirP(dotnetDir);
-    let thrown = false;
-    try {
-      // This will throw if it doesn't find it in the cache (because no such version exists)
-      await getDotnet('251.0.0');
-    } catch {
-      thrown = true;
-    }
-    expect(thrown).toBe(true);
-    return;
-  });
 
   it('Uses an up to date bash download script', async () => {
     const httpCallbackClient = new hc.HttpClient('setup-dotnet-test', [], {
@@ -213,7 +93,7 @@ describe('installer tests', () => {
     expect(normalizeFileContents(currentContents)).toBe(
       normalizeFileContents(upToDateContents)
     );
-  }, 100000);
+  }, 30000);
 
   it('Uses an up to date powershell download script', async () => {
     var httpCallbackClient = new hc.HttpClient('setup-dotnet-test', [], {
@@ -233,7 +113,7 @@ describe('installer tests', () => {
     expect(normalizeFileContents(currentContents)).toBe(
       normalizeFileContents(upToDateContents)
     );
-  }, 100000);
+  }, 30000);
 });
 
 function normalizeFileContents(contents: string): string {

__tests__/sample-csproj/Program.cs

@@ -1,14 +1,15 @@
-using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Newtonsoft.Json;
+using System;
 
 namespace sample_csproj
 {
-    class Program
+    [TestClass]
+    public class Program
     {
-        static void Main(string[] args)
+        [TestMethod]
+        public void TestMethod1()
         {
-            var json = JsonConvert.SerializeObject(new[] {"Hello", "World!" });
+            Console.WriteLine("Hello, World!");
-            Console.WriteLine(json);
         }
     }
 }

__tests__/sample-csproj/runtimeconfig.template.json

@@ -1,7 +0,0 @@
-{
-  "runtimeOptions": {
-    "configProperties": {
-      "System.Globalization.Invariant": true
-    }
-  }
-}

__tests__/sample-csproj/sample.csproj

@@ -1,13 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <OutputType>Exe</OutputType>
+    <TargetFrameworks>netcoreapp3.1;netcoreapp2.2</TargetFrameworks>
-    <TargetFramework>netcoreapp3.0</TargetFramework>
     <RootNamespace>sample_csproj</RootNamespace>
+
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <!-- These packages will be downloaded over the network for testing proxy settings -->
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.1.0" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.1.0" />
+    <PackageReference Include="coverlet.collector" Version="1.2.0" />
   </ItemGroup>
 
 </Project>

__tests__/setup-dotnet.test.ts

@@ -0,0 +1,47 @@
+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 setup from '../src/setup-dotnet';
+
+const IS_WINDOWS = process.platform === 'win32';
+
+describe('setup-dotnet tests', () => {
+  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);
+  });
+
+  afterAll(async () => {
+    try {
+      await io.rmRF(path.join(process.cwd(), 'global.json'));
+      await io.rmRF(toolDir);
+      await io.rmRF(tempDir);
+    } catch {
+      console.log('Failed to remove test directories');
+    }
+  }, 30000);
+
+  it('Acquires version of dotnet from global.json if no matching version is installed', async () => {
+    const globalJsonPath = path.join(process.cwd(), 'global.json');
+    const jsonContents = `{${os.EOL}"sdk": {${os.EOL}"version": "3.1.201"${os.EOL}}${os.EOL}}`;
+    if (!fs.existsSync(globalJsonPath)) {
+      fs.writeFileSync(globalJsonPath, jsonContents);
+    }
+    await setup.run();
+
+    expect(fs.existsSync(path.join(toolDir, 'sdk', '3.1.201'))).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);
+    }
+  }, 400000);
+});

__tests__/verify-dotnet.ps1

@@ -8,13 +8,32 @@ Write-Host "Found '$dotnet'"
 
 $version = & $dotnet --version | Out-String | ForEach-Object { $_.Trim() }
 Write-Host "Version $version"
-# if ($version -ne $args[0])
+if (-not ($version.StartsWith($args[0].ToString())))
-# {
+{
-#   Write-Host "PATH='$env:path'"
+  Write-Host "PATH='$env:PATH'"
-#   Write-Host "gcm dotnet:"
+  throw "Unexpected version"
-#   gcm dotnet | fl
+}
-#   throw "Unexpected version"
+
-# }
+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())) 
+    {
+      $isInstalledVersion = $true
+      break
+    }
+  }
+  if (-not $isInstalledVersion)
+  {
+    Write-Host "PATH='$env:PATH'"
+    throw "Unexpected version"
+  }
+}
 
 Write-Host "Building sample csproj"
 & $dotnet build __tests__/sample-csproj/ --no-cache
@@ -24,9 +43,20 @@ if ($LASTEXITCODE -ne 0)
 }
 
 Write-Host "Testing compiled app"
-$sample_output = "$(__tests__/sample-csproj/bin/Debug/netcoreapp3.0/sample.exe)".Trim()
+$sample_output = "$(dotnet test __tests__/sample-csproj/ --no-build)"
 Write-Host "Sample output: $sample_output"
-if ($sample_output -notlike "*Hello*World*")
+# For Side-by-Side installs we want to run the tests twice, for a single install the tests will run once
+if ($args[1])
 {
-  throw "Unexpected output"
+  if ($sample_output -notlike "*Test Run Successful.*Test Run Successful.*")
+  {
+    throw "Unexpected output"
+  }
+}
+else
+{
+  if ($sample_output -notlike "*Test Run Successful.*")
+  {
+    throw "Unexpected output"
+  }
 }

__tests__/verify-dotnet.sh

@@ -3,6 +3,11 @@ if [ -z "$1" ]; then
   exit 1
 fi
 
+if [ ! -f "../nuget.config" ]; then
+  echo "nuget file not generated correctly"
+  exit 1
+fi
+
 dotnet_version="$(dotnet --version)"
 echo "Found dotnet version '$dotnet_version'"
 if [ -z "$(echo $dotnet_version | grep $1)" ]; then
@@ -10,13 +15,30 @@ if [ -z "$(echo $dotnet_version | grep $1)" ]; then
   exit 1
 fi
 
+if [ -n "$2" ]; then
+  dotnet_version="$(dotnet --list-sdks)"
+  echo "Found dotnet version '$dotnet_version'"
+  if [ -z "$(echo $dotnet_version | grep $2)" ]; then
+    echo "Unexpected version"
+    exit 1
+  fi
+fi
+
 echo "Building sample csproj"
 dotnet build __tests__/sample-csproj/ --no-cache || exit 1
 
 echo "Testing compiled app"
-sample_output="$(__tests__/sample-csproj/bin/Debug/netcoreapp3.0/sample)"
+sample_output=$(dotnet test __tests__/sample-csproj/ --no-build)
 echo "Sample output: $sample_output"
-if [ -z "$(echo $sample_output | grep Hello)" ]; then
+# For Side-by-Side installs we want to run the tests twice, for a single install the tests will run once
-  echo "Unexpected output"
+if [ -n "$2" ]; then
-  exit 1
+  if [ -z "$(echo $sample_output | grep "Test Run Successful.*Test Run Successful.")" ]; then
+    echo "Unexpected output"
+    exit 1
+  fi
+else
+  if [ -z "$(echo $sample_output | grep "Test Run Successful.")" ]; then
+    echo "Unexpected output"
+    exit 1
+  fi
 fi

__tests__/versionutil.test.ts

@@ -0,0 +1,90 @@
+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.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',
+    '2.x',
+    '*.*.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

@@ -4,19 +4,15 @@ author: 'GitHub'
 branding:
   icon: play
   color: green
-inputs: 
+inputs:
   dotnet-version:
-    description: 'SDK version to use. Examples: 2.2.104, 3.1, 3.1.x'
+    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'
   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.'
-  # Deprecated option, do not use. Will not be supported after October 1, 2019
-  version:
-    description: 'Deprecated. Use dotnet-version instead. Will not be supported after October 1, 2019'
-    deprecationMessage: 'The version property will not be supported after October 1, 2019. Use dotnet-version instead'
 runs:
   using: 'node12'
   main: 'dist/index.js'

docs/contributors.md

@@ -1,17 +1,34 @@
 # 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.
 
-# Checkin
+If you would like to contribute there are a few things to consider:
 
-- Do checkin source (src)
+## Commands to use
-- Do checkin build output (lib)
-- Do checkin runtime node_modules
-- Do not checkin 
 
-# Adding a dev dependency
+- 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)
 
-Remember to update .gitignore.  
+## To check in or not to check in
 
-# Updating toolkit dependency
+- 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)
 
-Until released publically, update tgz packages in toolkit
+## Writing tests
+
+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.
+
+## Creating new version
+
+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
+```

externals/get-os-distro.sh

@@ -1,192 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) .NET Foundation and contributors. All rights reserved.
-# Licensed under the MIT license. See LICENSE file in the project root for full license information.
-#
-
-# Stop script on NZEC
-set -e
-# Stop script if unbound variable found (use ${var:-} if intentional)
-set -u
-# By default cmd1 | cmd2 returns exit code of cmd2 regardless of cmd1 success
-# This is causing it to fail
-set -o pipefail
-
-# Use in the the functions: eval $invocation
-invocation='say_verbose "Calling: ${yellow:-}${FUNCNAME[0]} ${green:-}$*${normal:-}"'
-
-# standard output may be used as a return value in the functions
-# we need a way to write text on the screen in the functions so that
-# it won't interfere with the return value.
-# Exposing stream 3 as a pipe to standard output of the script itself
-exec 3>&1
-
-say_err() {
-    printf "%b\n" "get-os-distro: Error: $1" >&2
-}
-
-# This platform list is finite - if the SDK/Runtime has supported Linux distribution-specific assets,
-#   then and only then should the Linux distribution appear in this list.
-# Adding a Linux distribution to this list does not imply distribution-specific support.
-get_legacy_os_name_from_platform() {
-
-    platform="$1"
-    case "$platform" in
-        "centos.7")
-            echo "centos"
-            return 0
-            ;;
-        "debian.8")
-            echo "debian"
-            return 0
-            ;;
-        "fedora.23")
-            echo "fedora.23"
-            return 0
-            ;;
-        "fedora.27")
-            echo "fedora.27"
-            return 0
-            ;;
-        "fedora.24")
-            echo "fedora.24"
-            return 0
-            ;;
-        "opensuse.13.2")
-            echo "opensuse.13.2"
-            return 0
-            ;;
-        "opensuse.42.1")
-            echo "opensuse.42.1"
-            return 0
-            ;;
-        "opensuse.42.3")
-            echo "opensuse.42.3"
-            return 0
-            ;;
-        "rhel.7"*)
-            echo "rhel"
-            return 0
-            ;;
-        "ubuntu.14.04")
-            echo "ubuntu"
-            return 0
-            ;;
-        "ubuntu.16.04")
-            echo "ubuntu.16.04"
-            return 0
-            ;;
-        "ubuntu.16.10")
-            echo "ubuntu.16.10"
-            return 0
-            ;;
-        "ubuntu.18.04")
-            echo "ubuntu.18.04"
-            return 0
-            ;;
-        "alpine.3.4.3")
-            echo "alpine"
-            return 0
-            ;;
-    esac
-    return 1
-}
-
-get_linux_platform_name() {
-
-    if [ -e /etc/os-release ]; then
-        . /etc/os-release
-        echo "$ID.$VERSION_ID"
-        return 0
-    elif [ -e /etc/redhat-release ]; then
-        local redhatRelease=$(</etc/redhat-release)
-        if [[ $redhatRelease == "CentOS release 6."* || $redhatRelease == "Red Hat Enterprise Linux Server release 6."* ]]; then
-            echo "rhel.6"
-            return 0
-        fi
-    fi
-
-    say_err "Linux specific platform name and version could not be detected: UName = $uname"
-    return 1
-}
-
-get_current_os_name() {
-
-    local uname=$(uname)
-    if [ "$uname" = "Darwin" ]; then
-        echo "osx"
-        return 0
-    elif [ "$uname" = "Linux" ]; then
-        local linux_platform_name
-        linux_platform_name="$(get_linux_platform_name)" || { echo "linux" && return 0 ; }
-
-        if [[ $linux_platform_name == "rhel.6" ]]; then
-            echo "$linux_platform_name"
-            return 0
-        elif [[ $linux_platform_name == alpine* ]]; then
-            echo "linux-musl"
-            return 0
-        else
-            echo "linux"
-            return 0
-        fi
-    fi
-
-    say_err "OS name could not be detected: UName = $uname"
-    return 1
-}
-
-get_legacy_os_name() {
-
-    local uname=$(uname)
-    if [ "$uname" = "Darwin" ]; then
-        echo "osx"
-        return 0
-    else
-        if [ -e /etc/os-release ]; then
-            . /etc/os-release
-            os=$(get_legacy_os_name_from_platform "$ID.$VERSION_ID" || echo "")
-            if [ -n "$os" ]; then
-                echo "$os"
-                return 0
-            fi
-        fi
-    fi
-
-    say_err "Distribution specific OS name and version could not be detected: UName = $uname"
-    return 1
-}
-
-get_machine_architecture() {
-
-    if command -v uname > /dev/null; then
-        CPUName=$(uname -m)
-        case $CPUName in
-        armv7l)
-            echo "arm"
-            return 0
-            ;;
-        aarch64)
-            echo "arm64"
-            return 0
-            ;;
-        esac
-    fi
-
-    # Always default to 'x64'
-    echo "x64"
-    return 0
-}
-
-osName=$(get_current_os_name || echo "")
-legacyOsName=$(get_legacy_os_name || echo "")
-arch=$(get_machine_architecture || echo "")
-
-primaryName="$osName-$arch"
-legacyName="$legacyOsName"
-
-echo "Primary:$primaryName"
-echo "Legacy:$legacyName"
-
-if [ -z "$osName" ] && [ -z "$legacyOsName" ];then
-    exit 1
-fi

externals/get-os-platform.ps1

@@ -1,18 +0,0 @@
-function Get-Machine-Architecture()
-{
-    # possible values: AMD64, IA64, x86
-    return $ENV:PROCESSOR_ARCHITECTURE
-}
-
-function Get-CLIArchitecture-From-Architecture([string]$Architecture)
-{
-    switch ($Architecture.ToLower())
-    {
-        { ($_ -eq "amd64") -or ($_ -eq "x64") } { return "x64" }
-        { $_ -eq "x86" } { return "x86" }
-        default { throw "Architecture not supported. If you think this is a bug, please report it at https://github.com/dotnet/cli/issues" }
-    }
-}
-
-$CLIArchitecture = Get-CLIArchitecture-From-Architecture $(Get-Machine-Architecture)
-Write-Output "Primary:win-$CLIArchitecture"

externals/install-dotnet.sh

@@ -40,7 +40,7 @@ if [ -t 1 ] && command -v tput > /dev/null; then
 fi
 
 say_warning() {
-    printf "%b\n" "${yellow:-}dotnet_install: Warning: $1${normal:-}"
+    printf "%b\n" "${yellow:-}dotnet_install: Warning: $1${normal:-}" >&3
 }
 
 say_err() {
@@ -183,6 +183,9 @@ get_current_os_name() {
         elif is_musl_based_distro; then
             echo "linux-musl"
             return 0
+        elif [ "$linux_platform_name" = "linux-musl" ]; then
+            echo "linux-musl"
+            return 0
         else
             echo "linux"
             return 0
@@ -241,42 +244,6 @@ check_min_reqs() {
     return 0
 }
 
-check_pre_reqs() {
-    eval $invocation
-
-    if [ "${DOTNET_INSTALL_SKIP_PREREQS:-}" = "1" ]; then
-        return 0
-    fi
-
-    if [ "$(uname)" = "Linux" ]; then
-        if is_musl_based_distro; then
-            if ! command -v scanelf > /dev/null; then
-                say_warning "scanelf not found, please install pax-utils package."
-                return 0
-            fi
-            LDCONFIG_COMMAND="scanelf --ldpath -BF '%f'"
-            [ -z "$($LDCONFIG_COMMAND 2>/dev/null | grep libintl)" ] && say_warning "Unable to locate libintl. Probable prerequisite missing; install libintl (or gettext)."
-        else
-            if [ ! -x "$(command -v ldconfig)" ]; then
-                say_verbose "ldconfig is not in PATH, trying /sbin/ldconfig."
-                LDCONFIG_COMMAND="/sbin/ldconfig"
-            else
-                LDCONFIG_COMMAND="ldconfig"
-            fi
-            local librarypath=${LD_LIBRARY_PATH:-}
-            LDCONFIG_COMMAND="$LDCONFIG_COMMAND -NXv ${librarypath//:/ }"
-        fi
-
-        [ -z "$($LDCONFIG_COMMAND 2>/dev/null | grep zlib)" ] && say_warning "Unable to locate zlib. Probable prerequisite missing; install zlib."
-        [ -z "$($LDCONFIG_COMMAND 2>/dev/null | grep ssl)" ] && say_warning "Unable to locate libssl. Probable prerequisite missing; install libssl."
-        [ -z "$($LDCONFIG_COMMAND 2>/dev/null | grep libicu)" ] && say_warning "Unable to locate libicu. Probable prerequisite missing; install libicu."
-        [ -z "$($LDCONFIG_COMMAND 2>/dev/null | grep lttng)" ] && say_warning "Unable to locate liblttng. Probable prerequisite missing; install libcurl."
-        [ -z "$($LDCONFIG_COMMAND 2>/dev/null | grep libcurl)" ] && say_warning "Unable to locate libcurl. Probable prerequisite missing; install libcurl."
-    fi
-
-    return 0
-}
-
 # args:
 # input - $1
 to_lowercase() {
@@ -332,11 +299,11 @@ get_machine_architecture() {
     if command -v uname > /dev/null; then
         CPUName=$(uname -m)
         case $CPUName in
-        armv7l)
+        armv*l)
             echo "arm"
             return 0
             ;;
-        aarch64)
+        aarch64|arm64)
             echo "arm64"
             return 0
             ;;
@@ -373,10 +340,34 @@ get_normalized_architecture_from_architecture() {
             ;;
     esac
 
-    say_err "Architecture \`$architecture\` not supported. If you think this is a bug, report it at https://github.com/dotnet/sdk/issues"
+    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:
+# user_defined_os - $1
+get_normalized_os() {
+    eval $invocation
+
+    local osname="$(to_lowercase "$1")"
+    if [ ! -z "$osname" ]; then
+        case "$osname" in
+            osx | freebsd | rhel.6 | linux-musl | linux)
+                echo "$osname"
+                return 0
+                ;;
+            *)
+                say_err "'$user_defined_os' is not a supported value for --os option, supported values are: osx, linux, linux-musl, freebsd, rhel.6. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues."
+                return 1
+                ;;
+        esac
+    else
+        osname="$(get_current_os_name)" || return 1
+    fi
+    echo "$osname"
+    return 0
+}
+
 # The version text returned from the feeds is a 1-line or 2-line string:
 # For the SDK and the dotnet runtime (2 lines):
 # Line 1: # commit_hash
@@ -418,14 +409,12 @@ is_dotnet_package_installed() {
 # azure_feed - $1
 # channel - $2
 # normalized_architecture - $3
-# coherent - $4
 get_latest_version_info() {
     eval $invocation
 
     local azure_feed="$1"
     local channel="$2"
     local normalized_architecture="$3"
-    local coherent="$4"
 
     local version_file_url=null
     if [[ "$runtime" == "dotnet" ]]; then
@@ -433,11 +422,7 @@ get_latest_version_info() {
     elif [[ "$runtime" == "aspnetcore" ]]; then
         version_file_url="$uncached_feed/aspnetcore/Runtime/$channel/latest.version"
     elif [ -z "$runtime" ]; then
-        if [ "$coherent" = true ]; then
+         version_file_url="$uncached_feed/Sdk/$channel/latest.version"
-            version_file_url="$uncached_feed/Sdk/$channel/latest.coherent.version"
-        else
-            version_file_url="$uncached_feed/Sdk/$channel/latest.version"
-        fi
     else
         say_err "Invalid value for \$runtime"
         return 1
@@ -468,7 +453,6 @@ parse_jsonfile_for_version() {
     sdk_list=$(echo $sdk_section | awk -F"[{}]" '{print $2}')
     sdk_list=${sdk_list//[\" ]/}
     sdk_list=${sdk_list//,/$'\n'}
-    sdk_list="$(echo -e "${sdk_list}" | tr -d '[[:space:]]')"
 
     local version_info=""
     while read -r line; do
@@ -505,26 +489,16 @@ get_specific_version_from_version() {
     local json_file="$5"
 
     if [ -z "$json_file" ]; then
-        case "$version" in
+        if [[ "$version" == "latest" ]]; then
-            latest)
+            local version_info
-                local version_info
+            version_info="$(get_latest_version_info "$azure_feed" "$channel" "$normalized_architecture" false)" || return 1
-                version_info="$(get_latest_version_info "$azure_feed" "$channel" "$normalized_architecture" false)" || return 1
+            say_verbose "get_specific_version_from_version: version_info=$version_info"
-                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_version_info
+            return 0
-                return 0
+        else
-                ;;
+            echo "$version"
-            coherent)
+            return 0
-                local version_info
+        fi
-                version_info="$(get_latest_version_info "$azure_feed" "$channel" "$normalized_architecture" true)" || return 1
-                say_verbose "get_specific_version_from_version: version_info=$version_info"
-                echo "$version_info" | get_version_from_version_info
-                return 0
-                ;;
-            *)
-                echo "$version"
-                return 0
-                ;;
-        esac
     else
         local version_info
         version_info="$(parse_jsonfile_for_version "$json_file")" || return 1
@@ -538,6 +512,7 @@ get_specific_version_from_version() {
 # channel - $2
 # normalized_architecture - $3
 # specific_version - $4
+# normalized_os - $5
 construct_download_link() {
     eval $invocation
 
@@ -545,17 +520,16 @@ construct_download_link() {
     local channel="$2"
     local normalized_architecture="$3"
     local specific_version="${4//[$'\t\r\n']}"
-
+    local specific_product_version="$(get_specific_product_version "$1" "$4")"
-    local osname
+    local osname="$5"
-    osname="$(get_current_os_name)" || return 1
 
     local download_link=null
     if [[ "$runtime" == "dotnet" ]]; then
-        download_link="$azure_feed/Runtime/$specific_version/dotnet-runtime-$specific_version-$osname-$normalized_architecture.tar.gz"
+        download_link="$azure_feed/Runtime/$specific_version/dotnet-runtime-$specific_product_version-$osname-$normalized_architecture.tar.gz"
     elif [[ "$runtime" == "aspnetcore" ]]; then
-        download_link="$azure_feed/aspnetcore/Runtime/$specific_version/aspnetcore-runtime-$specific_version-$osname-$normalized_architecture.tar.gz"
+        download_link="$azure_feed/aspnetcore/Runtime/$specific_version/aspnetcore-runtime-$specific_product_version-$osname-$normalized_architecture.tar.gz"
     elif [ -z "$runtime" ]; then
-        download_link="$azure_feed/Sdk/$specific_version/dotnet-sdk-$specific_version-$osname-$normalized_architecture.tar.gz"
+        download_link="$azure_feed/Sdk/$specific_version/dotnet-sdk-$specific_product_version-$osname-$normalized_architecture.tar.gz"
     else
         return 1
     fi
@@ -564,6 +538,50 @@ construct_download_link() {
     return 0
 }
 
+# args:
+# azure_feed - $1
+# specific_version - $2
+get_specific_product_version() {
+    # If we find a 'productVersion.txt' at the root of any folder, we'll use its contents
+    # to resolve the version of what's in the folder, superseding the specified version.
+    eval $invocation
+
+    local azure_feed="$1"
+    local specific_version="${2//[$'\t\r\n']}"
+    local specific_product_version=$specific_version
+
+    local download_link=null
+    if [[ "$runtime" == "dotnet" ]]; then
+        download_link="$azure_feed/Runtime/$specific_version/productVersion.txt${feed_credential}"
+    elif [[ "$runtime" == "aspnetcore" ]]; then
+        download_link="$azure_feed/aspnetcore/Runtime/$specific_version/productVersion.txt${feed_credential}"
+    elif [ -z "$runtime" ]; then
+        download_link="$azure_feed/Sdk/$specific_version/productVersion.txt${feed_credential}"
+    else
+        return 1
+    fi
+
+    if machine_has "curl"
+    then
+        specific_product_version=$(curl -s --fail "$download_link")
+        if [ $? -ne 0 ]
+        then
+            specific_product_version=$specific_version
+        fi
+    elif machine_has "wget"
+    then
+        specific_product_version=$(wget -qO- "$download_link")
+        if [ $? -ne 0 ]
+        then
+            specific_product_version=$specific_version
+        fi
+    fi
+    specific_product_version="${specific_product_version//[$'\t\r\n']}"
+
+    echo "$specific_product_version"
+    return 0
+}
+
 # args:
 # azure_feed - $1
 # channel - $2
@@ -684,11 +702,31 @@ extract_dotnet_package() {
     find "$temp_out_path" -type f | grep -Ev "$folders_with_version_regex" | copy_files_or_dirs_from_list "$temp_out_path" "$out_path" "$override_non_versioned_files"
 
     rm -rf "$temp_out_path"
+    rm -f "$zip_path" && say_verbose "Temporary zip file $zip_path was removed"
 
     if [ "$failed" = true ]; then
         say_err "Extraction failed"
         return 1
     fi
+    return 0
+}
+
+get_http_header_curl() {
+    eval $invocation
+    local remote_path="$1"
+    remote_path_with_credential="${remote_path}${feed_credential}"
+    curl_options="-I -sSL --retry 5 --retry-delay 2 --connect-timeout 15 "
+    curl $curl_options "$remote_path_with_credential" || return 1
+    return 0
+}
+
+get_http_header_wget() {
+    eval $invocation
+    local remote_path="$1"
+    remote_path_with_credential="${remote_path}${feed_credential}"
+    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
 }
 
 # args:
@@ -706,13 +744,30 @@ download() {
     fi
 
     local failed=false
-    if machine_has "curl"; then
+    local attempts=0
-        downloadcurl "$remote_path" "$out_path" || failed=true
+    while [ $attempts -lt 3 ]; do
-    elif machine_has "wget"; then
+        attempts=$((attempts+1))
-        downloadwget "$remote_path" "$out_path" || failed=true
+        failed=false
-    else
+        if machine_has "curl"; then
-        failed=true
+            downloadcurl "$remote_path" "$out_path" || failed=true
-    fi
+        elif machine_has "wget"; then
+            downloadwget "$remote_path" "$out_path" || failed=true
+        else
+            say_err "Missing dependency: neither curl nor wget was found."
+            exit 1
+        fi
+
+        if [ "$failed" = false ] || [ $attempts -ge 3 ] || { [ ! -z $http_code ] && [ $http_code = "404" ]; }; then
+            break
+        fi
+
+        say "Download attempt #$attempts has failed: $http_code $download_error_msg"
+        say "Attempt #$((attempts+1)) will start in $((attempts*10)) seconds."
+        sleep $((attempts*20))
+    done
+
+
+
     if [ "$failed" = true ]; then
         say_verbose "Download failed: $remote_path"
         return 1
@@ -720,44 +775,60 @@ download() {
     return 0
 }
 
+# Updates global variables $http_code and $download_error_msg
 downloadcurl() {
     eval $invocation
+    unset http_code
+    unset download_error_msg
     local remote_path="$1"
     local out_path="${2:-}"
-
     # Append feed_credential as late as possible before calling curl to avoid logging feed_credential
-    remote_path="${remote_path}${feed_credential}"
+    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
     if [ -z "$out_path" ]; then
-        curl $curl_options "$remote_path" || failed=true
+        curl $curl_options "$remote_path_with_credential" || failed=true
     else
-        curl $curl_options -o "$out_path" "$remote_path" || failed=true
+        curl $curl_options -o "$out_path" "$remote_path_with_credential" || failed=true
     fi
     if [ "$failed" = true ]; then
-        say_verbose "Curl download failed"
+        local response=$(get_http_header_curl $remote_path_with_credential)
+        http_code=$( echo "$response" | awk '/^HTTP/{print $2}' | tail -1 )
+        download_error_msg="Unable to download $remote_path."
+        if  [[ $http_code != 2* ]]; then
+            download_error_msg+=" Returned HTTP status code: $http_code."
+        fi
+        say_verbose "$download_error_msg"
         return 1
     fi
     return 0
 }
 
+
+# Updates global variables $http_code and $download_error_msg
 downloadwget() {
     eval $invocation
+    unset http_code
+    unset download_error_msg
     local remote_path="$1"
     local out_path="${2:-}"
-
     # Append feed_credential as late as possible before calling wget to avoid logging feed_credential
-    remote_path="${remote_path}${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" || failed=true
+        wget -q $wget_options -O - "$remote_path_with_credential" || failed=true
     else
-        wget $wget_options -O "$out_path" "$remote_path" || failed=true
+        wget $wget_options -O "$out_path" "$remote_path_with_credential" || failed=true
     fi
     if [ "$failed" = true ]; then
-        say_verbose "Wget download failed"
+        local response=$(get_http_header_wget $remote_path_with_credential)
+        http_code=$( echo "$response" | awk '/^  HTTP/{print $2}' | tail -1 )
+        download_error_msg="Unable to download $remote_path."
+        if  [[ $http_code != 2* ]]; then
+            download_error_msg+=" Returned HTTP status code: $http_code."
+        fi
+        say_verbose "$download_error_msg"
         return 1
     fi
     return 0
@@ -770,14 +841,18 @@ calculate_vars() {
     normalized_architecture="$(get_normalized_architecture_from_architecture "$architecture")"
     say_verbose "normalized_architecture=$normalized_architecture"
 
+    normalized_os="$(get_normalized_os "$user_defined_os")"
+    say_verbose "normalized_os=$normalized_os"
+
     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")"
+    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
@@ -822,38 +897,74 @@ install_dotnet() {
     zip_path="$(mktemp "$temporary_file_template")"
     say_verbose "Zip path: $zip_path"
 
-    say "Downloading link: $download_link"
 
     # 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"
+
+    # 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 the download fails, download the legacy_download_link
     if [ "$download_failed" = true ]; then
-        say "Cannot download: $download_link"
+        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"
+
+            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
-                say "Cannot download: $download_link"
+                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
-        say_err "Could not find/download: \`$asset_name\` with version = $specific_version"
+        if [[ "$primary_path_http_code" = "404" && ( "$valid_legacy_download_link" = false || "$legacy_path_http_code" = "404") ]]; then
-        say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support"
+            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"
+        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
+        fi
         return 1
     fi
 
     say "Extracting zip from $download_link"
-    extract_dotnet_package "$zip_path" "$install_root"
+    extract_dotnet_package "$zip_path" "$install_root" || return 1
 
     #  Check if the SDK version is installed; if not, fail the installation.
     # if the version contains "RTM" or "servicing"; check if a 'release-type' SDK version is installed.
@@ -869,12 +980,14 @@ install_dotnet() {
     fi
 
     #  Check if the standard SDK version is installed.
-    say_verbose "Checking installation: version = $specific_version"
+    say_verbose "Checking installation: version = $specific_product_version"
-    if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$specific_version"; then
+    if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$specific_product_version"; then
         return 0
     fi
 
-    say_err "\`$asset_name\` with version = $specific_version failed to install with an unknown error."
+    # 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."
     return 1
 }
 
@@ -900,6 +1013,7 @@ runtime=""
 runtime_id=""
 override_non_versioned_files=true
 non_dynamic_parameters=""
+user_defined_os=""
 
 while [ $# -ne 0 ]
 do
@@ -921,6 +1035,10 @@ do
             shift
             architecture="$1"
             ;;
+        --os|-[Oo][SS])
+            shift
+            user_defined_os="$1"
+            ;;
         --shared-runtime|-[Ss]hared[Rr]untime)
             say_warning "The --shared-runtime flag is obsolete and may be removed in a future version of this script. The recommended usage is to specify '--runtime dotnet'."
             if [ -z "$runtime" ]; then
@@ -972,6 +1090,7 @@ do
             shift
             runtime_id="$1"
             non_dynamic_parameters+=" $name "\""$1"\"""
+            say_warning "Use of --runtime-id is obsolete and should be limited to the versions below 2.1. To override architecture, use --architecture option instead. To override OS, use --os option instead."
             ;;
         --jsonfile|-[Jj][Ss]on[Ff]ile)
             shift
@@ -1004,8 +1123,6 @@ do
             echo "      -Version"
             echo "          Possible values:"
             echo "          - latest - most latest build on specific channel"
-            echo "          - coherent - most latest coherent build on specific channel"
-            echo "              coherent applies only to SDK downloads"
             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 "  -i,--install-dir <DIR>             Install under specified location (see Install Location below)"
@@ -1013,6 +1130,11 @@ do
             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 "  --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."
+            echo "          Not supported for legacy links. Use --runtime-id to specify platform for legacy links."
+            echo "          Refer to: https://aka.ms/dotnet-os-lifecycle for more information."
             echo "  --runtime <RUNTIME>                Installs a shared runtime only, without the SDK."
             echo "      -Runtime"
             echo "          Possible values:"
@@ -1029,14 +1151,15 @@ do
             echo "  --no-cdn,-NoCdn                    Disable downloading from the Azure CDN, and use the uncached feed directly."
             echo "  --jsonfile <JSONFILE>              Determines the SDK version from a user specified global.json file."
             echo "                                     Note: global.json must have a value for 'SDK:Version'"
-            echo "  --runtime-id                       Installs the .NET Tools for the given platform (use linux-x64 for portable linux)."
-            echo "      -RuntimeId"
             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:"
@@ -1058,6 +1181,11 @@ 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."
+say "To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer.\n"
+
 check_min_reqs
 calculate_vars
 script_name=$(basename "$0")
@@ -1068,7 +1196,7 @@ if [ "$dry_run" = true ]; then
     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"\"""
+    repeatable_command="./$script_name --version "\""$specific_version"\"" --install-dir "\""$install_root"\"" --architecture "\""$normalized_architecture"\"" --os "\""$normalized_os"\"""
     if [[ "$runtime" == "dotnet" ]]; then
         repeatable_command+=" --runtime "\""dotnet"\"""
     elif [[ "$runtime" == "aspnetcore" ]]; then
@@ -1079,7 +1207,6 @@ if [ "$dry_run" = true ]; then
     exit 0
 fi
 
-check_pre_reqs
 install_dotnet
 
 bin_path="$(get_absolute_path "$(combine_paths "$install_root" "$bin_folder_relative_path")")"
@@ -1090,4 +1217,6 @@ else
     say "Binaries of dotnet can be found in $bin_path"
 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."

package.json

@@ -11,6 +11,13 @@
     "test": "jest",
     "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"
@@ -23,26 +30,29 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.2.2",
+    "@actions/core": "^1.2.6",
-    "@actions/exec": "^1.0.3",
+    "@actions/exec": "^1.0.4",
     "@actions/github": "^1.1.0",
     "@actions/http-client": "^1.0.8",
     "@actions/io": "^1.0.2",
-    "@actions/tool-cache": "^1.3.1",
     "fast-xml-parser": "^3.15.1",
     "semver": "^6.3.0",
     "xmlbuilder": "^13.0.2"
   },
   "devDependencies": {
-    "@types/jest": "^24.0.13",
+    "@types/jest": "^25.2.3",
-    "@types/node": "^12.0.4",
+    "@types/node": "^12.12.62",
-    "@types/semver": "^6.0.0",
+    "@types/semver": "^6.2.2",
-    "@zeit/ncc": "^0.21.0",
+    "@zeit/ncc": "^0.21.1",
-    "jest": "^26.0.1",
+    "husky": "^4.3.0",
-    "jest-circus": "^26.0.1",
+    "jest": "^26.4.2",
-    "prettier": "^1.17.1",
+    "jest-circus": "^26.4.2",
-    "ts-jest": "^26.0.0",
+    "prettier": "^1.19.1",
-    "typescript": "^3.9.2",
+    "ts-jest": "^26.4.0",
-    "wget-improved": "^3.0.2"
+    "typescript": "^3.9.7",
+    "wget-improved": "^3.2.1"
+  },
+  "jest": {
+    "testEnvironment": "node"
   }
 }

src/authutil.ts

@@ -4,18 +4,20 @@ 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,
-  existingFileLocation: string = ''
+  existingFileLocation: string = '',
+  processRoot: string = process.cwd()
 ) {
   const existingNuGetConfig: string = path.resolve(
-    process.env['RUNNER_TEMP'] || process.cwd(),
+    processRoot,
     existingFileLocation == '' ? 'nuget.config' : existingFileLocation
   );
 
   const tempNuGetConfig: string = path.resolve(
-    process.env['RUNNER_TEMP'] || process.cwd(),
+    processRoot,
     '../',
     'nuget.config'
   );

src/installer.ts

@@ -1,40 +1,26 @@
 // Load tempDirectory before it gets wiped by tool-cache
-let tempDirectory = process.env['RUNNER_TEMPDIRECTORY'] || '';
 import * as core from '@actions/core';
 import * as exec from '@actions/exec';
 import * as io from '@actions/io';
-import * as tc from '@actions/tool-cache';
 import hc = require('@actions/http-client');
 import {chmodSync} from 'fs';
-import * as os from 'os';
 import * as path from 'path';
+import {ExecOptions} from '@actions/exec/lib/interfaces';
 import * as semver from 'semver';
 
 const IS_WINDOWS = process.platform === 'win32';
 
-if (!tempDirectory) {
-  let baseLocation;
-  if (IS_WINDOWS) {
-    // On windows use the USERPROFILE env variable
-    baseLocation = process.env['USERPROFILE'] || 'C:\\';
-  } else {
-    if (process.platform === 'darwin') {
-      baseLocation = '/Users';
-    } else {
-      baseLocation = '/home';
-    }
-  }
-  tempDirectory = path.join(baseLocation, 'actions', 'temp');
-}
-
 /**
  * Represents the inputted version information
  */
 export class DotNetVersionInfo {
+  public inputVersion: string;
   private fullversion: string;
   private isExactVersionSet: boolean = false;
 
   constructor(version: string) {
+    this.inputVersion = version;
+
     // Check for exact match
     if (semver.valid(semver.clean(version) || '') != null) {
       this.fullversion = semver.clean(version) as string;
@@ -89,91 +75,54 @@ export class DotNetVersionInfo {
   }
 }
 
-/**
- * Represents a resolved version from the Web-Api
- */
-class ResolvedVersionInfo {
-  downloadUrls: string[];
-  resolvedVersion: string;
-
-  constructor(downloadUrls: string[], resolvedVersion: string) {
-    if (downloadUrls.length === 0) {
-      throw 'DownloadUrls can not be empty';
-    }
-
-    if (!resolvedVersion) {
-      throw 'Resolved version is invalid';
-    }
-
-    this.downloadUrls = downloadUrls;
-    this.resolvedVersion = resolvedVersion;
-  }
-}
-
 export class DotnetCoreInstaller {
   constructor(version: string) {
-    this.versionInfo = new DotNetVersionInfo(version);
+    this.version = version;
-    this.cachedToolName = 'dncs';
-    this.arch = 'x64';
   }
 
   public async installDotnet() {
-    // Check cache
-    let toolPath: string = '';
-    let osSuffixes = await this.detectMachineOS();
-    let parts = osSuffixes[0].split('-');
-    if (parts.length > 1) {
-      this.arch = parts[1];
-    }
-
-    // If version is not generic -> look up cache
-    if (this.versionInfo.isExactVersion())
-      toolPath = this.getLocalTool(this.versionInfo.version());
-
-    if (!toolPath) {
-      // download, extract, cache
-      console.log('Getting a download url', this.versionInfo.version());
-      let resolvedVersionInfo = await this.resolveInfos(
-        osSuffixes,
-        this.versionInfo
-      );
-
-      //Check if cache exists for resolved version
-      toolPath = this.getLocalTool(resolvedVersionInfo.resolvedVersion);
-      if (!toolPath) {
-        //If not exists install it
-        toolPath = await this.downloadAndInstall(resolvedVersionInfo);
-      } else {
-        console.log('Using cached tool');
-      }
-    } else {
-      console.log('Using cached tool');
-    }
-
-    // Need to set this so that .NET Core global tools find the right locations.
-    core.exportVariable('DOTNET_ROOT', toolPath);
-
-    // Prepend the tools path. instructs the agent to prepend for future tasks
-    core.addPath(toolPath);
-  }
-
-  private getLocalTool(version: string): string {
-    console.log('Checking tool cache', version);
-    return tc.find(this.cachedToolName, version, this.arch);
-  }
-
-  private async detectMachineOS(): Promise<string[]> {
-    let osSuffix: string[] = [];
     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', 'get-os-platform.ps1')
+        .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}"`,
         [
@@ -186,98 +135,68 @@ export class DotnetCoreInstaller {
           '-Command',
           command
         ],
-        {
+        options
-          listeners: {
-            stdout: (data: Buffer) => {
-              output += data.toString();
-            }
-          }
-        }
       );
     } else {
-      let scriptPath = path.join(
+      let escapedScript = path
-        __dirname,
+        .join(__dirname, '..', 'externals', 'install-dotnet.sh')
-        '..',
+        .replace(/'/g, "''");
-        'externals',
+      chmodSync(escapedScript, '777');
-        'get-os-distro.sh'
-      );
-      chmodSync(scriptPath, '777');
 
-      const toolPath = await io.which(scriptPath, true);
+      const scriptPath = await io.which(escapedScript, true);
-      resultCode = await exec.exec(`"${toolPath}"`, [], {
+
+      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
       });
     }
 
-    if (resultCode != 0) {
+    if (process.env['DOTNET_INSTALL_DIR']) {
-      throw `Failed to detect os with result code ${resultCode}. Output: ${output}`;
+      core.addPath(process.env['DOTNET_INSTALL_DIR']);
-    }
+      core.exportVariable('DOTNET_ROOT', process.env['DOTNET_INSTALL_DIR']);
-
+    } else {
-    let index;
+      if (IS_WINDOWS) {
-    if ((index = output.indexOf('Primary:')) >= 0) {
+        // This is the default set in install-dotnet.ps1
-      let primary = output.substr(index + 'Primary:'.length).split(os.EOL)[0];
+        core.addPath(
-      osSuffix.push(primary);
+          path.join(process.env['LocalAppData'] + '', 'Microsoft', 'dotnet')
-    }
+        );
-
+        core.exportVariable(
-    if ((index = output.indexOf('Legacy:')) >= 0) {
+          'DOTNET_ROOT',
-      let legacy = output.substr(index + 'Legacy:'.length).split(os.EOL)[0];
+          path.join(process.env['LocalAppData'] + '', 'Microsoft', 'dotnet')
-      osSuffix.push(legacy);
+        );
-    }
+      } else {
-
+        // This is the default set in install-dotnet.sh
-    if (osSuffix.length == 0) {
+        core.addPath(path.join(process.env['HOME'] + '', '.dotnet'));
-      throw 'Could not detect platform';
+        core.exportVariable(
-    }
+          'DOTNET_ROOT',
-
+          path.join(process.env['HOME'] + '', '.dotnet')
-    return osSuffix;
+        );
-  }
-
-  private async downloadAndInstall(resolvedVersionInfo: ResolvedVersionInfo) {
-    let downloaded = false;
-    let downloadPath = '';
-    for (const url of resolvedVersionInfo.downloadUrls) {
-      try {
-        downloadPath = await tc.downloadTool(url);
-        downloaded = true;
-        break;
-      } catch (error) {
-        console.log('Could not Download', url, JSON.stringify(error));
       }
     }
 
-    if (!downloaded) {
+    console.log(process.env['PATH']);
-      throw 'Failed to download package';
+
+    if (resultCode != 0) {
+      throw `Failed to install dotnet ${resultCode}. ${output}`;
     }
-
-    // extract
-    console.log('Extracting Package', downloadPath);
-    let extPath: string = IS_WINDOWS
-      ? await tc.extractZip(downloadPath)
-      : await tc.extractTar(downloadPath);
-
-    // cache tool
-    console.log('Caching tool');
-    let cachedDir = await tc.cacheDir(
-      extPath,
-      this.cachedToolName,
-      resolvedVersionInfo.resolvedVersion,
-      this.arch
-    );
-
-    console.log('Successfully installed', resolvedVersionInfo.resolvedVersion);
-    return cachedDir;
   }
 
-  // OsSuffixes - The suffix which is a part of the file name ex- linux-x64, windows-x86
-  // Type - SDK / Runtime
   // versionInfo - versionInfo of the SDK/Runtime
-  async resolveInfos(
+  async resolveVersion(versionInfo: DotNetVersionInfo): Promise<string> {
-    osSuffixes: string[],
+    if (versionInfo.isExactVersion()) {
-    versionInfo: DotNetVersionInfo
+      return versionInfo.version();
-  ): Promise<ResolvedVersionInfo> {
+    }
+
     const httpClient = new hc.HttpClient('actions/setup-dotnet', [], {
       allowRetries: true,
       maxRetries: 3
@@ -305,67 +224,23 @@ export class DotnetCoreInstaller {
     });
 
     // Exclude versions that are newer than the latest if using not exact
-    if (!versionInfo.isExactVersion()) {
+    let latestSdk: string = releasesResult['latest-sdk'];
-      let latestSdk: string = releasesResult['latest-sdk'];
 
-      releasesInfo = releasesInfo.filter((releaseInfo: any) =>
+    releasesInfo = releasesInfo.filter((releaseInfo: any) =>
-        semver.lte(releaseInfo['sdk']['version'], latestSdk)
+      semver.lte(releaseInfo['sdk']['version'], latestSdk)
-      );
+    );
-    }
 
     // Sort for latest version
     releasesInfo = releasesInfo.sort((a, b) =>
       semver.rcompare(a['sdk']['version'], b['sdk']['version'])
     );
 
-    let downloadedVersion: string = '';
+    if (releasesInfo.length == 0) {
-    let downloadUrls: string[] = [];
+      throw `Could not find dotnet core version. Please ensure that specified version ${versionInfo.inputVersion} is valid.`;
-
-    if (releasesInfo.length != 0) {
-      let release = releasesInfo[0];
-
-      downloadedVersion = release['sdk']['version'];
-
-      let files: any[] = release['sdk']['files'];
-      files = files.filter((file: any) => {
-        if (file['rid'] == osSuffixes[0] || file['rid'] == osSuffixes[1]) {
-          return (
-            file['url'].endsWith('.zip') || file['url'].endsWith('.tar.gz')
-          );
-        }
-      });
-
-      if (files.length > 0) {
-        files.forEach((file: any) => {
-          downloadUrls.push(file['url']);
-        });
-      } else {
-        throw `The specified version's download links are not correctly formed in the supported versions document => ${releasesJsonUrl}`;
-      }
-    } else {
-      console.log(
-        `Could not fetch download information for version ${versionInfo.version()}`
-      );
-
-      if (versionInfo.isExactVersion()) {
-        console.log('Using fallback');
-
-        downloadUrls = await this.getFallbackDownloadUrls(
-          versionInfo.version()
-        );
-        downloadedVersion = versionInfo.version();
-      } else {
-        console.log('Unable to use fallback, version is generic!');
-      }
     }
 
-    if (downloadUrls.length == 0) {
+    let release = releasesInfo[0];
-      throw `Could not construct download URL. Please ensure that specified version ${versionInfo.version()}/${downloadedVersion} is valid.`;
+    return release['sdk']['version'];
-    }
-
-    core.debug(`Got download urls ${downloadUrls}`);
-
-    return new ResolvedVersionInfo(downloadUrls, downloadedVersion);
   }
 
   private async getReleasesJsonUrl(
@@ -375,124 +250,29 @@ export class DotnetCoreInstaller {
     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') {
+      if (
+        versionParts.length >= 2 &&
+        !(versionParts[1] == 'x' || versionParts[1] == '*')
+      ) {
         return versionParts[0] == sdkParts[0] && versionParts[1] == sdkParts[1];
       }
       return versionParts[0] == sdkParts[0];
     });
+
     if (releasesInfo.length === 0) {
       throw `Could not find info for version ${versionParts.join(
         '.'
       )} at ${DotNetCoreIndexUrl}`;
     }
+
     return releasesInfo[0]['releases.json'];
   }
 
-  private async getFallbackDownloadUrls(version: string): Promise<string[]> {
+  private version: string;
-    let primaryUrlSearchString: string;
-    let legacyUrlSearchString: string;
-    let output = '';
-    let resultCode = 0;
-
-    if (IS_WINDOWS) {
-      let escapedScript = path
-        .join(__dirname, '..', 'externals', 'install-dotnet.ps1')
-        .replace(/'/g, "''");
-      let command = `& '${escapedScript}' -Version ${version} -DryRun`;
-
-      const powershellPath = await io.which('powershell', true);
-      resultCode = await exec.exec(
-        `"${powershellPath}"`,
-        [
-          '-NoLogo',
-          '-Sta',
-          '-NoProfile',
-          '-NonInteractive',
-          '-ExecutionPolicy',
-          'Unrestricted',
-          '-Command',
-          command
-        ],
-        {
-          listeners: {
-            stdout: (data: Buffer) => {
-              output += data.toString();
-            }
-          }
-        }
-      );
-
-      primaryUrlSearchString = 'dotnet-install: Primary named payload URL: ';
-      legacyUrlSearchString = 'dotnet-install: Legacy named payload URL: ';
-    } else {
-      let escapedScript = path
-        .join(__dirname, '..', 'externals', 'install-dotnet.sh')
-        .replace(/'/g, "''");
-      chmodSync(escapedScript, '777');
-
-      const scriptPath = await io.which(escapedScript, true);
-      resultCode = await exec.exec(
-        `"${scriptPath}"`,
-        ['--version', version, '--dry-run'],
-        {
-          listeners: {
-            stdout: (data: Buffer) => {
-              output += data.toString();
-            }
-          }
-        }
-      );
-
-      primaryUrlSearchString = 'dotnet-install: Primary named payload URL: ';
-      legacyUrlSearchString = 'dotnet-install: Legacy named payload URL: ';
-    }
-
-    if (resultCode != 0) {
-      throw `Failed to get download urls with result code ${resultCode}. ${output}`;
-    }
-
-    let primaryUrl: string = '';
-    let legacyUrl: string = '';
-    if (!!output && output.length > 0) {
-      let lines: string[] = output.split(os.EOL);
-
-      // Fallback to \n if initial split doesn't work (not consistent across versions)
-      if (lines.length === 1) {
-        lines = output.split('\n');
-      }
-      if (!!lines && lines.length > 0) {
-        lines.forEach((line: string) => {
-          if (!line) {
-            return;
-          }
-          var primarySearchStringIndex = line.indexOf(primaryUrlSearchString);
-          if (primarySearchStringIndex > -1) {
-            primaryUrl = line.substring(
-              primarySearchStringIndex + primaryUrlSearchString.length
-            );
-            return;
-          }
-
-          var legacySearchStringIndex = line.indexOf(legacyUrlSearchString);
-          if (legacySearchStringIndex > -1) {
-            legacyUrl = line.substring(
-              legacySearchStringIndex + legacyUrlSearchString.length
-            );
-            return;
-          }
-        });
-      }
-    }
-
-    return [primaryUrl, legacyUrl];
-  }
-
-  private versionInfo: DotNetVersionInfo;
-  private cachedToolName: string;
-  private arch: string;
 }
 
 const DotNetCoreIndexUrl: string =

src/setup-dotnet.ts

@@ -7,13 +7,13 @@ import * as auth from './authutil';
 export async function run() {
   try {
     //
-    // Version is optional.  If supplied, install / use from the tool cache
+    // dotnet-version is optional, but needs to be provided for most use cases.
-    // If not supplied then task is still used to setup proxy, auth, etc...
+    // If supplied, install / use from the tool cache.
+    // 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: string = core.getInput('version');
+    let version = core.getInput('dotnet-version');
-    if (!version) {
-      version = core.getInput('dotnet-version');
-    }
     if (!version) {
       // Try to fall back to global.json
       core.debug('No version found, trying to find version from global.json');