Revert "Updated flow to use trigger branch as base for releasing"

This reverts commit 6e08459.

Author: michalChrobot

Tools/scripts/ReleaseAutomation/release_config.py

@@ -65,9 +65,9 @@ def __init__(self):
 
         self.release_commit_message = f"Updated changelog and package version for Netcode in anticipation of v{self.package_version} release"
 
-        self.pr_branch_name = f"netcode-update-after-{self.package_version}-release-branch-creation" # Branch from which we will create PR to trigger branch with relevant changes after release branch is created
+        self.pr_branch_name = f"netcode-update-after-{self.package_version}-release-branch-creation" # Branch from which we will create PR to default branch with relevant changes after release branch is created
         self.pr_commit_message = f"chore: Updated aspects of Netcode package in anticipation of v{self.package_version} release"
-        self.pr_body = f"This PR was created in sync with branching of {self.release_branch_name}. It includes changes that should land on the branch this job was triggered from which usually is {self.default_repo_branch} (please double check if the target branch is different if this was intended) to reflect the new state of the package after the v{self.package_version} release:\n" \
+        self.pr_body = f"This PR was created in sync with branching of {self.release_branch_name}. It includes changes that should land on the default Netcode branch ({self.default_repo_branch}) to reflect the new state of the package after the v{self.package_version} release:\n" \
             f"1) Updated CHANGELOG.md by adding new [Unreleased] section template at the top and cleaning the Changelog for the current release.\n" \
             f"2) Updated package version in package.json by incrementing the patch version to signify the current state of the package.\n" \
             f"3) Updated package version in ValidationExceptions.json to match the new package version.\n\n" \

Tools/scripts/Utils/createPrAfterRelease.py

@@ -28,48 +28,31 @@ def createPrAfterRelease(config: ReleaseConfig):
         3) Update the package version in the package.json file by incrementing the patch version to signify the current state of the package.
         4) Update package version in the validation exceptions to match the new package version.
 
-    IMPORTANT: The PR is created against the trigger branch (the branch the job was triggered from),
-    not the default branch. This ensures consistency with the validation and release branch creation.
-    Please double check if the target branch is different and if so the if this was intended.
+    This assumes that at the same time you already branched off for the release. Otherwise it may be confusing
     """
 
     try:
-        repo = get_local_repo()
-        trigger_branch = repo.active_branch.name
-        
-        if not config.github_manager.is_branch_present(trigger_branch):
-            raise Exception(f"Trigger branch '{trigger_branch}' does not exist. Exiting.")
         if not config.github_manager.is_branch_present(config.default_repo_branch):
-            raise Exception(f"Default branch '{config.default_repo_branch}' does not exist. Exiting.")
-
-        # Check if PR branch already exists (could happen if a previous run failed partway through)
-        if config.github_manager.is_branch_present(config.pr_branch_name):
-            raise Exception(f"PR branch '{config.pr_branch_name}' already exists. This might indicate a previous incomplete run.")
+            raise Exception(f"Branch '{config.default_repo_branch}' does not exist. Exiting.")
 
         author = Actor(config.commiter_name, config.commiter_email)
         committer = Actor(config.commiter_name, config.commiter_email)
 
+        repo = get_local_repo()
         repo.git.fetch('--prune', '--prune-tags')
 
-        # Ensure we're on the trigger branch and have latest changes
-        # Stash any uncommitted changes that might block operations
+        # Check if there are uncommitted changes that would block checkout
+        # Stash them if they exist to allow checkout to proceed
         has_uncommitted_changes = repo.is_dirty()
         if has_uncommitted_changes:
-            print("Uncommitted changes detected. Stashing before operations...")
-            repo.git.stash('push', '-m', 'Auto-stash before release PR creation')
+            print("Uncommitted changes detected. Stashing before checkout...")
+            repo.git.stash('push', '-m', 'Auto-stash before checkout for release PR creation')
 
-        repo.git.checkout(trigger_branch)
-        repo.git.pull("origin", trigger_branch)
+        repo.git.checkout(config.default_repo_branch)
+        repo.git.pull("origin", config.default_repo_branch)
 
-        # Create a new branch for the release changes PR to trigger branch
-        try:
-            repo.git.checkout('-b', config.pr_branch_name)
-        except Exception as e:
-            # Branch might exist locally, try to checkout existing branch
-            if 'already exists' in str(e).lower():
-                raise Exception(f"Branch '{config.pr_branch_name}' already exists locally which is not expected. Exiting.")
-            else:
-                raise
+        # Create a new branch for the release changes PR to default branch
+        repo.git.checkout('-b', config.pr_branch_name)
 
         # Update the changelog file with adding new [Unreleased] section
         update_changelog(config.changelog_path, config.package_version, add_unreleased_template=True)
@@ -85,10 +68,10 @@ def createPrAfterRelease(config: ReleaseConfig):
         repo.git.push("origin", config.pr_branch_name)
 
         github = config.github_manager
-        pr = github.create_pull_request(title=config.pr_commit_message, body=config.pr_body, head=config.pr_branch_name, base=trigger_branch)
+        pr = github.create_pull_request(title=config.pr_commit_message, body=config.pr_body, head=config.pr_branch_name, base=config.default_repo_branch)
         github.request_reviews(pr, config.pr_reviewers)
 
-        print(f"Successfully updated and created the PR targeting trigger branch: {trigger_branch}")
+        print(f"Successfully updated and created the PR targeting: {config.default_repo_branch}")
 
     except GithubException as e:
         print(f"An error occurred with the GitHub API: {e.status}", file=sys.stderr)

Tools/scripts/Utils/git_utils.py

@@ -45,27 +45,13 @@ def create_release_branch(config: ReleaseConfig):
     """
     Creates a new branch with the specified name, performs specified action, commits the current changes and pushes it to the repo.
     Note that command_to_run_on_release_branch (within the Config) should be a single command that will be executed using subprocess.run. For multiple commands consider using a Python script file.
-    
-    IMPORTANT: The release branch is created from the trigger branch (the branch the job was triggered from).
-    This ensures the release branch is created from the branch that was validated and will be used for the PR.
-    Please double check if the target branch is different and if so the if this was intended.
     """
 
     try:
         if config.github_manager.is_branch_present(config.release_branch_name):
             raise Exception(f"Branch '{config.release_branch_name}' already exists.")
 
         repo = get_local_repo()
-        trigger_branch = repo.active_branch.name
-        
-        # Stash any uncommitted changes to allow pull
-        has_uncommitted_changes = repo.is_dirty()
-        if has_uncommitted_changes:
-            print("Uncommitted changes detected. Stashing before pull...")
-            repo.git.stash('push', '-m', 'Auto-stash before pull for release branch creation')
-        
-        repo.git.fetch('--prune', '--prune-tags')
-        repo.git.pull("origin", trigger_branch)
 
         new_branch = repo.create_head(config.release_branch_name, repo.head.commit)
         new_branch.checkout()

Tools/scripts/Utils/verifyReleaseConditions.py

@@ -7,9 +7,6 @@
     - Note that if the job is triggered manually, this condition will be bypassed.
 2. **Is the [Unreleased] section of the CHANGELOG.md not empty?**
     - The script checks if the [Unreleased] section in the CHANGELOG.md contains meaningful entries.
-    - IMPORTANT: This check is performed on the branch the job was triggered from (after pulling latest).
-      The release branch will be created from this trigger branch, and the PR will target this trigger branch.
-      Please double check if the target branch is different and if so the if this was intended.
 3. **Does the release branch already exist?**
     - If the release branch for the target release already exists, the script will not run.
 """
@@ -24,7 +21,6 @@
 import datetime
 import re
 from release_config import ReleaseConfig
-from Utils.git_utils import get_local_repo
 
 def get_yamato_trigger_type():
     """
@@ -84,9 +80,6 @@ def verifyReleaseConditions(config: ReleaseConfig):
     This function checks the following conditions:
     1. If today is a scheduled release day (based on release cycle, weekday and anchor date).
     2. If the [Unreleased] section of the CHANGELOG.md is not empty.
-       IMPORTANT: This check is performed on the branch the job was triggered from (after pulling latest).
-       The release branch will be created from this trigger branch, and the PR will target this trigger branch.
-       Please double check if the target branch is different and if so the if this was intended.
     3. If the release branch does not already exist.
     """
 
@@ -99,34 +92,12 @@ def verifyReleaseConditions(config: ReleaseConfig):
         if not is_manual and not is_release_date(config.release_weekday, config.release_week_cycle, config.anchor_date):
             error_messages.append(f"Condition not met: Today is not the scheduled release day. It should be weekday: {config.release_weekday}, every {config.release_week_cycle} weeks starting from {config.anchor_date}.")
 
-        # Pull latest changes from the trigger branch to ensure we're checking the latest state
-        # The release branch will be created from this trigger branch, and the PR will target this trigger branch
-        repo = get_local_repo()
-        trigger_branch = repo.active_branch.name
-        print(f"\nTrigger branch: {trigger_branch}")
-        print(f"Pulling latest changes from '{trigger_branch}' to verify changelog state...")
-        
-        # Stash any uncommitted changes to allow pull
-        has_uncommitted_changes = repo.is_dirty()
-        if has_uncommitted_changes:
-            print("Uncommitted changes detected. Stashing before pull...")
-            repo.git.stash('push', '-m', 'Auto-stash before pull for release verification')
-        
-        repo.git.fetch('--prune', '--prune-tags')
-        repo.git.pull("origin", trigger_branch)
-        print(f"Now on branch '{trigger_branch}' with latest changes pulled.")
-
         if is_changelog_empty(config.changelog_path):
             error_messages.append("Condition not met: The [Unreleased] section of the changelog has no meaningful entries.")
 
         if config.github_manager.is_branch_present(config.release_branch_name):
             error_messages.append("Condition not met: The release branch already exists.")
 
-        # Restore stashed changes if any
-        if has_uncommitted_changes:
-            print("Restoring stashed changes...")
-            repo.git.stash('pop')
-
         if error_messages:
             print("\n--- Release conditions not met: ---")
             for i, msg in enumerate(error_messages, 1):