Add support for release branch freezing and unfreezing (#56)

Task/Issue URL: https://app.asana.com/1/137249556945/project/1201899738287924/task/1211100722861854?focus=true

This change adds a new freeze_release_branch_action that is called by the “promote”
workflow on Fridays. The branch is then unfrozen by tag_release_action when run for
a public release (if a branch wasn’t frozen, it handles it gracefully - this will be the case
for hotfixes). Internal release bump workflows run validate_internal_release_bump_action
that now starts with a check for a frozen branch, and if that fails, the workflow is stopped.

Author: ayoy

lib/fastlane/plugin/ddg_apple_automation/actions/asana_find_release_task_action.rb

@@ -38,7 +38,7 @@ def self.run(params)
         setup_constants(platform)
 
         UI.message("Checking latest marketing version")
-        latest_marketing_version = find_latest_marketing_version(github_token, params[:platform])
+        latest_marketing_version = Helper::GitHelper.find_latest_marketing_version(github_token, params[:platform])
         UI.success("Latest marketing version: #{latest_marketing_version}")
         UI.message("Searching for release task for version #{latest_marketing_version}")
         release_task_id, hotfix_task_id = find_release_task(latest_marketing_version, asana_access_token)
@@ -64,31 +64,6 @@ def self.run(params)
         }
       end
 
-      def self.find_latest_marketing_version(github_token, platform)
-        latest_internal_release = Helper::GitHelper.latest_release(Helper::GitHelper.repo_name, true, platform, github_token)
-
-        version = extract_version_from_tag_name(latest_internal_release&.tag_name)
-        if version.to_s.empty?
-          Fastlane::UI.user_error!("Failed to find latest marketing version")
-          return
-        end
-        unless self.validate_semver(version)
-          Fastlane::UI.user_error!("Invalid marketing version: #{version}, expected format: MAJOR.MINOR.PATCH")
-          return
-        end
-        version
-      end
-
-      def self.extract_version_from_tag_name(tag_name)
-        # Remove build number (if present) and platform suffix from the tag name
-        tag_name&.split(/[-+]/)&.first
-      end
-
-      def self.validate_semver(version)
-        # we only need basic "x.y.z" validation here
-        version.match?(/\A\d+\.\d+\.\d+\z/)
-      end
-
       def self.find_release_task(version, asana_access_token)
         asana_client = Helper::AsanaHelper.make_asana_client(asana_access_token)
         release_task_id = nil

lib/fastlane/plugin/ddg_apple_automation/actions/asana_report_failed_workflow_action.rb

@@ -18,9 +18,11 @@ def self.run(params)
 
         extra_collaborators = []
 
-        if params[:commit_sha]
-          args[:last_commit_url] = "https://github.com/#{Helper::GitHelper.repo_name}/commit/#{params[:commit_sha]}"
-          commit_author = Helper::GitHelper.commit_author(Helper::GitHelper.repo_name, params[:commit_sha], params[:github_token])
+        commit_sha = params[:commit_sha].to_s.strip
+
+        unless commit_sha.empty?
+          args[:last_commit_url] = "https://github.com/#{Helper::GitHelper.repo_name}/commit/#{commit_sha}"
+          commit_author = Helper::GitHelper.commit_author(Helper::GitHelper.repo_name, commit_sha, params[:github_token])
           args[:last_commit_author_id] = Helper::AsanaHelper.get_asana_user_id_for_github_handle(commit_author)
           extra_collaborators << args[:last_commit_author_id]
         end

lib/fastlane/plugin/ddg_apple_automation/actions/freeze_release_branch_action.rb

@@ -0,0 +1,50 @@
+require "fastlane/action"
+require "fastlane_core/configuration/config_item"
+require "octokit"
+require_relative "../helper/ddg_apple_automation_helper"
+require_relative "../helper/git_helper"
+
+module Fastlane
+  module Actions
+    class FreezeReleaseBranchAction < Action
+      def self.run(params)
+        platform = params[:platform] || Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+
+        begin
+          Helper::GitHelper.freeze_release_branch(platform, params[:github_token], other_action)
+        rescue StandardError => e
+          UI.important("Failed to create GitHub release")
+          Helper::DdgAppleAutomationHelper.report_error(e)
+        end
+      end
+
+      def self.description
+        "Adds a draft public release for the latest marketing version as an indicator of a frozen release branch"
+      end
+
+      def self.authors
+        ["DuckDuckGo"]
+      end
+
+      def self.return_value
+        ""
+      end
+
+      def self.details
+        "This action checks the latest marketing version in GitHub and creates a draft public release for it.
+        If the release already exists, it does nothing."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.github_token,
+          FastlaneCore::ConfigItem.platform
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

lib/fastlane/plugin/ddg_apple_automation/actions/tag_release_action.rb

@@ -7,6 +7,7 @@
 require_relative "asana_extract_task_id_action"
 require_relative "asana_log_message_action"
 require_relative "asana_create_action_item_action"
+require_relative "asana_report_failed_workflow_action"
 
 module Fastlane
   module Actions
@@ -22,12 +23,36 @@ def self.setup_constants(platform)
         end
       end
 
+      # rubocop:disable Metrics/PerceivedComplexity
       def self.run(params)
         platform = params[:platform] || Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
         Helper::GitHelper.setup_git_user
 
         setup_constants(platform)
 
+        unless params[:is_prerelease]
+          branch = other_action.git_branch
+          begin
+            Helper::GitHelper.unfreeze_release_branch(branch, platform, params[:github_token])
+          rescue StandardError => e
+            Helper::GitHubActionsHelper.set_output("stop_workflow", true)
+            Helper::DdgAppleAutomationHelper.report_error(e)
+            UI.important("Failed to unfreeze release branch. Cannot proceed with the public release. Please unfreeze manually and run the workflow again.")
+            task_id = AsanaExtractTaskIdAction.run(task_url: params[:asana_task_url])
+            AsanaReportFailedWorkflowAction.run(
+              asana_access_token: params[:asana_access_token],
+              github_token: params[:github_token],
+              platform: platform,
+              task_id: task_id,
+              branch: branch,
+              github_handle: params[:github_handle],
+              workflow_name: "Tag Release",
+              workflow_url: ENV.fetch("WORKFLOW_URL", nil)
+            )
+            return
+          end
+        end
+
         unless assert_branch_tagged_before_public_release(params.values)
           UI.important("Skipping release because release branch's HEAD is not tagged.")
           Helper::GitHubActionsHelper.set_output("stop_workflow", true)
@@ -85,6 +110,7 @@ def self.assert_branch_tagged_before_public_release(params)
         end
         true
       end
+      # rubocop:enable Metrics/PerceivedComplexity
 
       def self.create_tag_and_github_release(is_prerelease, platform, github_token)
         tag, promoted_tag = Helper::DdgAppleAutomationHelper.compute_tag(is_prerelease, platform)

lib/fastlane/plugin/ddg_apple_automation/actions/validate_internal_release_bump_action.rb

@@ -14,6 +14,8 @@ def self.run(params)
         options = params.values
         find_release_task_if_needed(options)
 
+        Helper::GitHelper.assert_release_branch_is_not_frozen(options[:release_branch], params[:platform], options[:github_token])
+
         if params[:is_scheduled_release] && !Helper::GitHelper.assert_branch_has_changes(options[:release_branch], params[:platform])
           UI.important("No changes to the release branch (or only changes to scripts and workflows). Skipping automatic release.")
           Helper::GitHubActionsHelper.set_output("skip_release", true)

lib/fastlane/plugin/ddg_apple_automation/helper/git_helper.rb

@@ -90,7 +90,38 @@ def self.commit_sha_for_tag(tag)
         `git rev-parse "#{tag}"^{}`.chomp
       end
 
-      def self.latest_release(repo_name, prerelease, platform, github_token)
+      def self.find_latest_marketing_version(github_token, platform)
+        latest_internal_release = Helper::GitHelper.latest_release(Helper::GitHelper.repo_name, true, platform, github_token)
+
+        version = extract_version_from_tag_name(latest_internal_release&.tag_name)
+        if version.to_s.empty?
+          UI.user_error!("Failed to find latest marketing version")
+          return
+        end
+        unless self.validate_semver(version)
+          UI.user_error!("Invalid marketing version: #{version}, expected format: MAJOR.MINOR.PATCH")
+          return
+        end
+        version
+      end
+
+      def self.extract_version_from_tag_name(tag_name)
+        # Remove build number (if present) and platform suffix from the tag name
+        tag_name&.split(/[-+]/)&.first
+      end
+
+      def self.extract_version_from_branch_name(branch_name)
+        version = branch_name.split('/')&.last
+        version if validate_semver(version)
+      end
+
+      def self.validate_semver(version)
+        # we only need basic "x.y.z" validation here
+        version.match?(/\A\d+\.\d+\.\d+\z/)
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity
+      def self.latest_release(repo_name, prerelease, platform, github_token, allow_drafts: false)
         client = Octokit::Client.new(access_token: github_token)
 
         current_page = 1
@@ -104,6 +135,9 @@ def self.latest_release(repo_name, prerelease, platform, github_token)
           # If `prerelease` is false, then ensure that the release is public.
           matching_release = releases.find do |release|
             matches_platform = platform.nil? || release.tag_name.end_with?("+#{platform}")
+            if allow_drafts
+              matches_platform ||= release.name.end_with?("+#{platform}")
+            end
             matches_prerelease = prerelease == release.prerelease
             matches_platform && matches_prerelease
           end
@@ -116,6 +150,107 @@ def self.latest_release(repo_name, prerelease, platform, github_token)
 
         return nil
       end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def self.delete_release(release_url, github_token)
+        client = Octokit::Client.new(access_token: github_token)
+        client.delete_release(release_url)
+      end
+
+      def self.freeze_release_branch(platform, github_token, other_action)
+        UI.message("Checking latest marketing version")
+        latest_marketing_version = find_latest_marketing_version(github_token, platform)
+        UI.success("Latest marketing version: #{latest_marketing_version}")
+
+        draft_public_release_name = "#{latest_marketing_version}+#{platform}"
+
+        UI.message("Will freeze release branch for #{latest_marketing_version} by creating a draft public release")
+        UI.message("First we'll check if #{draft_public_release_name} release exists.")
+
+        UI.message("Checking for draft public release #{draft_public_release_name}")
+        latest_public_release = latest_release(Helper::GitHelper.repo_name, false, platform, github_token, allow_drafts: true)
+        UI.success("Latest public release (including drafts): #{latest_public_release.name}")
+
+        if latest_public_release.name == draft_public_release_name
+          UI.success("Draft public release #{draft_public_release_name} already exists. Nothing to do as the branch is already frozen.")
+          return
+        end
+
+        UI.message("Creating draft public release #{draft_public_release_name}")
+
+        description = <<~DESCRIPTION
+          This draft release is here to indicate that the release branch is frozen.
+          New internal releases on `release/#{platform}/#{latest_marketing_version}` branch cannot be created.
+          If you need to bump the internal release, please manually delete this draft release.
+        DESCRIPTION
+
+        other_action.set_github_release(
+          repository_name: repo_name,
+          api_bearer: github_token,
+          description: description,
+          name: draft_public_release_name,
+          tag_name: "",
+          is_draft: true,
+          is_prerelease: false
+        )
+        UI.success("Draft public release #{draft_public_release_name} created")
+      end
+
+      def self.assert_release_branch_is_not_frozen(release_branch, platform, github_token)
+        UI.message("Checking if release on #{release_branch} branch can be bumped.")
+
+        marketing_version = extract_version_from_branch_name(release_branch)
+        if marketing_version.to_s.empty?
+          UI.user_error!("Unable to extract version from '#{release_branch}' branch name.")
+          return
+        end
+
+        UI.message("Version extracted from '#{release_branch}' branch name: #{marketing_version}")
+
+        draft_public_release_name = "#{marketing_version}+#{platform}"
+        UI.message("Checking if draft public release #{draft_public_release_name} exists.")
+
+        latest_public_release = latest_release(repo_name, false, platform, github_token, allow_drafts: true)
+        UI.success("Latest public release (including drafts): #{latest_public_release.name}")
+
+        if latest_public_release.name == draft_public_release_name && latest_public_release.draft
+          UI.important("Draft public release #{draft_public_release_name} exists, which means the release branch is frozen.")
+          UI.error("🚨 If you need to bump the release:")
+          UI.error(" - Delete the draft public release to unfreeze the branch")
+          UI.error("    - Release URL: ➡️ #{latest_public_release.html_url} ⬅️")
+          UI.error(" - Restart the workflow")
+          UI.user_error!("Release branch is frozen.")
+          return
+        end
+
+        UI.success("No draft public release #{draft_public_release_name} found - the release isn't frozen.")
+      end
+
+      def self.unfreeze_release_branch(release_branch, platform, github_token)
+        marketing_version = extract_version_from_branch_name(release_branch)
+        if marketing_version.to_s.empty?
+          UI.user_error!("Unable to extract version from '#{release_branch}' branch name.")
+          return
+        end
+
+        UI.message("Unfreezing release branch #{release_branch} if needed")
+
+        draft_public_release_name = "#{marketing_version}+#{platform}"
+        UI.message("Checking if draft public release #{draft_public_release_name} exists.")
+
+        latest_public_release = latest_release(repo_name, false, platform, github_token, allow_drafts: true)
+        UI.success("Latest public release (including drafts): #{latest_public_release.name}")
+
+        unless latest_public_release.name == draft_public_release_name && latest_public_release.draft
+          UI.important("Latest public release is not a draft. No need to delete it.")
+          return
+        end
+
+        UI.message("Release version matches and it's a draft release.")
+        UI.important("Deleting draft public release #{draft_public_release_name}")
+        delete_release(latest_public_release.url, github_token)
+        UI.success("Draft public release #{draft_public_release_name} deleted")
+      end
 
       def self.commit_author(repo_name, commit_sha, github_token)
         client = Octokit::Client.new(access_token: github_token)

lib/fastlane/plugin/ddg_apple_automation/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module DdgAppleAutomation
-    VERSION = "2.11.0"
+    VERSION = "3.0.0"
   end
 end