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

There are 4 versions of changegroups: ``1``, ``2``, ``3`` and ``4``. 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 storage flags in the *delta header* and optionally
exchanging treemanifests (enabled by setting an option on the
``changegroup`` part in the bundle2). Version ``4`` adds support for exchanging
sidedata (additional revision metadata not part of the digest).

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``, ``3`` and ``4``
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) |
   |            |             |             |            |            |           |
   +------------------------------------------------------------------------------+

Version 4 (headerlen=103)::

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

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.

The *flags* field holds bitwise flags affecting the processing of revision
data. The following flags are defined:

32768
   Censored revision. The revision's fulltext has been replaced by censor
   metadata. May only occur on file revisions.
16384
   Ellipsis revision. Revision hash does not match data (likely due to rewritten
   parents).
8192
   Externally stored. The revision fulltext contains ``key:value`` ``\n``
   delimited metadata defining an object stored elsewhere. Used by the LFS
   extension.
4096
   Contains copy information. This revision changes files in a way that could
   affect copy tracing. This does *not* affect changegroup handling, but is
   relevant for other parts of Mercurial.

For historical reasons, the integer values are identical to revlog version 1
per-revision storage flags and correspond to bits being set in this 2-byte
field. Bits were allocated starting from the most-significant bit, hence the
reverse ordering and allocation of these flags.

The *pflags* (protocol flags) field holds bitwise flags affecting the protocol
itself. They are first in the header since they may affect the handling of the
rest of the fields in a future version. They are defined as such:

1 indicates whether to read a chunk of sidedata (of variable length) right
  after the revision flags.


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 ``4``,
and only if the 'treemanifest' param is part of the bundle2 changegroup part
(it is not possible to use changegroup version 3 or 4 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.
