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.