.vsts.release.yml

schedules:
- cron: '0 6 * * 2'
  displayName: Scheduled weekly run
  branches:
    include:
    - master

parameters:
- name: version
  type: string
  displayName: Version
  default: 'NotSet'
- name: derivedFrom
  type: string
  displayName: Derived From Version
  default: latest
- name: skipTests
  type: boolean
  default: false
  displayName: Skip Tests
# buildStageOnly is useful for testing changes of the build stage which cannot be tested
# in the ci project, like signing, without actually doing a release
- name: buildStageOnly
  type: boolean
  default: false
  displayName: Build Stage Only

- name: onlyGitHubRelease
  type: boolean
  default: false
  displayName: Release only for GitHub

- name: testProxyAgent
  type: boolean
  default: true
  displayName: Test Proxy Agent

extends:
  template: .azure-pipelines/pipeline.yml
  parameters:
    # https://learn.microsoft.com/en-us/azure/devops/pipelines/process/expressions?view=azure-devops#format
    # https://learn.microsoft.com/en-us/azure/devops/pipelines/process/expressions?view=azure-devops#replace
    # https://learn.microsoft.com/en-us/azure/devops/pipelines/process/expressions?view=azure-devops#coalesce
    branch:  $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.releaseBranch'] ]
    componentDetection: false
    test: ${{ not(parameters.skipTests) }}
    sign: true
    publishArtifacts: true
    testProxyAgent: ${{ parameters.testProxyAgent }}
    stageDependencies:
      - Verify_release
      - Create_Release_Branch
    stageCondition: |
      and(
        succeeded('Verify_release'),
        in(dependencies.Create_Release_Branch.result, 'Succeeded', 'Skipped')
      )

    preBuildStages:
    - stage: Verify_release
      displayName: Make sure it's actually the release run
      pool:
        vmImage: ubuntu-latest
      jobs:
      - job: Set_variables
        displayName: Set release-specific variables
        steps:
        - checkout: none
        - pwsh: |
            $isBuildStageOnly = [System.Convert]::ToBoolean('${{ parameters.buildStageOnly }}')
            $buildReason = '$(Build.Reason)'

            $currentSprint = (Invoke-WebRequest https://whatsprintis.it -Headers @{"Accept" = "application/json" } | ConvertFrom-Json)
            $isReleaseWeek = $currentSprint.week -eq 3
            Write-Host "isReleaseWeek = $isReleaseWeek"

            $isRelease = ($buildReason -eq 'Manual' -and !$isBuildStageOnly) -or ($buildReason -eq 'Schedule' -and $isReleaseWeek)
            Write-Host "isRelease = $isRelease"
            $isRelease = $false
            Write-Host "##vso[task.setVariable variable=isRelease;isOutput=true]$isRelease"

            $isScheduledRelease = $isRelease -and $buildReason -eq 'Schedule'
            # $isScheduledRelease = $false
            Write-Host "isScheduledRelease = $isScheduledRelease"

            if ($isRelease) {
              if ($isScheduledRelease) {
                $majorAndMinorVersion = "3.$($currentSprint.sprint)"
                $patchVersion = 0
                ## Checking existing branches while not found unused patch version in sprint
                while ($true) {
                  $agentVersion = "$majorAndMinorVersion.$patchVersion"
                  git ls-remote --exit-code --heads origin refs/heads/releases/$agentVersion
                  if ($LASTEXITCODE -eq 2) {
                      $LASTEXITCODE = 0
                      break
                  }
                  $patchVersion++
                }
              } else {
                $agentVersion = "${{ parameters.version }}"
                if ($agentVersion -eq 'NotSet') {
                  Write-Error "Version parameter is required for manual release." -ErrorAction Stop
                }
              }
              Write-Host "agentVersion = $agentVersion"
              Write-Host "##vso[task.setVariable variable=agentVersion;isOutput=true]$agentVersion"

              $releaseBranch = "releases/$agentVersion"
              Write-Host "releaseBranch = $releaseBranch"
              Write-Host "##vso[task.setVariable variable=releaseBranch;isOutput=true]$releaseBranch"
            }
            else {
              Write-Host "##vso[task.setVariable variable=releaseBranch;isOutput=true]"
            }

          name: SetReleaseVariables
          displayName: Set release-specific variables

    - stage: Create_Release_Branch
      displayName: Create Release Branch
      dependsOn:
      - Verify_release
      jobs:
      ################################################################################
      - job: Create_Release_Branch
      ################################################################################
        displayName: Create Release Branch
        variables:
          IsRelease: $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.isRelease'] ]
          ReleaseBranch: $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.releaseBranch'] ]
          AgentVersion: $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.agentVersion'] ]
        condition: and(succeeded(), eq(variables.IsRelease, 'True'))
        pool:
          vmImage: ubuntu-latest
        steps:

        - checkout: self

        # - task: NodeTool@0
        #   displayName: Use node 14.15.1
        #   inputs:
        #     versionSpec: "14.15.1"

        - script: |
            # cd release
            # npm install

            # node createReleaseBranch.js $(AgentVersion) --derivedFrom=${{ parameters.derivedFrom }}
            echo "Agent version: $(AgentVersion)"
          env:
            EDITOR: cat
            PAT: $(GithubToken)
          displayName: Push release branch to GitHub

    postBuildStages:
      - stage: Release
        dependsOn:
          - build
          - Verify_release
        jobs:
        ################################################################################
        - job: publish_agent_packages
        ################################################################################
          displayName: Publish Agents (Windows/Linux/OSX)
          pool:
            # name: RMAgentsProdAME
            vmImage: ubuntu-latest
          variables:
            IsRelease: $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.isRelease'] ]
            ReleaseBranch: $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.releaseBranch'] ]
            AgentVersion: $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.agentVersion'] ]
          condition: and(succeeded(), eq(variables.IsRelease, 'True'))
          steps:

          # Clean
          - checkout: self
            clean: true

          - task: PowerShell@2
            displayName: 'Switch to release branch'
            inputs:
              targetType: 'filePath'
              filePath: .azure-pipelines/scripts/Switch-Branch.ps1
            env:
              TARGET_BRANCH: $(ReleaseBranch)

          # # Switch to release branch
          # - template: switch-branch.yml
          #   parameters:
          #     branch: $(ReleaseBranch)

          # # Download all agent packages from all previous phases
          # - task: DownloadBuildArtifacts@0
          #   displayName: Download Agent Packages
          #   inputs:
          #     artifactName: agent

          # # Upload agent packages to Azure blob storage and refresh Azure CDN
          # - powershell: |
          #     Write-Host "Preloading Azure modules." # This is for better performance, to avoid module-autoloading.
          #     Import-Module Azure, Az.Accounts, Az.Storage, Az.Cdn -ErrorAction Ignore -PassThru
          #     $uploadFiles = New-Object System.Collections.ArrayList
          #     $certificateThumbprint = (Get-ItemProperty -Path "$(ServicePrincipalReg)").ServicePrincipalCertThumbprint
          #     $clientId = (Get-ItemProperty -Path "$(ServicePrincipalReg)").ServicePrincipalClientId
          #     Write-Host "##vso[task.setsecret]$certificateThumbprint"
          #     Write-Host "##vso[task.setsecret]$clientId"
          #     Login-AzAccount -ServicePrincipal -CertificateThumbprint $certificateThumbprint -ApplicationId $clientId -TenantId $(TenantId)
          #     Select-AzSubscription -SubscriptionId $(SubscriptionId)
          #     $storage = Get-AzStorageAccount -ResourceGroupName vstsagentpackage -AccountName vstsagentpackage
          #     $versionDir = "$(AgentVersion)"
          #     Get-ChildItem -LiteralPath "$(System.ArtifactsDirectory)/agent" | ForEach-Object {
          #       $target=$_
          #       Get-ChildItem -LiteralPath "$(System.ArtifactsDirectory)/agent/$target" -Include "*.zip","*.tar.gz" | ForEach-Object {
          #         $executable = $_
          #         Write-Host "Uploading $executable to BlobStorage vstsagentpackage/agent/$versionDir"
          #         Set-AzStorageBlobContent -Context $storage.Context -Container agent -File "$(System.ArtifactsDirectory)/agent/$target/$executable" -Blob "$versionDir/$executable" -Force
          #         $uploadFiles.Add("/agent/$versionDir/$executable")
          #       }
          #     }
          #     Write-Host "Purge Azure CDN Cache"
          #     Unpublish-AzCdnEndpointContent -EndpointName vstsagentpackage -ProfileName vstsagentpackage -ResourceGroupName vstsagentpackage -PurgeContent $uploadFiles
          #     Write-Host "Force Refresh Azure CDN Cache"
          #     Publish-AzCdnEndpointContent -EndpointName vstsagentpackage -ProfileName vstsagentpackage -ResourceGroupName vstsagentpackage -LoadContent $uploadFiles
          #   displayName: Upload to Azure Blob

          # # Download all agent hashes created in previous phases
          # - task: DownloadBuildArtifacts@0
          #   displayName: Download Agent Hashes
          #   inputs:
          #     artifactName: hash
          #     downloadPath: $(Build.SourcesDirectory)/_hashes

          # Fill release notes with agent version and package hashes
          - script: |
              # cd release
              # node fillReleaseNotesTemplate.js $(AgentVersion)
              echo "Agent version: $(AgentVersion)"
            displayName: Fill release notes

          # # Create agent release on Github
          # - powershell: |
          #     Write-Host "Creating github release."
          #     $releaseNotes = [System.IO.File]::ReadAllText("$(Build.SourcesDirectory)\releaseNote.md")
          #     $releaseData = @{
          #       tag_name = "v$(AgentVersion)";
          #       target_commitish = "$(Build.SourceVersion)";
          #       name = "v$(AgentVersion)";
          #       body = $releaseNotes;
          #       draft = $false;
          #       prerelease = $true;
          #     }
          #     $releaseParams = @{
          #       Uri = "https://api.github.com/repos/Microsoft/azure-pipelines-agent/releases";
          #       Method = 'POST';
          #       Headers = @{
          #         Authorization = 'Basic ' + [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes("vsts:$(GithubToken)"));
          #       }
          #       ContentType = 'application/json';
          #       Body = (ConvertTo-Json $releaseData -Compress)
          #     }
          #     [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
          #     $releaseCreated = Invoke-RestMethod @releaseParams
          #     Write-Host $releaseCreated
          #     $releaseId = $releaseCreated.id
          #     $assets = [System.IO.File]::ReadAllText("$(Build.SourcesDirectory)\assets.json").Replace("<AGENT_VERSION>","$(AgentVersion)")
          #     $assetsParams = @{
          #       Uri = "https://uploads.github.com/repos/Microsoft/azure-pipelines-agent/releases/$releaseId/assets?name=assets.json"
          #       Method = 'POST';
          #       Headers = @{
          #         Authorization = 'Basic ' + [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes("vsts:$(GithubToken)"));
          #       }
          #       ContentType = 'application/octet-stream';
          #       Body = [system.Text.Encoding]::UTF8.GetBytes($assets)
          #     }
          #     Invoke-RestMethod @assetsParams
          #   displayName: Create agent release on Github

      - stage: CreatePRs
        dependsOn:
        - Release
        - Verify_release
        condition: and(succeeded(), not(${{ parameters.onlyGitHubRelease }}))
        pool:
          vmImage: ubuntu-latest
        jobs:
        ################################################################################
        - job: create_ado_prs
        ################################################################################
          displayName: Create PRs in AzureDevOps and ConfigChange
          variables:
            IsRelease: $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.isRelease'] ]
            ReleaseBranch: $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.releaseBranch'] ]
            AgentVersion: $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.agentVersion'] ]
          condition: and(succeeded(), eq(variables.IsRelease, 'True'))

          steps:
          - checkout: self

          # - ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/master') }}:
          - script: echo $(ReleaseBranch) # git checkout $(ReleaseBranch)
            displayName: Checkout release branch

          # # Download all agent hashes created in previous phases
          # - task: DownloadBuildArtifacts@0
          #   displayName: Download Agent Hashes
          #   inputs:
          #     artifactName: hash
          #     downloadPath: $(Build.SourcesDirectory)/_hashes

          - bash: |
              # set -x
              # cd release
              # npm install
              # ls
              # node createAdoPrs.js $(AgentVersion)
              echo "Agent version: $(AgentVersion)"

              echo "##vso[task.setVariable variable=AdoPrId;isOutput=true]ADO_PR_ID_4848"
              echo "##vso[task.setvariable variable=AdoPrLink;isOutput=true]ADO_PR_LINK_4848"
              echo "##vso[task.setvariable variable=CcPrId;isOutput=true]CC_PR_ID_4848"
              echo "##vso[task.setvariable variable=CcPrLink;isOutput=true]CC_PR_LINK_4848"

            name: s_CreateAdoPrs
            displayName: Create PRs in AzureDevOps and ConfigChange
            env:
              USERNAME: $(User)
              PAT: $(AdoPAT)
              USEREMAIL: $(Email)

      - stage: S_Notifications
        displayName: Send Notifications
        dependsOn:
        - Verify_release
        - CreatePRs
        condition: always()
        pool:
          vmImage: ubuntu-latest
        jobs:
        - job: j_SendPRsNotifications
          displayName: Send Release PRs notifications
          variables:
            IsRelease: $[ stageDependencies.Verify_release.Set_variables.outputs['SetReleaseVariables.isRelease'] ]
            AdoPrId: $[ stageDependencies.CreatePRs.create_ado_prs.outputs['s_CreateAdoPrs.AdoPrId'] ]
            AdoPrLink: $[ stageDependencies.CreatePRs.create_ado_prs.outputs['s_CreateAdoPrs.AdoPrLink'] ]
            CcPrId: $[ stageDependencies.CreatePRs.create_ado_prs.outputs['s_CreateAdoPrs.CcPrId'] ]
            CcPrLink: $[ stageDependencies.CreatePRs.create_ado_prs.outputs['s_CreateAdoPrs.CcPrLink'] ]
          condition: |
            and(
              eq(variables.IsRelease, 'True'),
              not(${{ parameters.onlyGitHubRelease }})
            )
          steps:
          - task: PowerShell@2
            inputs:
              targetType: 'filePath'
              filePath: ./release/Send-PRsNotification.ps1
            displayName: Send MS Teams notification
            env:
              TEAMS_WEBHOOK: $(MsTeamsWebhook)
              ADO_PR_ID: $(AdoPrId)
              ADO_PR_LINK: $(AdoPrLink)
              CC_PR_ID: $(CcPrId)
              CC_PR_LINK: $(CcPrLink)
          - script: |
              echo "Stage attempt: $(System.StageAttempt)"
              echo "Stage name: $(System.StageName)"
              echo "Job attempt: $(System.JobAttempt)"
              echo "Job name: $(System.JobName)"
              echo "Job status: $(System.JobStatus)"
              echo "Phase attempt: $(System.PhaseAttempt)"
              echo "Phase name: $(System.PhaseName)"