dotnet-installer/.vsts-ci.yml

trigger:
  batch: true
  branches:
    include:
    - main
    - master
    - release/*
    - internal/release/3.*
    - internal/release/5.*
    - internal/release/6.*

variables:
- name: _PublishUsingPipelines
  value: false
- name: PostBuildSign
  value: true
- ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
  - group: DotNet-DotNetCli-Storage
  - group: DotNet-Blob-Feed
  - group: DotNet-Installer-SDLValidation-Params
  - name: _PublishUsingPipelines
    value: true

# Default to running tests in PRs and public CI, but not in official builds
- name: _WindowsTestArg
  value: '-test'
- name: _NonWindowsTestArg
  value: '--test'
- ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
  - name: _WindowsTestArg
    value: ''
  - name: _NonWindowsTestArg
    value: ''

- name: _InternalRuntimeDownloadArgs
  value: ''

- ${{ if eq(variables['System.TeamProject'], 'internal') }}:
  - group: DotNet-MSRC-Storage
  - name: _InternalRuntimeDownloadArgs
    value: /p:DotNetRuntimeSourceFeed=https://dotnetclimsrc.blob.core.windows.net/dotnet
      /p:DotNetRuntimeSourceFeedKey=$(dotnetclimsrc-read-sas-token-base64)

stages:
- stage: build
  jobs:
  - job: Publish_Build_Configuration
    steps:
    - publish: $(Build.SourcesDirectory)\eng\BuildConfiguration
      artifact: BuildConfiguration
      displayName: Publish Build Config
  - template: /eng/build.yml
    parameters:
      agentOs: Windows_NT
      pool:
        ${{ if eq(variables['System.TeamProject'], 'public') }}:
          name: NetCorePublic-Pool
          queue: buildpool.windows.10.amd64.vs2019.open
        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
          name: NetCoreInternal-Pool
          queue: buildpool.windows.10.amd64.vs2019
      timeoutInMinutes: 180
      strategy:
        matrix:
          # Public-only builds
          ${{ if or(eq(variables['System.TeamProject'], 'public'), in(variables['Build.Reason'], 'PullRequest')) }}:
            Build_Debug_x86:
              _BuildConfig: Debug
              _BuildArchitecture: x86
              _DOTNET_CLI_UI_LANGUAGE: ''
              _AdditionalBuildParameters: ''
              _TestArg: $(_WindowsTestArg)
            Build_ES_Debug_x64:
              _BuildConfig: Debug
              _BuildArchitecture: x64
              _DOTNET_CLI_UI_LANGUAGE: es
              _AdditionalBuildParameters: ''
              _TestArg: $(_WindowsTestArg)
          # Internal-only builds
          ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
            Build_Release_x86:
              _BuildConfig: Release
              _BuildArchitecture: x86
              _DOTNET_CLI_UI_LANGUAGE: ''
              _AdditionalBuildParameters: ''
              _TestArg: $(_WindowsTestArg)
          # Always run builds
          Build_Release_x64:
            _BuildConfig: Release
            _BuildArchitecture: x64
            _DOTNET_CLI_UI_LANGUAGE: ''
            _AdditionalBuildParameters: '/p:PublishInternalAsset=true'
            _TestArg: $(_WindowsTestArg)
          Build_Release_arm:
            _BuildConfig: Release
            _BuildArchitecture: arm
            _DOTNET_CLI_UI_LANGUAGE: ''
            _AdditionalBuildParameters: ''
            # Never run tests on arm64
            _TestArg: ''
          Build_Release_arm64:
            _BuildConfig: Release
            _BuildArchitecture: arm64
            _DOTNET_CLI_UI_LANGUAGE: ''
            _AdditionalBuildParameters: ''
            # Never run tests on arm64
            _TestArg: ''

  - template: /eng/build.yml
    parameters:
      agentOs: Windows_NT
      pool:
        ${{ if eq(variables['System.TeamProject'], 'public') }}:
          name: NetCorePublic-Pool
          queue: buildpool.windows.10.amd64.vs2019.open
        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
          name: NetCoreInternal-Pool
          queue: buildpool.windows.10.amd64.vs2019
      timeoutInMinutes: 180
      strategy:
        matrix:
          # Always run builds
          Build_Release_x64:
            _BuildConfig: Release
            _BuildArchitecture: x64
            _DOTNET_CLI_UI_LANGUAGE: ''
            _AdditionalBuildParameters: '/p:PublishInternalAsset=true'
            # Never run tests on PGO bits
            _TestArg: ''
          Build_Release_x86:
            _BuildConfig: Release
            _BuildArchitecture: x86
            _DOTNET_CLI_UI_LANGUAGE: ''
            _AdditionalBuildParameters: ''
            _TestArg: ''
      pgoInstrument: true

  - template: /eng/build.yml
    parameters:
      agentOs: Linux
      pool:
        ${{ if eq(variables['System.TeamProject'], 'public') }}:
          name: NetCorePublic-Pool
          queue: BuildPool.Ubuntu.1604.Amd64.Open
        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
          name: NetCoreInternal-Pool
          queue: BuildPool.Ubuntu.1604.Amd64
      timeoutInMinutes: 180
      strategy:
        matrix:
          ${{ if or(eq(variables['System.TeamProject'], 'public'), in(variables['Build.Reason'], 'PullRequest')) }}:
            Build_Ubuntu_16_04_Debug_x64:
              _BuildConfig: Debug
              _DockerParameter: '--docker ubuntu.16.04'
              _LinuxPortable: ''
              _RuntimeIdentifier: ''
              _BuildArchitecture: 'x64'
              _TestArg: $(_NonWindowsTestArg)
            Build_Ubuntu_18_04_Debug_x64:
              _BuildConfig: Debug
              _DockerParameter: '--docker ubuntu.18.04'
              _LinuxPortable: '--linux-portable'
              _RuntimeIdentifier: ''
              _BuildArchitecture: 'x64'
              _TestArg: $(_NonWindowsTestArg)
            Build_Fedora_29_Debug_x64:
              _BuildConfig: Debug
              _DockerParameter: '--docker fedora.29'
              _LinuxPortable: '--linux-portable'
              _RuntimeIdentifier: ''
              _BuildArchitecture: 'x64'
              _TestArg: $(_NonWindowsTestArg)
            Build_CentOS_7_1_Debug_x64:
              _BuildConfig: Debug
              _DockerParameter: '--docker centos'
              _LinuxPortable: ''
              _RuntimeIdentifier: ''
              _BuildArchitecture: 'x64'
              _TestArg: $(_NonWindowsTestArg)
            Build_Debian_Stretch_Debug_x64:
              _BuildConfig: Debug
              _DockerParameter: '--docker debian'
              _LinuxPortable: ''
              _RuntimeIdentifier: ''
              _BuildArchitecture: 'x64'
              _TestArg: $(_NonWindowsTestArg)
            Build_Rhel_7_2_Release_x64:
              _BuildConfig: Release
              _DockerParameter: '--docker rhel'
              _LinuxPortable: ''
              _RuntimeIdentifier: ''
              _BuildArchitecture: 'x64'
              _TestArg: $(_NonWindowsTestArg)
            Build_Arm_Debug:
              _BuildConfig: Debug
              _DockerParameter: ''
              _LinuxPortable: '--linux-portable'
              _RuntimeIdentifier: '--runtime-id linux-arm'
              _BuildArchitecture: 'arm'
              # Never run tests on arm
              _TestArg: ''
            Build_Arm64_Debug:
              _BuildConfig: Debug
              _DockerParameter: ''
              _LinuxPortable: '--linux-portable'
              _RuntimeIdentifier: '--runtime-id linux-arm64'
              _BuildArchitecture: 'arm64'
              # Never run tests on arm64
              _TestArg: ''
            Build_Linux_musl_Debug_arm:
              _BuildConfig: Debug
              # linux-musl-arm cross gen depends on glibc 2.27 (this OS has it)
              _DockerParameter: '--docker ubuntu.18.04'
              _LinuxPortable: ''
              _RuntimeIdentifier: '--runtime-id linux-musl-arm'
              _BuildArchitecture: 'arm'
              _AdditionalBuildParameters: '/p:OSName="linux-musl"'
              # Never run tests on arm
              _TestArg: ''
            Build_Linux_musl_Debug_arm64:
              _BuildConfig: Debug
              _DockerParameter: ''
              _LinuxPortable: ''
              _RuntimeIdentifier: '--runtime-id linux-musl-arm64'
              _BuildArchitecture: 'arm64'
              _AdditionalBuildParameters: '/p:OSName="linux-musl"'
              # Never run tests on arm64
              _TestArg: ''
            Build_Linux_musl_Debug_x64:
              _BuildConfig: Debug
              _DockerParameter: '--docker alpine.3.13'
              _LinuxPortable: ''
              _RuntimeIdentifier: '--runtime-id linux-musl-x64'
              _BuildArchitecture: 'x64'
              # Pass in HostOSName when running on alpine
              _AdditionalBuildParameters: '/p:HostOSName="linux-musl"'
              _TestArg: $(_NonWindowsTestArg)
          ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
            Build_Arm_Release:
              _BuildConfig: Release
              _DockerParameter: ''
              _LinuxPortable: '--linux-portable'
              _RuntimeIdentifier: '--runtime-id linux-arm'
              _BuildArchitecture: 'arm'
              # Never run tests on arm
              _TestArg: ''
            Build_Arm64_Release:
              _BuildConfig: Release
              _DockerParameter: ''
              _LinuxPortable: '--linux-portable'
              _RuntimeIdentifier: '--runtime-id linux-arm64'
              _BuildArchitecture: 'arm64'
              # Never run tests on arm64
              _TestArg: ''
            Build_Linux_musl_Release_arm:
              _BuildConfig: Release
              # linux-musl-arm cross gen depends on glibc 2.27 (this OS has it)
              _DockerParameter: '--docker ubuntu.18.04'
              _LinuxPortable: ''
              _RuntimeIdentifier: '--runtime-id linux-musl-arm'
              _BuildArchitecture: 'arm'
              _AdditionalBuildParameters: '/p:OSName="linux-musl"'
              # Never run tests on arm
              _TestArg: ''
            Build_Linux_musl_Release_arm64:
              _BuildConfig: Release
              _DockerParameter: ''
              _LinuxPortable: ''
              _RuntimeIdentifier: '--runtime-id linux-musl-arm64'
              _BuildArchitecture: 'arm64'
              _AdditionalBuildParameters: '/p:OSName="linux-musl"'
              # Never run tests on arm64
              _TestArg: ''
            Build_Linux_musl_Release_x64:
              _BuildConfig: Release
              _DockerParameter: '--docker alpine.3.13'
              _LinuxPortable: ''
              _RuntimeIdentifier: '--runtime-id linux-musl-x64'
              _BuildArchitecture: 'x64'
              # Pass in HostOSName when running on alpine
              _AdditionalBuildParameters: '/p:HostOSName="linux-musl"'
            Build_Linux_Portable_Deb_Release_x64:
              _BuildConfig: Release
              _DockerParameter: '--docker ubuntu.16.04'
              _LinuxPortable: '--linux-portable'
              _RuntimeIdentifier: ''
              _BuildArchitecture: 'x64'
              # Do not publish zips and tarballs. The linux-x64 binaries are
              # already published by Build_LinuxPortable_Release_x64
              _AdditionalBuildParameters: '/p:PublishBinariesAndBadge=false'
              _TestArg: $(_NonWindowsTestArg)
            Build_Linux_Portable_Rpm_Release_x64:
              _BuildConfig: Release
              _DockerParameter: '--docker rhel'
              _LinuxPortable: '--linux-portable'
              _RuntimeIdentifier: ''
              _BuildArchitecture: 'x64'
              # Do not publish zips and tarballs. The linux-x64 binaries are
              # already published by Build_LinuxPortable_Release_x64
              _AdditionalBuildParameters: '/p:PublishBinariesAndBadge=false'
              _TestArg: $(_NonWindowsTestArg)
          Build_LinuxPortable_Release_x64:
            _BuildConfig: Release
            _DockerParameter: ''
            _LinuxPortable: '--linux-portable'
            _RuntimeIdentifier: ''
            _BuildArchitecture: 'x64'
            _TestArg: $(_NonWindowsTestArg)

  - template: /eng/build.yml
    parameters:
      agentOs: Linux
      pool:
        ${{ if eq(variables['System.TeamProject'], 'public') }}:
          name: NetCorePublic-Pool
          queue: BuildPool.Ubuntu.1604.Amd64.Open
        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
          name: NetCoreInternal-Pool
          queue: BuildPool.Ubuntu.1604.Amd64
      timeoutInMinutes: 180
      strategy:
        matrix:
          # Always run builds
          Build_LinuxPortable_Release_x64:
            _BuildConfig: Release
            _DockerParameter: ''
            _LinuxPortable: '--linux-portable'
            _RuntimeIdentifier: ''
            _BuildArchitecture: 'x64'
            _TestArg: ''
      pgoInstrument: true

  - template: /eng/build.yml
    parameters:
      agentOs: Darwin
      pool:
        vmImage: 'macOS-10.15'
      timeoutInMinutes: 180
      strategy:
        matrix:
          Build_Release_x64:
            _BuildConfig: Release
            _RuntimeIdentifier: ''
            _BuildArchitecture: 'x64'
            _TestArg: $(_NonWindowsTestArg)
          Build_Release_arm64:
            _BuildConfig: Release
            _RuntimeIdentifier: '--runtime-id osx-arm64'
            _BuildArchitecture: 'arm64'
            # Never run tests on arm64
            _TestArg: ''

  - template: /eng/common/templates/jobs/source-build.yml

  - template: /src/SourceBuild/Arcade/eng/common/templates/job/source-build-create-tarball.yml

  - template: /src/SourceBuild/Arcade/eng/common/templates/job/source-build-run-tarball-build.yml
    parameters:
      dependsOn: Source_Build_Create_Tarball
      condition: eq(dependencies.Source_Build_Create_Tarball.outputs['Tarball_Build_Check._includeTarballBuild'], 'true')

  # https://github.com/dotnet/core-sdk/issues/248
  # - template: /eng/build.yml
  #   parameters:
  #     agentOs: FreeBSD
  #     queue:
  #       name: dnceng-freebsd-internal
  #       timeoutInMinutes: 180
  #       matrix:
  #         Build_Release:
  #           _BuildConfig: Release
  #           _BuildArchitecture: 'x64'
  #           _AdditionalBuildParameters: '/p:DisableSourceLink=true /p:DISABLE_CROSSGEN=true'

  - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
    - template: /eng/common/templates/job/publish-build-assets.yml
      parameters:
        dependsOn:
          - Windows_NT
          - Linux
          - Darwin
          - Source_Build_Managed
          - Source_Build_Create_Tarball
        publishUsingPipelines: true
        pool:
          vmImage: vs2017-win2016

- ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
  - template: eng\common\templates\post-build\post-build.yml
    parameters:
      publishingInfraVersion: 3
      enableSymbolValidation: false
      enableSigningValidation: false
      enableNugetValidation: false
      enableSourceLinkValidation: false
      publishInstallersAndChecksums: true
      SDLValidationParameters:
        enable: false
        params: ' -SourceToolsList @("policheck","credscan")
        -TsaInstanceURL $(_TsaInstanceURL)
        -TsaProjectName $(_TsaProjectName)
        -TsaNotificationEmail $(_TsaNotificationEmail)
        -TsaCodebaseAdmin $(_TsaCodebaseAdmin)
        -TsaBugAreaPath $(_TsaBugAreaPath)
        -TsaIterationPath $(_TsaIterationPath)
        -TsaRepositoryName "dotnet-installer"
        -TsaCodebaseName "dotnet-installer"
        -TsaPublish $True'