git-c2b: An alternative workflow for Chromium's GerritSeptember 14, 2018
There are two main options to handle reviews in git. The first option is to treat commits as the unit of review. In this commit-based flow, authors work on a branch with multiple commits and submit them for review, either by pushing the branch or by creating a patch series for these commits. Typically, each commit is expected to be functional and to be reviewable independently.
Here is a feature branch in a commit-based flow, before and after changing D to D' with an interactive rebase (E and F are also changed by the rebase, to E' and F'):
A-B-C [master] A-B-C [master] \ \ D-E-F [feature] D'-E'-F' [feature] or [feature-v2]
The second option is to treat branches as the unit of review. In this branch-based flow, authors work on multiple dependent branches and submit them for review by pushing them to the review system. The individual commits in each branch don't matter; only the final state of each branch is taken into account. Some review systems call this the "squash" mode.
Here are some dependent branches for a feature in a branch-based flow, before and after updating feature-1 by adding D', and then updating the other branches by merging (we could rebase, instead, if we don't care about retaining history):
A-B-C [master] A-B-C [master] \ \ D [feature-1] D--D' [feature-1] \ \ \ E [feature-2] E--E' [feature-2] \ \ \ F [feature-3] F--F' [feature-3]
Some people prefer to work this way, so they can update their submission without losing the history of each individual change (e.g., keep both D and D'). This reason is unconvincing, however, since one can easily preserve history in a commit-based flow, too, by checking out a different branch (e.g., 'feature-v2') to work on.
Personally, I find branch-based flows a pain to work with. Their main fault is the distracting and annoying user experience when dealing with multiple dependent changes. Setting up and maintaining the dependent branches during updates is far from straightforward. What would normally be a simple 'git rebase -i', now turns into a fight to create and maintain separate dependent branches. There are tools that can help (git-rebase-update), but they are no match for the simplicity and efficiency of rebasing interactively in a single branch.
Chromium previously used the Rietveld review system, which uses branches as its unit of review. Recently Chromium switched to Gerrit, but, instead of sticking with Gerrit's native commit-based flow, it adapted its tools to provide a branch-based flow similar to Rietveld's. Interacting with Chromium's review system is done mainly through the git-cl tool which evolved over the years to support both flows. At this point, however, the commit-based flow is essentially unsupported and broken for many use cases. Here is what working on Chromium typically looks like:
# Create and work on first branch $ git checkout -b feature -t origin/master $ git commit -m 'Feature' ... $ git commit -m 'Update to feature' ... # Create and work on second (dependent) branch $ git checkout -b feature-next -t feature $ git commit -m 'Feature next' ... $ git commit -m 'Update to feature next' ... # Upload the changes for review $ git checkout feature $ git cl upload --dependencies
I wrote the git-c2b (commits-to-branches) tool to be able to maintain a commit-based git flow even when working with branch-based review systems, such as Chromium's Gerrit. The idea, and the tool itself, is simple but effective. It allows me to work as usual in a single branch, splitting changes into commits and amending them as I like. Just before submitting, I run git-c2b to produce separate dependent branches for each commit. If the branches already exist they are updated without losing any upstream metadata.
This is my current workflow with Chromium and git-c2b:
# Create patchset in branch $ git checkout -b feature -t origin/master $ git commit -m 'Change 1' ... $ git commit -m 'Change 2' ... # Use git-c2b to create branches feature-1, feature-2, ... for each commit $ git c2b # Upload the changes for review $ git checkout feature-1 $ git cl upload --dependencies
To update the patches and dependent CLs:
$ git checkout feature $ git rebase -i origin/master ... # Use c2b to update the feature-1, feature-2, ... branches $ git c2b # Upload the changes for review $ git checkout feature-1 $ git cl upload --dependencies
When changes start to get merged, I typically need to reupload only the commits that are left. For example, if the changes from the first two commits get merged, I will rebase on top of master, and the previously third commit will now be the first. You can tell git-c2b to start updating branches starting from a particular number using the -n flag:
# The first two changes got merged, get new master and rebase on top of it $ git fetch $ git checkout feature $ git rebase -i origin/master ... # At this point the first two commits will be gone, so tell c2b to update # feature-3 from the first commit, feature-4 from the second and so on. $ git c2b -n 3 # Upload the remaining changes for review $ git checkout feature-3 $ git cl upload --dependencies
Although the main driver for implementing git-c2b was improving my Chromium workflow, there is nothing Chromium-specific about this tool. It can be used as a general solution to create dependent branches from commits in any branch. Enjoy!