Git release branches
A method I like to utilize internally, which I’ve been slowly pushing into my open source work, is to create branches for each major/minor release. Many developers will say branches are meant to be short-lived, to be eventually merged into your main branch. I believe this is true for features and bugfixes, but there is a benefit to keeping branches around for the long term.
Essentially, if you follow symver ([major].[minor].[patch]) for versioning, you would create and maintain a branch for each [major].[minor] release. For example… if I tagged the production branch with v9.0.0, a new major release, I would create a supplementary branch 9.0. If I then released a bugfix, v9.0.1, I would then issue a pull request to merge code for v9.0.1 into branch 9.0 to keep it updated with patches.
$ git branch -l | sort -V
# ...
8.2
8.3
9.0
develop
master
By having your releases tagged and supplementing it with release branches, you will:
- Have the ability to rollback easily
- Have the ability to support multiple versions easily
- Have a easily navigable snapshot of previous releases
This may be overkill for small and personal projects, but when you’re working with a team and potentially have to support multiple versions of a codebase, then this flow is easy to adopt.
Below is a script you can use to walk through your existing repository (assuming everything is tagged in symver format) and create the [major].[minor] branches for you.
#!/usr/bin/env python
#
# Usage: `python release_branches.py`
# For a "dry run": `DRY_RUN=1 python release_branches.py`
#
import subprocess
import re
from os import environ
from typing import List, Dict
def get_tag_list() -> List[str]:
"""
Get list of tags, sorted.
"""
# Ensure tags are in vX.Y.Z format
mmp = re.compile(r"^v([0-9]+).([0-9]+).([0-9]+)$")
# Get all tags that match the format
tags = subprocess.getoutput(" ".join(("git", "tag", "-l"))).split("\n")
result = list(filter(lambda tag: (mmp.match(tag) is not None), tags))
result = [tag[1:] for tag in result]
result.sort(reverse=True)
return result
def major_minor_list(tags: List[str]) -> Dict[str, str]:
"""
Create a list of major.minor versions.
"""
mm = {}
for tag in tags:
# Strip off patch from tag
cleaned_tag = ".".join(tag.split(".")[:-1])
if cleaned_tag not in mm:
# Add to dict if major.minor doesn't exist yet
mm[cleaned_tag] = tag
return mm
def make_branch(branch: str, tag: str) -> None:
"""
Make a branch from a tag.
"""
# Checkout tag, create branch of major.minor based on tag, push to BB
subprocess.run(["git", "checkout", f"v{tag}"])
subprocess.run(["git", "checkout", "-b", branch])
subprocess.run(["git", "push", "origin", branch])
tags = get_tag_list()
mm = major_minor_list(tags)
for branch, tag in mm.items():
print(f"Making branch '{branch}' based on tag of '{tag}'...")
if environ.get('DRY_RUN') is None:
make_branch(branch, tag)
print(">> Complete")
Running with the DRY_RUN env supplied, you’ll be able to see the branches it will created based on your existing tags before proceeding with the creation.