lib/tasks/release.rake

namespace :release do
  desc 'Create a release task issue'
  task :issue, [:version] do |_t, args|
    version = get_version(args)

    ReleaseTools::Tasks::Release::Issue.new(version).execute
  end

  desc 'Prepare for a new release'
  task :prepare, [:version] do |_t, args|
    version = args[:version] ? get_version(args) : nil

    ReleaseTools::Tasks::Release::Prepare.new(version).execute
  end

  desc "Check a release's build status"
  task :status, [:version] do |t, args|
    version = get_version(args)

    status = ReleaseTools::BranchStatus.for([version])

    status.each_pair do |project, results|
      results.each do |result|
        ReleaseTools.logger.tagged(t.name) do
          ReleaseTools.logger.info(project, result.to_h)
        end
      end
    end

    ReleaseTools::Slack::ChatopsNotification.branch_status(status)
  end

  desc 'Tag a new release'
  task :tag, [:version] do |_t, args|
    version = get_version(args)
    metadata = ReleaseTools::ReleaseMetadata.new
    cng_version = ReleaseTools::CNGVersion.new(version.to_ee)
    omnibus_version =
      ReleaseTools::OmnibusGitlabVersion.new(version.to_omnibus(ee: true))
    charts_version =
      ReleaseTools::Helm::HelmVersionFinder.new.execute(version)

    commits =
      if (env = ENV.fetch('STABLE_BRANCH_SOURCE_COMMITS', nil))
        ReleaseTools::PublicRelease.parse_hash_from_string(env.to_s)
      else
        {}
      end

    ReleaseTools::TraceSection.collapse('Gitaly release', icon: '📦') do
      ReleaseTools::PublicRelease::GitalyMonthlyRelease
        .new(version, release_metadata: metadata, commit: commits[:gitaly])
        .execute
    end

    ReleaseTools::TraceSection.collapse('Kas release', icon: '📦') do
      ReleaseTools::PublicRelease::KasRelease
        .new(version, release_metadata: metadata)
        .execute
    end

    ReleaseTools::TraceSection.collapse('GitLab Pages release', icon: '📦') do
      ReleaseTools::PublicRelease::GitlabPagesRelease
        .new(version, release_metadata: metadata, commit: commits[:gitlab_pages])
        .execute
    end

    ReleaseTools::TraceSection.collapse('GitLab release', icon: '📦') do
      ReleaseTools::PublicRelease::GitlabRelease
        .new(version.to_ee, release_metadata: metadata, commit: commits[:gitlab])
        .execute
    end

    ReleaseTools::TraceSection.collapse('Omnibus release', icon: '📦') do
      ReleaseTools::PublicRelease::OmnibusGitlabRelease
        .new(omnibus_version, release_metadata: metadata, commit: commits[:omnibus])
        .execute
    end

    ReleaseTools::TraceSection.collapse('CNG release', icon: '📦') do
      ReleaseTools::PublicRelease::CNGImageRelease
        .new(cng_version, release_metadata: metadata, commit: commits[:cng])
        .execute
    end

    ReleaseTools::TraceSection.collapse('Helm release', icon: '📦') do
      ReleaseTools::PublicRelease::HelmGitlabRelease
        .new(charts_version, version, release_metadata: metadata, commit: commits[:helm])
        .execute
    end

    unless dry_run?
      file_name = version.to_normalized_version

      ReleaseTools::ReleaseMetadataUploader.new.upload(file_name, metadata, auto_deploy: false)
    end

    Rake::Task['release_environment:create'].invoke(version)
  end

  desc 'Records a deployment in release/metadata project using the GitLab API'
  task :record_metadata_deployment, [:environment, :status, :version] do |_, args|
    env = args[:environment]
    status = args[:status]
    version = args[:version]

    ReleaseTools.logger.info(
      'Recording metadata deployment',
      env: env,
      status: status,
      version: version,
      dry_run: dry_run?
    )

    next if dry_run?

    meta = ReleaseTools::Deployments::Metadata.new(version)

    ReleaseTools::SharedStatus.as_security_release(meta.security_release?) do
      tracker = ReleaseTools::Deployments::DeploymentTracker.new(environment: env, status: status, version: version)
      tracker.record_metadata_deployment
    end
  end

  desc 'Tracks a deployment using the GitLab API'
  task :track_deployment, [:environment, :status, :version] do |_, args|
    env = args[:environment]
    status = args[:status]
    version = args[:version]

    ReleaseTools.logger.info(
      'Starting track_deployment',
      env: env,
      status: status,
      version: version,
      dry_run: dry_run?
    )

    next if dry_run?

    meta = ReleaseTools::Deployments::Metadata.new(version)

    ReleaseTools::SharedStatus.as_security_release(meta.security_release?) do
      tracker = ReleaseTools::Deployments::DeploymentTracker.new(environment: env, status: status, version: version)
      deployments = tracker.track

      unless env == 'gstg-ref'
        ReleaseTools::ErrorTracking.with_exception_captured do
          ReleaseTools::Deployments::MergeRequestLabeler
            .new
            .label_merge_requests(env, deployments)
        end
      end

      ReleaseTools::Deployments::SentryTracker.new.deploy(env, status, version)
    end
  end

  namespace :gitaly do
    desc 'Tag a new release'
    task :tag, [:version] do |_, args|
      version = get_version(args)

      ReleaseTools::PublicRelease::GitalyMasterRelease.new(version).execute
    end
  end

  namespace :helm do
    desc 'Tag a new release'
    task :tag, [:charts_version, :gitlab_version] do |_t, args|
      charts_version = ReleaseTools::Version.new(args[:charts_version]) if args[:charts_version] && !args[:charts_version].empty?
      gitlab_version = ReleaseTools::Version.new(args[:gitlab_version]) if args[:gitlab_version] && !args[:gitlab_version].empty?

      # At least one of the versions must be provided in order to tag
      if (!charts_version && !gitlab_version) || (charts_version && !charts_version.valid?) || (gitlab_version && !gitlab_version.valid?)
        ReleaseTools.logger.warn('Version number must be in the following format: X.Y.Z')
        exit 1
      end

      ReleaseTools.logger.info(
        'Chart release',
        charts_version: charts_version,
        gitlab_version: gitlab_version
      )

      charts_version ||=
        ReleaseTools::Helm::HelmVersionFinder.new.execute(gitlab_version)

      gitlab_version ||=
        ReleaseTools::Helm::GitlabVersionFinder.new.execute(charts_version)

      ReleaseTools::TraceSection.collapse('Helm release', icon: '📦') do
        ReleaseTools::PublicRelease::HelmGitlabRelease
          .new(charts_version, gitlab_version)
          .execute
      end
    end
  end

  # This rake task can be used if the patch blog post automatic generation fails.
  # Do not use this task for major or minor releases that go out on the release monthly date.
  desc 'Creates a new release post for patch versions'
  task :patch_blog_post, :version do |_t, args|
    unless args[:version]
      ReleaseTools::Security::ReleasePreparation::GenerateBlogPost.new.execute
      next
    end

    coordinator = ReleaseTools::PatchRelease::Coordinator.new(version: args[:version])

    blog_post = ReleaseTools::PatchRelease::BlogPost::MergeRequestFactory.create(
      patch_coordinator: coordinator,
      security_fixes: []
    )

    ReleaseTools.logger.info("Printing blog post for patch release", version: args[:version])
    $stdout.puts blog_post.generate_blog_content if dry_run?

    create_or_show_merge_request(blog_post)
  end

  desc 'Post a message on slack containing a list of backports merged into the stable branches'
  task :pending_backports do
    release = ReleaseTools::PatchRelease::Coordinator.new
    content = release.merge_requests(with_patch_version: true)

    ReleaseTools.logger.info("Notifying #{release.versions.join(', ')} backports on slack.")

    ReleaseTools::Slack::PatchReleaseMergeRequestsNotification.notify(content)
  end

  namespace :update_paths do
    desc 'Notify the update path pipeline has finished'
    task :finish_notification, [:previous_version, :version, :status] do |_t, args|
      previous_version = args[:previous_version]
      version = args[:version]
      status = args[:status].to_sym
      ReleaseTools::UpdatePaths::FinishNotification.new(previous_version: previous_version, version: version, status: status).execute
    end
  end
end