Changegroups

Changegroups are representations of repository revlog data, specifically the changelog data, root/flat manifest data, treemanifest data, and filelogs.

There are 3 versions of changegroups: "1", "2", and "3". From a high-level, versions "1" and "2" are almost exactly the same, with the only difference being an additional item in the *delta header*. Version "3" adds support for revlog flags in the *delta header* and optionally exchanging treemanifests (enabled by setting an option on the "changegroup" part in the bundle2).

Changegroups when not exchanging treemanifests consist of 3 logical segments:

+---------------------------------+
|           |          |          |
| changeset | manifest | filelogs |
|           |          |          |
|           |          |          |
+---------------------------------+

When exchanging treemanifests, there are 4 logical segments:

+-------------------------------------------------+
|           |          |               |          |
| changeset |   root   | treemanifests | filelogs |
|           | manifest |               |          |
|           |          |               |          |
+-------------------------------------------------+

The principle building block of each segment is a *chunk*. A *chunk* is a framed piece of data:

+---------------------------------------+
|           |                           |
|  length   |           data            |
| (4 bytes) |   (<length - 4> bytes)    |
|           |                           |
+---------------------------------------+

All integers are big-endian signed integers. Each chunk starts with a 32-bit integer indicating the length of the entire chunk (including the length field itself).

There is a special case chunk that has a value of 0 for the length ("0x00000000"). We call this an *empty chunk*.

Delta Groups

A *delta group* expresses the content of a revlog as a series of deltas, or patches against previous revisions.

Delta groups consist of 0 or more *chunks* followed by the *empty chunk* to signal the end of the delta group:

+------------------------------------------------------------------------+
|                |             |               |             |           |
| chunk0 length  | chunk0 data | chunk1 length | chunk1 data |    0x0    |
|   (4 bytes)    |  (various)  |   (4 bytes)   |  (various)  | (4 bytes) |
|                |             |               |             |           |
+------------------------------------------------------------------------+

Each *chunk*'s data consists of the following:

+---------------------------------------+
|                        |              |
|     delta header       |  delta data  |
|  (various by version)  |  (various)   |
|                        |              |
+---------------------------------------+

The *delta data* is a series of *delta*s that describe a diff from an existing entry (either that the recipient already has, or previously specified in the bundle/changegroup).

The *delta header* is different between versions "1", "2", and "3" of the changegroup format.

Version 1 (headerlen=80):

+------------------------------------------------------+
|            |             |             |             |
|    node    |   p1 node   |   p2 node   |  link node  |
| (20 bytes) |  (20 bytes) |  (20 bytes) |  (20 bytes) |
|            |             |             |             |
+------------------------------------------------------+

Version 2 (headerlen=100):

+------------------------------------------------------------------+
|            |             |             |            |            |
|    node    |   p1 node   |   p2 node   | base node  | link node  |
| (20 bytes) |  (20 bytes) |  (20 bytes) | (20 bytes) | (20 bytes) |
|            |             |             |            |            |
+------------------------------------------------------------------+

Version 3 (headerlen=102):

+------------------------------------------------------------------------------+
|            |             |             |            |            |           |
|    node    |   p1 node   |   p2 node   | base node  | link node  |   flags   |
| (20 bytes) |  (20 bytes) |  (20 bytes) | (20 bytes) | (20 bytes) | (2 bytes) |
|            |             |             |            |            |           |
+------------------------------------------------------------------------------+

The *delta data* consists of "chunklen - 4 - headerlen" bytes, which contain a series of *delta*s, densely packed (no separators). These deltas describe a diff from an existing entry (either that the recipient already has, or previously specified in the bundle/changegroup). The format is described more fully in "hg help internals.bdiff", but briefly:

+---------------------------------------------------------------+
|              |            |            |                      |
| start offset | end offset | new length |        content       |
|  (4 bytes)   |  (4 bytes) |  (4 bytes) | (<new length> bytes) |
|              |            |            |                      |
+---------------------------------------------------------------+

Please note that the length field in the delta data does *not* include itself.

In version 1, the delta is always applied against the previous node from the changegroup or the first parent if this is the first entry in the changegroup.

In version 2 and up, the delta base node is encoded in the entry in the changegroup. This allows the delta to be expressed against any parent, which can result in smaller deltas and more efficient encoding of data.

Changeset Segment

The *changeset segment* consists of a single *delta group* holding changelog data. The *empty chunk* at the end of the *delta group* denotes the boundary to the *manifest segment*.

Manifest Segment

The *manifest segment* consists of a single *delta group* holding manifest data. If treemanifests are in use, it contains only the manifest for the root directory of the repository. Otherwise, it contains the entire manifest data. The *empty chunk* at the end of the *delta group* denotes the boundary to the next segment (either the *treemanifests segment* or the *filelogs segment*, depending on version and the request options).

Treemanifests Segment

The *treemanifests segment* only exists in changegroup version "3", and only if the 'treemanifest' param is part of the bundle2 changegroup part (it is not possible to use changegroup version 3 outside of bundle2). Aside from the filenames in the *treemanifests segment* containing a trailing "/" character, it behaves identically to the *filelogs segment* (see below). The final sub-segment is followed by an *empty chunk* (logically, a sub-segment with filename size 0). This denotes the boundary to the *filelogs segment*.

Filelogs Segment

The *filelogs segment* consists of multiple sub-segments, each corresponding to an individual file whose data is being described:

+--------------------------------------------------+
|          |          |          |     |           |
| filelog0 | filelog1 | filelog2 | ... |    0x0    |
|          |          |          |     | (4 bytes) |
|          |          |          |     |           |
+--------------------------------------------------+

The final filelog sub-segment is followed by an *empty chunk* (logically, a sub-segment with filename size 0). This denotes the end of the segment and of the overall changegroup.

Each filelog sub-segment consists of the following:

+------------------------------------------------------+
|                 |                      |             |
| filename length |       filename       | delta group |
|    (4 bytes)    | (<length - 4> bytes) |  (various)  |
|                 |                      |             |
+------------------------------------------------------+

That is, a *chunk* consisting of the filename (not terminated or padded) followed by N chunks constituting the *delta group* for this file. The *empty chunk* at the end of each *delta group* denotes the boundary to the next filelog sub-segment.