dotnet-installer/eng/pipelines/templates/jobs/vmr-build.yml

### This job source-builds https://github.com/dotnet/dotnet with given parameters
### If run in a PR, new changes are applied to a local copy of the VMR, then it is source-built and tested

parameters:
- name: isBuiltFromVmr
  displayName: True when build is running from dotnet/dotnet directly
  type: boolean

- name: vmrPath
  type: string
  default: $(Agent.BuildDirectory)/vmr

- name: vmrBranch
  displayName: dotnet/dotnet branch to use
  type: string
  default: $(Build.SourceBranchName)

- name: buildName
  type: string

- name: architecture
  type: string

- name: container
  type: string

- name: pool
  type: object

# Allow downloading artifacts from the internet during the build
- name: runOnline
  type: boolean

# Skip running the SDK content smoke-tests
- name: excludeSdkContentTests
  type: boolean
  default: false

# Name of a previous job (from the same template as this) whose output will be used to build this job
# The SDK from its artifacts is copied to vmr/.dotnet
- name: reuseBuildArtifactsFrom
  type: string
  default: ''

- name: excludeOmniSharpTests
  type: boolean

- name: bootstrapPrep
  type: boolean

- name: enablePoison
  type: boolean

# Instead of building the VMR directly, exports the sources into a tarball and builds from that
- name: buildFromArchive
  type: boolean

# Some distros like CentOS Stream 9 use OpenSSL 3.0 which disables SHA1 signing.
# This option overrides that default configuration and enables it. See https://github.com/dotnet/installer/pull/15289
- name: overrideDistroDisablingSha1
  type: boolean
  default: false

jobs:
- job: ${{ parameters.buildName }}_${{ parameters.architecture }}
  timeoutInMinutes: 150
  pool: ${{ parameters.pool }}
  ${{ if ne(parameters.reuseBuildArtifactsFrom, '') }}:
    # Always attempt to run the bootstrap leg (e.g. even when stage 1 tests fail) in order to get a complete accessment of the build status.
    # The build shortcuts when stage 1 build fails and doesn't produce the SDK.
    condition: succeededOrFailed()
    dependsOn: ${{ parameters.reuseBuildArtifactsFrom }}_${{ parameters.architecture }}
  variables:
  - template: /eng/common/templates/variables/pool-providers.yml
  - ${{ if eq(variables['System.TeamProject'], 'internal') }}:
    - group: AzureDevOps-Artifact-Feeds-Pats
  - ${{ if and(not(parameters.isBuiltFromVmr), eq(variables['System.TeamProject'], 'internal')) }}:
    - group: DotNetBot-GitHub
  - ${{ else }}:
    - name: BotAccount-dotnet-bot-repo-PAT
      value: N/A
  - ${{ if eq(parameters.reuseBuildArtifactsFrom, '') }}:
    - name: additionalBuildArgs
      value: ''
  - ${{ else }}:
    - name: additionalBuildArgs
      value: ' --with-sdk /vmr/.dotnet'

  # Location of the VMR sources
  # We either build the repo directly, or we extract them outside (which is what partners do)
  - ${{ if parameters.buildFromArchive }}:
    - name: sourcesPath
      value: $(Build.StagingDirectory)/dotnet-sources/
  - ${{ else }}:
    - name: sourcesPath
      value: ${{ parameters.vmrPath }}

  steps:
  - template: ../steps/vmr-prepare.yml
    parameters:
      vmrBranch: ${{ parameters.vmrBranch }}
      isBuiltFromVmr: ${{ parameters.isBuiltFromVmr }}
      skipComponentGovernanceDetection: true

  # Synchronize new content in the VMR during PRs (we expect this to come
  - ${{ if and(not(parameters.isBuiltFromVmr), eq(variables['Build.Reason'], 'PullRequest')) }}:
    - template: ../steps/vmr-pull-updates.yml
      parameters:
        vmrPath: ${{ parameters.vmrPath }}
        vmrBranch: ${{ parameters.vmrBranch }}
        targetRef: $(Build.SourceVersion) # Synchronize the current installer commit

  - ${{ if parameters.buildFromArchive }}:
    - script: |
        set -ex
        "${{ parameters.vmrPath }}/eng/pack-sources.sh" -o "$(Build.StagingDirectory)/dotnet-sources.tar.gz"
        tar -xf dotnet-sources.tar.gz
        mv "dotnet-$(Build.SourceVersion)" "$(sourcesPath)"        
      displayName: Export VMR sources
      workingDirectory: $(Build.StagingDirectory)

  - ${{ if ne(variables['System.TeamProject'], 'public') }}:
    - script: cp "$(sourcesPath)/src/installer/NuGet.config" "$(sourcesPath)/test/Microsoft.DotNet.SourceBuild.SmokeTests/assets/online.NuGet.Config"
      displayName: Copy Test NuGet Config

    - task: Bash@3
      displayName: Setup Private Feeds Credentials
      inputs:
        filePath: $(sourcesPath)/src/installer/eng/common/SetupNugetSources.sh
        arguments: $(sourcesPath)/test/Microsoft.DotNet.SourceBuild.SmokeTests/assets/online.NuGet.Config $Token
      env:
        Token: $(dn-bot-dnceng-artifact-feeds-rw)

  - ${{ if ne(parameters.excludeSdkContentTests, 'true') }}:
    - download: current
      artifact: BlobArtifacts
      patterns: '**/dotnet-sdk-+([0-9]).+([0-9]).+([0-9])?(-@(alpha|preview|rc|rtm)*)-linux-${{ parameters.architecture }}.tar.gz'
      displayName: Download MSFT SDK

  - ${{ if ne(parameters.reuseBuildArtifactsFrom, '') }}:
    - download: current
      artifact: ${{ parameters.reuseBuildArtifactsFrom }}_${{ parameters.architecture }}_Artifacts
      patterns: '*.tar.gz'
      displayName: Download Previous Build

    - task: CopyFiles@2
      displayName: Copy Previous Build
      inputs:
        SourceFolder: $(Pipeline.Workspace)/${{ parameters.reuseBuildArtifactsFrom }}_${{ parameters.architecture }}_Artifacts
        Contents: '*.tar.gz'
        TargetFolder: ${{ variables.sourcesPath }}/packages/archive/

  - script: |
      set -x

      if [[ -z '${{ parameters.reuseBuildArtifactsFrom }}' ]]; then
        customPrepArgs=
        if [[ '${{ parameters.bootstrapPrep }}' == 'True' ]]; then
          customPrepArgs='--bootstrap'
        fi

        docker run --rm -v "$(sourcesPath):/vmr" -w /vmr ${{ parameters.container }} ./prep.sh ${customPrepArgs}
      else
        mkdir $(sourcesPath)/.dotnet
        previousSdkPath="$(sourcesPath)/packages/archive/dotnet-sdk-*.tar.gz"
        eval tar -ozxf "$previousSdkPath" -C "$(sourcesPath)/.dotnet"
        eval rm -f "$previousSdkPath"
      fi      
    displayName: Prep the Build

  - script: |
      set -x
      df -h

      customRunArgs=
      customBuildArgs=
      if [[ '${{ parameters.runOnline }}' == 'True' ]]; then
        customBuildArgs='--online'
      else
        customRunArgs='--network none'
      fi

      # See https://github.com/dotnet/source-build/issues/3202
      if [[ '${{ parameters.overrideDistroDisablingSha1 }}' == 'True' ]]; then
        customRunArgs="$customRunArgs -e OPENSSL_ENABLE_SHA1_SIGNATURES=1"
      fi

      if [[ '${{ parameters.enablePoison }}' == 'True' ]]; then
        customBuildArgs="$customBuildArgs --poison"
      fi

      docker run --rm -v "$(sourcesPath):/vmr" -w /vmr ${customRunArgs} ${{ parameters.container }} ./build.sh --clean-while-building $(additionalBuildArgs) ${customBuildArgs}      
    displayName: Build

  - script: |
      set -x

      dockerVolumeArgs="-v $(sourcesPath):/vmr"
      dockerEnvArgs="-e SMOKE_TESTS_EXCLUDE_OMNISHARP=${{ parameters.excludeOmniSharpTests }} -e SMOKE_TESTS_WARN_SDK_CONTENT_DIFFS=true"
      poisonArg=''

      if [[ '${{ parameters.excludeSdkContentTests }}' != 'True' ]]; then
        dockerVolumeArgs+=" -v $(Pipeline.Workspace)/BlobArtifacts/:/BlobArtifacts"
        msftSdkTarballName=$(find "$(Pipeline.Workspace)/BlobArtifacts/" -name "dotnet-sdk-*-linux-${{ parameters.architecture }}.tar.gz" -exec basename {} \;)
        dockerEnvArgs+=" -e SMOKE_TESTS_MSFT_SDK_TARBALL_PATH=/BlobArtifacts/$msftSdkTarballName"
      fi

      if [[ '${{ parameters.enablePoison }}' == 'True' ]]; then
        poisonArg='--poison'
        dockerEnvArgs+=" -e SMOKE_TESTS_WARN_POISON_DIFFS=true"
      fi

      docker run --rm $dockerVolumeArgs -w /vmr $dockerEnvArgs ${{ parameters.container }} ./build.sh $poisonArg --run-smoke-test $(additionalBuildArgs) -- -p:SmokeTestConsoleVerbosity=detailed      
    displayName: Run Tests

  # Don't use CopyFiles@2 as it encounters permissions issues because it indexes all files in the source directory graph.
  - script: |
      set -x

      targetFolder=$(Build.StagingDirectory)/BuildLogs/
      mkdir -p ${targetFolder}

      cd "$(sourcesPath)"
      find artifacts/ -type f -name "*.binlog" -exec cp {} --parents -t ${targetFolder} \;
      find artifacts/ -type f -name "*.log" -exec cp {} --parents -t ${targetFolder} \;
      find artifacts/prebuilt-report/ -exec cp {} --parents -t ${targetFolder} \;
      find src/ -type f -name "*.binlog" -exec cp {} --parents -t ${targetFolder} \;
      find src/ -type f -name "*.log" -exec cp {} --parents -t ${targetFolder} \;
      find test/ -type f -name "*.binlog" -exec cp {} --parents -t ${targetFolder} \;
      find test/ -type f -name "Updated*.diff" -exec cp {} --parents -t ${targetFolder} \;
      find test/ -type f -name "Updated*.txt" -exec cp {} --parents -t ${targetFolder} \;      
    displayName: Prepare BuildLogs staging directory
    continueOnError: true
    condition: succeededOrFailed()

  - publish: '$(Build.StagingDirectory)/BuildLogs'
    artifact: $(Agent.JobName)_BuildLogs_Attempt$(System.JobAttempt)
    displayName: Publish BuildLogs
    continueOnError: true
    condition: succeededOrFailed()

  - task: PublishTestResults@2
    displayName: Publish Test Results
    condition: succeededOrFailed()
    continueOnError: true
    inputs:
      testRunner: vSTest
      testResultsFiles: 'test/**/*.trx'
      searchFolder: ${{ variables.sourcesPath }}
      mergeTestResults: true
      publishRunAttachments: true
      testRunTitle: SourceBuild_SmokeTests_$(Agent.JobName)

  - publish: '${{ variables.sourcesPath }}/artifacts/${{ parameters.architecture }}/Release/'
    artifact: $(Agent.JobName)_Artifacts
    displayName: Publish Artifacts
    condition: succeededOrFailed()
    continueOnError: true