Mercurial_ The Definitive Guide - Bryan O'Sullivan [90]
Chapter 12. Managing Changes with Mercurial Queues
The Patch Management Problem
Here is a common scenario: you need to install a software package from source, but you find a bug that you must fix in the source before you can start using the package. You make your changes, forget about the package for a while, and a few months later you need to upgrade to a newer version of the package. If the newer version of the package still has the bug, you must extract your fix from the older source tree and apply it against the newer version. This is a tedious task, and it’s easy to make mistakes.
This is a simple case of the “patch management” problem. You have an “upstream” source tree that you can’t change; you need to make some local changes on top of the upstream tree; and you’d like to be able to keep those changes separate, so that you can apply them to newer versions of the upstream source.
The patch management problem arises in many situations. Probably the most visible is when a user of an open source software project contributes a bug fix or new feature to the project’s maintainers in the form of a patch.
Distributors of operating systems that include open source software often need to make changes to the packages they distribute so that they will build properly in their environments.
When you have few changes to maintain, it is easy to manage a single patch using the standard diff and patch programs (see Understanding Patches for a discussion of these tools). Once the number of changes grows, it starts to make sense to maintain patches as discrete “chunks of work,” so that for example a single patch will contain only one bug fix (the patch might modify several files, but it’s doing “only one thing”), and you may have a number of such patches for different bugs you need fixed and local changes you require. In this situation, if you submit a bug fix patch to the upstream maintainers of a package and they include your fix in a subsequent release, you can simply drop that single patch when you’re updating to the newer release.
Maintaining a single patch against an upstream tree is a little tedious and error-prone, but not difficult. However, the complexity of the problem grows rapidly as the number of patches you have to maintain increases. With more than a tiny number of patches in hand, understanding which ones you have applied and maintaining them moves from messy to overwhelming.
Fortunately, Mercurial includes a powerful extension, Mercurial Queues (or simply “MQ”), that massively simplifies the patch management problem.
The Prehistory of Mercurial Queues
During the late 1990s, several Linux kernel developers started to maintain “patch series” that modified the behavior of the Linux kernel. Some of these series were focused on stability, some on feature coverage, and some were more speculative.
The sizes of these patch series grew rapidly. In 2002, Andrew Morton published some shell scripts he had been using to automate the task of managing his patch queues. Andrew was successfully using these scripts to manage hundreds (sometimes thousands) of patches on top of the Linux kernel.
A Patchwork Quilt
In early 2003, Andreas Gruenbacher and Martin Quinson borrowed the approach of Andrew’s scripts and published a tool called “patchwork quilt”, or simply “quilt” (http://savannah.nongnu.org/projects/quilt/). Because quilt substantially automated patch management, it rapidly gained a large following among open source software developers.
Quilt manages a stack of patches on top of a directory tree. To begin, you tell quilt to manage a directory tree, and tell it which files you want to manage; it stores away the names and contents of those files. To fix a bug, you create a new patch (using a single command), edit the files you need to fix, then “refresh” the patch.
The refresh step causes quilt to scan the directory tree; it updates the patch with all of the