build-job.yml

parameters:
  archType: ''
  buildConfig: ''
  compilerName: 'clang'
  condition: true
  container: ''
  crossrootfsDir: ''
  isOfficialBuild: false
  osGroup: ''
  osSubgroup: ''
  platform: ''
  pool: ''
  signBinaries: false
  stagedBuild: false
  testGroup: ''
  timeoutInMinutes: ''
  variables: {}

### Product build
jobs:
- template: xplat-pipeline-job.yml
  parameters:
    buildConfig: ${{ parameters.buildConfig }}
    _BuildConfig: ${{ parameters.buildConfig }}
    archType: ${{ parameters.archType }}
    osGroup: ${{ parameters.osGroup }}
    osSubgroup: ${{ parameters.osSubgroup }}
    testGroup: ${{ parameters.testGroup }}
    helixType: 'build/product/'
    enableMicrobuild: true
    stagedBuild: ${{ parameters.stagedBuild }}
    pool: ${{ parameters.pool }}
    condition: ${{ parameters.condition }}

    # Compute job name from template parameters
    ${{ if eq(parameters.compilerName, 'gcc') }}:
      name: ${{ format('coreclr_{0}_product_build_{1}{1}_{3}_{4}', parameters.compilerName, parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
      displayName: ${{ format('CoreCLR GCC Product Build {0}{1} {2} {3}', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
    ${{ if eq(parameters.compilerName, 'clang') }}:
      name: ${{ format('coreclr_product_build_{0}{1}_{2}_{3}', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
      displayName: ${{ format('CoreCLR Product Build {0}{1} {2} {3}', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}

    # Run all steps in the container.
    # Note that the containers are defined in platform-matrix.yml
    container: ${{ parameters.container }}

    timeoutInMinutes: ${{ parameters.timeoutInMinutes }}

    crossrootfsDir: ${{ parameters.crossrootfsDir }}

    gatherAssetManifests: true
    variables:
    - name: osGroup
      value: ${{ parameters.osGroup }}
    - name: osSubgroup
      value: ${{ parameters.osSubgroup }}
    - name: compilerArg
      value: ''
    - name: publishLogsArtifactPrefix
      value: 'BuildLogs_CoreCLR'
    - ${{ if eq(parameters.compilerName, 'gcc') }}:
      - name: compilerArg
        value: '-gcc'
      - name: publishLogsArtifactPrefix
        value: 'BuildLogs_CoreCLR_GCC'
      # workaround for gcc directory not in PATH
      - name: CLR_CC
        value: /opt/rh/devtoolset-7/root/usr/bin/gcc
      - name: CLR_CXX
        value: /opt/rh/devtoolset-7/root/usr/bin/g++
    - ${{ if and(ne(parameters.osGroup, 'Windows_NT'), eq(parameters.compilerName, 'clang')) }}:
      - name: compilerArg
        value: '-clang9'
      # Our FreeBSD doesn't yet detect available clang versions, so pass it explicitly.
      - ${{ if eq(parameters.osGroup, 'FreeBSD') }}:
        - name: compilerArg
          value: '-clang6.0'
      # Building for x64 MUSL happens on Alpine Linux and we need to use the stable version available there
      - ${{ if and(eq(parameters.osGroup, 'Linux'), eq(parameters.osSubgroup, '_musl'), eq(parameters.archType, 'x64')) }}:
        - name: compilerArg
          value: ''
      # AppleClang has different version scheme, so we let complier introspection pick up the available clang from PATH
      - ${{ if eq(parameters.osGroup, 'OSX') }}:
        - name: compilerArg
          value: ''
    - ${{ if and(ne(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
      # Variables used to publish packages to blob feed
      - name: dotnetfeedUrl
        value: https://dotnetfeed.blob.core.windows.net/dotnet-coreclr/index.json
      - name: dotnetfeedPAT
        value: $(dotnetfeed-storage-access-key-1)
      # Variables used by arcade to gather asset manifests
      - name: _DotNetPublishToBlobFeed
        value: true
    - name: officialBuildIdArg
      value: ''
    - ${{ if and(eq(variables['System.TeamProject'], 'internal'), ne(variables['Build.Reason'], 'PullRequest')) }}:
      - name: officialBuildIdArg
        value: '/p:OfficialBuildId=$(Build.BuildNumber)'
    - name: enforcePgoArg
      value: ''
    # The EnforcePGO script is only supported on Windows and is not supported on arm or arm64.
    - ${{ if and(eq(parameters.buildConfig, 'Release'), and(eq(parameters.osGroup, 'Windows_NT'), not(or(eq(parameters.archType, 'arm64'), eq(parameters.archType, 'arm'))))) }}:
      - name: enforcePgoArg
        value: '-enforcepgo'

    - ${{ parameters.variables }}

    steps:

    # Install native dependencies
    # Linux builds use docker images with dependencies preinstalled,
    # and FreeBSD builds use a build agent with dependencies
    # preinstalled, so we only need this step for OSX and Windows.
    - ${{ if eq(parameters.osGroup, 'OSX') }}:
      - script: sh $(Build.SourcesDirectory)/eng/install-native-dependencies.sh $(osGroup)
        displayName: Install native dependencies
    - ${{ if eq(parameters.osGroup, 'Windows_NT') }}:
      # Necessary to install python
      - script: $(Build.SourcesDirectory)\eng\common\init-tools-native.cmd -InstallDirectory $(Build.SourcesDirectory)\native-tools -Force
        displayName: Install native dependencies

    # # Install internal tools on official builds
    # # Since our internal tools are behind an authenticated feed,
    # # we need to use the DotNetCli AzDO task to restore from the feed using a service connection.
    # # We can't do this from within the build, so we need to do this as a separate step.
    - ${{ if and(eq(variables['System.TeamProject'], 'internal'), ne(variables['Build.Reason'], 'PullRequest')) }}:
      - template: /eng/pipelines/common/restore-internal-tools.yml
        parameters:
          installDotnet: true

    # Build CoreCLR Runtime
    - ${{ if ne(parameters.osGroup, 'Windows_NT') }}:
      - script: $(coreClrRepoRootDir)build-runtime$(scriptExt) $(buildConfig) $(archType) $(crossArg) -ci $(compilerArg) $(officialBuildIdArg)
        displayName: Build CoreCLR Runtime
    - ${{ if eq(parameters.osGroup, 'Windows_NT') }}:
      - script: set __TestIntermediateDir=int&&$(coreClrRepoRootDir)build-runtime$(scriptExt) $(buildConfig) $(archType) -ci $(enforcePgoArg) $(officialBuildIdArg)
        displayName: Build CoreCLR Runtime

    - ${{ if and(eq(parameters.osGroup, 'Windows_NT'), ne(parameters.archType, 'x86')) }}:
      - script: set __TestIntermediateDir=int&&$(coreClrRepoRootDir)build-runtime$(scriptExt) $(buildConfig) $(archType) -ci -linuxdac $(officialBuildIdArg)
        displayName: Build Cross OS Linux DAC for Windows

    # Build CoreCLR Managed Components
    - script: $(Build.SourcesDirectory)$(dir)build$(scriptExt) -subsetCategory coreclr -subset corelib-nativecorelib-tools-packages $(crossArg) -arch $(archType) -c $(buildConfig) $(officialBuildIdArg) -ci
      displayName: Build managed product components and packages

    # Build native test components
    - script: $(coreClrRepoRootDir)build-test$(scriptExt) skipmanaged $(buildConfig) $(archType) $(crossArg) $(priorityArg) $(compilerArg) skipgeneratelayout
      displayName: Build native test components

    # Sign on Windows
    - ${{ if and(eq(parameters.osGroup, 'Windows_NT'), eq(parameters.signBinaries, 'true')) }}:
      - powershell: eng\common\build.ps1 -ci -sign -restore -configuration:$(buildConfig) -warnaserror:0 /p:ArcadeBuild=true /p:OfficialBuild=true /p:TargetOS=$(osGroup) /p:BuildArch=$(archType) /p:BuildType=$(_BuildConfig) /p:DotNetSignType=$env:_SignType -projects $(Build.SourcesDirectory)\eng\empty.csproj
        displayName: Sign Binaries

      - task: PublishPipelineArtifact@1
        displayName: Publish Signing Logs
        inputs:
          targetPath: '$(Build.SourcesDirectory)/artifacts/log/'
          artifactName: ${{ format('SignLogs_{0}{1}_{2}_{3}', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
        continueOnError: true
        condition: always()

    # We only test on clang binaries.
    - ${{ if eq(parameters.compilerName, 'clang') }}:
      # Publish product output directory for consumption by tests.
      - template: /eng/pipelines/common/upload-artifact-step.yml
        parameters:
          rootFolder: $(buildProductRootFolderPath)
          includeRootFolder: false
          archiveType: $(archiveType)
          tarCompression: $(tarCompression)
          archiveExtension: $(archiveExtension)
          artifactName: $(buildProductArtifactName)
          displayName: 'product build'

      # Publish test native components for consumption by test execution.
      - template: /eng/pipelines/common/upload-artifact-step.yml
        parameters:
          rootFolder: $(nativeTestArtifactRootFolderPath)
          includeRootFolder: false
          archiveType: $(archiveType)
          tarCompression: $(tarCompression)
          archiveExtension: $(archiveExtension)
          artifactName: $(nativeTestArtifactName)
          displayName: 'native test components'

    # Get key vault secrets for publishing
    - ${{ if and(ne(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
      - task: AzureKeyVault@1
        inputs:
          azureSubscription: 'DotNet-Engineering-Services_KeyVault'
          KeyVaultName: EngKeyVault
          SecretsFilter: 'dotnetfeed-storage-access-key-1,microsoft-symbol-server-pat,symweb-symbol-server-pat'

    # Save packages using the prepare-signed-artifacts format.
    - ${{ if eq(parameters.isOfficialBuild, true) }}:
      - template: /eng/pipelines/common/upload-unsigned-artifacts-step.yml
        parameters:
          name: ${{ parameters.platform }}

    # Publish Logs
    - task: PublishPipelineArtifact@1
      displayName: Publish Logs
      inputs:
        targetPath: $(Build.SourcesDirectory)/artifacts/log
        artifactName: '$(publishLogsArtifactPrefix)_$(osGroup)$(osSubgroup)_$(archType)_$(buildConfig)'
      continueOnError: true
      condition: always()