This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4860

repository: define and use revision flag constants
ClosedPublic

Authored by indygreg on Oct 3 2018, 12:51 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG8e398628a3f2: repository: define and use revision flag constants
rHG731fdf6176b9: repository: define and use revision flag constants
Summary

Revlogs have a per-revision 2 byte field holding integer flags that
define how revision data should be interpreted. For historical reasons,
these integer values are sent verbatim on the wire protocol as part of
changegroup data.

From a semantic standpoint, the flags that go out over the wire are
different from the flags stored internally by revlogs. Failure to
establish this semantic distinction creates unwanted strong coupling
between revlog's internals and the wire protocol.

This commit establishes new constants on the repository module that
define the revision flags used by the wire protocol (and by some
internal storage APIs, sadly). The changegroups internals documentation
has been updated to document them explicitly. Various references
throughout the repo now use the repository constants instead of the
revlog constants. This is done to make it clear that we're operating
on generic revision data and this isn't tied to revlogs.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Oct 3 2018, 12:51 PM
indygreg updated this revision to Diff 11652.Oct 3 2018, 3:57 PM
martinvonz added a subscriber: martinvonz.Oct 3 2018, 8:11 PM
martinvonz added inline comments.
mercurial/help/internals/changegroups.txt
139–142

Add a TODO about removing this flag from the changegroup? Can be done in a followup. I'm also not sure if this is the right place for a TODO. Maybe it should be in repository.py?

indygreg added inline comments.Oct 4 2018, 12:56 PM
mercurial/help/internals/changegroups.txt
139–142

You mean removing the single integer flags field from a future changegroup v4? TBH I'm not sure we'd want to do that: bitwise fields do work for what we're using them for. It's just that we need better definitions around what flags are in play. e.g. the server should advertise revision flags that may be sent and clients should check for compatibility *before* attempting to pull data. And we need to abstract the flags in code such that we're not passing wire protocol bit flags down to the storage layer for verbatim storage, as that constricts behavior of storage backends.

martinvonz added inline comments.Oct 4 2018, 12:59 PM
mercurial/help/internals/changegroups.txt
139–142

I just mean that the "externally stored" flag doesn't seem to make sense in the wire protocol, but maybe I'm wrong?

PS. I wasn't blocking this patch based on that comment. I just happened to run out of time while reviewing this patch (but finished reviewing the earlier patches and queued them). I'll review this patch once I'm done with Boris' introrev() patches.

indygreg added inline comments.Oct 4 2018, 2:14 PM
mercurial/help/internals/changegroups.txt
139–142

"externally stored" AFAICT is code for "LFS object." I'm not sure why we didn't call it that. Regardless, the flag does need to be set for the revision because the consumer needs to know to interpret the data specially when resolving the revision fulltext.

Closed by commit rHG731fdf6176b9: repository: define and use revision flag constants (authored by indygreg). · Explain WhyOct 4 2018, 2:21 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 11652

mercurial/changegroup.py

from . import ( from . import (
error, error,
match as matchmod, match as matchmod,
mdiff, mdiff,
phases, phases,
pycompat, pycompat,
repository, repository,
revlog,
util, util,
) )
_CHANGEGROUPV1_DELTA_HEADER = struct.Struct("20s20s20s20s") _CHANGEGROUPV1_DELTA_HEADER = struct.Struct("20s20s20s20s")
_CHANGEGROUPV2_DELTA_HEADER = struct.Struct("20s20s20s20s20s") _CHANGEGROUPV2_DELTA_HEADER = struct.Struct("20s20s20s20s20s")
_CHANGEGROUPV3_DELTA_HEADER = struct.Struct(">20s20s20s20s20sH") _CHANGEGROUPV3_DELTA_HEADER = struct.Struct(">20s20s20s20s20sH")
LFS_REQUIREMENT = 'lfs' LFS_REQUIREMENT = 'lfs'
if ellipses: if ellipses:
linknode = linknodes[revision.node] linknode = linknodes[revision.node]
if revision.node in adjustedparents: if revision.node in adjustedparents:
p1node, p2node = adjustedparents[revision.node] p1node, p2node = adjustedparents[revision.node]
revision.p1node = p1node revision.p1node = p1node
revision.p2node = p2node revision.p2node = p2node
revision.flags |= revlog.REVIDX_ELLIPSIS revision.flags |= repository.REVISION_FLAG_ELLIPSIS
else: else:
linknode = lookup(revision.node) linknode = lookup(revision.node)
revision.linknode = linknode revision.linknode = linknode
yield revision yield revision
if progress: if progress:

mercurial/help/internals/changegroups.txt

Changegroups are representations of repository revlog data, specifically Changegroups are representations of repository revlog data, specifically
the changelog data, root/flat manifest data, treemanifest data, and the changelog data, root/flat manifest data, treemanifest data, and
filelogs. filelogs.
There are 3 versions of changegroups: ``1``, ``2``, and ``3``. From a 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 high-level, versions ``1`` and ``2`` are almost exactly the same, with the
only difference being an additional item in the *delta header*. Version only difference being an additional item in the *delta header*. Version
``3`` adds support for revlog flags in the *delta header* and optionally ``3`` adds support for storage flags in the *delta header* and optionally
exchanging treemanifests (enabled by setting an option on the exchanging treemanifests (enabled by setting an option on the
``changegroup`` part in the bundle2). ``changegroup`` part in the bundle2).
Changegroups when not exchanging treemanifests consist of 3 logical Changegroups when not exchanging treemanifests consist of 3 logical
segments:: segments::
+---------------------------------+ +---------------------------------+
| | | | | | | |
In version 1, the delta is always applied against the previous node from 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 the changegroup or the first parent if this is the first entry in the
changegroup. changegroup.
In version 2 and up, the delta base node is encoded in the entry in the 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, changegroup. This allows the delta to be expressed against any parent,
which can result in smaller deltas and more efficient encoding of data. 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.
martinvonzUnsubmitted
Not Done

Add a TODO about removing this flag from the changegroup? Can be done in a followup. I'm also not sure if this is the right place for a TODO. Maybe it should be in repository.py?

martinvonz: Add a TODO about removing this flag from the changegroup? Can be done in a followup. I'm also…
indygregAuthorUnsubmitted
Not Done

You mean removing the single integer flags field from a future changegroup v4? TBH I'm not sure we'd want to do that: bitwise fields do work for what we're using them for. It's just that we need better definitions around what flags are in play. e.g. the server should advertise revision flags that may be sent and clients should check for compatibility *before* attempting to pull data. And we need to abstract the flags in code such that we're not passing wire protocol bit flags down to the storage layer for verbatim storage, as that constricts behavior of storage backends.

indygreg: You mean removing the single integer flags field from a future changegroup v4? TBH I'm not sure…
martinvonzUnsubmitted
Not Done

I just mean that the "externally stored" flag doesn't seem to make sense in the wire protocol, but maybe I'm wrong?

PS. I wasn't blocking this patch based on that comment. I just happened to run out of time while reviewing this patch (but finished reviewing the earlier patches and queued them). I'll review this patch once I'm done with Boris' introrev() patches.

martinvonz: I just mean that the "externally stored" flag doesn't seem to make sense in the wire protocol…
indygregAuthorUnsubmitted
Not Done

"externally stored" AFAICT is code for "LFS object." I'm not sure why we didn't call it that. Regardless, the flag does need to be set for the revision because the consumer needs to know to interpret the data specially when resolving the revision fulltext.

indygreg: "externally stored" AFAICT is code for "LFS object." I'm not sure why we didn't call it that.
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.
Changeset Segment Changeset Segment
================= =================
The *changeset segment* consists of a single *delta group* holding The *changeset segment* consists of a single *delta group* holding
changelog data. The *empty chunk* at the end of the *delta group* denotes changelog data. The *empty chunk* at the end of the *delta group* denotes
the boundary to the *manifest segment*. the boundary to the *manifest segment*.
Manifest Segment Manifest Segment

mercurial/repository.py

REPO_FEATURE_REVLOG_FILE_STORAGE = b'revlogfilestorage' REPO_FEATURE_REVLOG_FILE_STORAGE = b'revlogfilestorage'
# The storage part of the repository is shared from an external source. # The storage part of the repository is shared from an external source.
REPO_FEATURE_SHARED_STORAGE = b'sharedstore' REPO_FEATURE_SHARED_STORAGE = b'sharedstore'
# LFS supported for backing file storage. # LFS supported for backing file storage.
REPO_FEATURE_LFS = b'lfs' REPO_FEATURE_LFS = b'lfs'
# Repository supports being stream cloned. # Repository supports being stream cloned.
REPO_FEATURE_STREAM_CLONE = b'streamclone' REPO_FEATURE_STREAM_CLONE = b'streamclone'
REVISION_FLAG_CENSORED = 1 << 15
REVISION_FLAG_ELLIPSIS = 1 << 14
REVISION_FLAG_EXTSTORED = 1 << 13
REVISION_FLAGS_KNOWN = (
REVISION_FLAG_CENSORED | REVISION_FLAG_ELLIPSIS | REVISION_FLAG_EXTSTORED)
class ipeerconnection(interfaceutil.Interface): class ipeerconnection(interfaceutil.Interface):
"""Represents a "connection" to a repository. """Represents a "connection" to a repository.
This is the base interface for representing a connection to a repository. This is the base interface for representing a connection to a repository.
It holds basic properties and methods applicable to all peer types. It holds basic properties and methods applicable to all peer types.
This is not a complete interface definition and should not be used This is not a complete interface definition and should not be used
outside of this module. outside of this module.
p2node = interfaceutil.Attribute( p2node = interfaceutil.Attribute(
"""20 byte node of 2nd parent of this revision.""") """20 byte node of 2nd parent of this revision.""")
linknode = interfaceutil.Attribute( linknode = interfaceutil.Attribute(
"""20 byte node of the changelog revision this node is linked to.""") """20 byte node of the changelog revision this node is linked to.""")
flags = interfaceutil.Attribute( flags = interfaceutil.Attribute(
"""2 bytes of integer flags that apply to this revision.""") """2 bytes of integer flags that apply to this revision.
This is a bitwise composition of the ``REVISION_FLAG_*`` constants.
""")
basenode = interfaceutil.Attribute( basenode = interfaceutil.Attribute(
"""20 byte node of the revision this data is a delta against. """20 byte node of the revision this data is a delta against.
``nullid`` indicates that the revision is a full revision and not ``nullid`` indicates that the revision is a full revision and not
a delta. a delta.
""") """)
flags=0, cachedelta=None): flags=0, cachedelta=None):
"""Add a new revision to the store. """Add a new revision to the store.
This is similar to ``add()`` except it operates at a lower level. This is similar to ``add()`` except it operates at a lower level.
The data passed in already contains a metadata header, if any. The data passed in already contains a metadata header, if any.
``node`` and ``flags`` can be used to define the expected node and ``node`` and ``flags`` can be used to define the expected node and
the flags to use with storage. the flags to use with storage. ``flags`` is a bitwise value composed
of the various ``REVISION_FLAG_*`` constants.
``add()`` is usually called when adding files from e.g. the working ``add()`` is usually called when adding files from e.g. the working
directory. ``addrevision()`` is often called by ``add()`` and for directory. ``addrevision()`` is often called by ``add()`` and for
scenarios where revision data has already been computed, such as when scenarios where revision data has already been computed, such as when
applying raw data from a peer repo. applying raw data from a peer repo.
""" """
def addgroup(deltas, linkmapper, transaction, addrevisioncb=None): def addgroup(deltas, linkmapper, transaction, addrevisioncb=None):

mercurial/revlogutils/constants.py

# revlogdeltas.py - constant used for revlog logic # revlogdeltas.py - constant used for revlog logic
# #
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# Copyright 2018 Octobus <contact@octobus.net> # Copyright 2018 Octobus <contact@octobus.net>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
"""Helper class to compute deltas stored inside revlogs""" """Helper class to compute deltas stored inside revlogs"""
from __future__ import absolute_import from __future__ import absolute_import
from .. import ( from .. import (
repository,
util, util,
) )
# revlog header flags # revlog header flags
REVLOGV0 = 0 REVLOGV0 = 0
REVLOGV1 = 1 REVLOGV1 = 1
# Dummy value until file format is finalized. # Dummy value until file format is finalized.
# Reminder: change the bounds check in revlog.__init__ when this is changed. # Reminder: change the bounds check in revlog.__init__ when this is changed.
REVLOGV2 = 0xDEAD REVLOGV2 = 0xDEAD
FLAG_INLINE_DATA = (1 << 16) FLAG_INLINE_DATA = (1 << 16)
FLAG_GENERALDELTA = (1 << 17) FLAG_GENERALDELTA = (1 << 17)
REVLOG_DEFAULT_FLAGS = FLAG_INLINE_DATA REVLOG_DEFAULT_FLAGS = FLAG_INLINE_DATA
REVLOG_DEFAULT_FORMAT = REVLOGV1 REVLOG_DEFAULT_FORMAT = REVLOGV1
REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT | REVLOG_DEFAULT_FLAGS REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT | REVLOG_DEFAULT_FLAGS
REVLOGV1_FLAGS = FLAG_INLINE_DATA | FLAG_GENERALDELTA REVLOGV1_FLAGS = FLAG_INLINE_DATA | FLAG_GENERALDELTA
REVLOGV2_FLAGS = REVLOGV1_FLAGS REVLOGV2_FLAGS = REVLOGV1_FLAGS
# revlog index flags # revlog index flags
REVIDX_ISCENSORED = (1 << 15) # revision has censor metadata, must be verified
REVIDX_ELLIPSIS = (1 << 14) # revision hash does not match data (narrowhg) # For historical reasons, revlog's internal flags were exposed via the
REVIDX_EXTSTORED = (1 << 13) # revision data is stored externally # wire protocol and are even exposed in parts of the storage APIs.
# revision has censor metadata, must be verified
REVIDX_ISCENSORED = repository.REVISION_FLAG_CENSORED
# revision hash does not match data (narrowhg)
REVIDX_ELLIPSIS = repository.REVISION_FLAG_ELLIPSIS
# revision data is stored externally
REVIDX_EXTSTORED = repository.REVISION_FLAG_EXTSTORED
REVIDX_DEFAULT_FLAGS = 0 REVIDX_DEFAULT_FLAGS = 0
# stable order in which flags need to be processed and their processors applied # stable order in which flags need to be processed and their processors applied
REVIDX_FLAGS_ORDER = [ REVIDX_FLAGS_ORDER = [
REVIDX_ISCENSORED, REVIDX_ISCENSORED,
REVIDX_ELLIPSIS, REVIDX_ELLIPSIS,
REVIDX_EXTSTORED, REVIDX_EXTSTORED,
] ]
REVIDX_KNOWN_FLAGS = util.bitsfrom(REVIDX_FLAGS_ORDER) REVIDX_KNOWN_FLAGS = util.bitsfrom(REVIDX_FLAGS_ORDER)
# bitmark for flags that could cause rawdata content change # bitmark for flags that could cause rawdata content change
REVIDX_RAWTEXT_CHANGING_FLAGS = REVIDX_ISCENSORED | REVIDX_EXTSTORED REVIDX_RAWTEXT_CHANGING_FLAGS = REVIDX_ISCENSORED | REVIDX_EXTSTORED
SPARSE_REVLOG_MAX_CHAIN_LENGTH = 1000 SPARSE_REVLOG_MAX_CHAIN_LENGTH = 1000

mercurial/testing/storage.py

from ..node import ( from ..node import (
hex, hex,
nullid, nullid,
nullrev, nullrev,
) )
from .. import ( from .. import (
error, error,
mdiff, mdiff,
revlog, repository,
) )
from ..utils import ( from ..utils import (
storageutil, storageutil,
) )
class basetestcase(unittest.TestCase): class basetestcase(unittest.TestCase):
if not getattr(unittest.TestCase, r'assertRaisesRegex', False): if not getattr(unittest.TestCase, r'assertRaisesRegex', False):
assertRaisesRegex = (# camelcase-required assertRaisesRegex = (# camelcase-required
}, b'') }, b'')
# TODO tests are incomplete because we need the node to be # TODO tests are incomplete because we need the node to be
# different due to presence of censor metadata. But we can't # different due to presence of censor metadata. But we can't
# do this with addrevision(). # do this with addrevision().
with self._maketransactionfn() as tr: with self._maketransactionfn() as tr:
node0 = f.add(b'foo', None, tr, 0, nullid, nullid) node0 = f.add(b'foo', None, tr, 0, nullid, nullid)
f.addrevision(stored1, tr, 1, node0, nullid, f.addrevision(stored1, tr, 1, node0, nullid,
flags=revlog.REVIDX_ISCENSORED) flags=repository.REVISION_FLAG_CENSORED)
self.assertTrue(f.iscensored(1)) self.assertTrue(f.iscensored(1))
self.assertEqual(f.revision(1), stored1) self.assertEqual(f.revision(1), stored1)
self.assertEqual(f.revision(1, raw=True), stored1) self.assertEqual(f.revision(1, raw=True), stored1)
self.assertEqual(f.read(1), b'') self.assertEqual(f.read(1), b'')
# Adding a revision with bad node value fails. # Adding a revision with bad node value fails.
with self.assertRaises(error.StorageError): with self.assertRaises(error.StorageError):
f.addrevision(b'foo', tr, 0, nullid, nullid, node=b'\x01' * 20) f.addrevision(b'foo', tr, 0, nullid, nullid, node=b'\x01' * 20)
def testaddrevisionunknownflag(self): def testaddrevisionunknownflag(self):
f = self._makefilefn() f = self._makefilefn()
with self._maketransactionfn() as tr: with self._maketransactionfn() as tr:
for i in range(15, 0, -1): for i in range(15, 0, -1):
if (1 << i) & ~revlog.REVIDX_KNOWN_FLAGS: if (1 << i) & ~repository.REVISION_FLAGS_KNOWN:
flags = 1 << i flags = 1 << i
break break
with self.assertRaises(error.StorageError): with self.assertRaises(error.StorageError):
f.addrevision(b'foo', tr, 0, nullid, nullid, flags=flags) f.addrevision(b'foo', tr, 0, nullid, nullid, flags=flags)
def testaddgroupsimple(self): def testaddgroupsimple(self):
f = self._makefilefn() f = self._makefilefn()

tests/simplestorerepo.py

if self.iscensored(rev): if self.iscensored(rev):
return 0 return 0
return len(self.revision(node)) return len(self.revision(node))
def iscensored(self, rev): def iscensored(self, rev):
validaterev(rev) validaterev(rev)
return self._flags(rev) & revlog.REVIDX_ISCENSORED return self._flags(rev) & repository.REVISION_FLAG_CENSORED
def commonancestorsheads(self, a, b): def commonancestorsheads(self, a, b):
validatenode(a) validatenode(a)
validatenode(b) validatenode(b)
a = self.rev(a) a = self.rev(a)
b = self.rev(b) b = self.rev(b)

tests/test-help.t

"""""""""""" """"""""""""
Changegroups are representations of repository revlog data, specifically Changegroups are representations of repository revlog data, specifically
the changelog data, root/flat manifest data, treemanifest data, and the changelog data, root/flat manifest data, treemanifest data, and
filelogs. filelogs.
There are 3 versions of changegroups: "1", "2", and "3". From a high- 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 level, versions "1" and "2" are almost exactly the same, with the only
difference being an additional item in the *delta header*. Version "3" difference being an additional item in the *delta header*. Version "3"
adds support for revlog flags in the *delta header* and optionally adds support for storage flags in the *delta header* and optionally
exchanging treemanifests (enabled by setting an option on the exchanging treemanifests (enabled by setting an option on the
"changegroup" part in the bundle2). "changegroup" part in the bundle2).
Changegroups when not exchanging treemanifests consist of 3 logical Changegroups when not exchanging treemanifests consist of 3 logical
segments: segments:
+---------------------------------+ +---------------------------------+
| | | | | | | |
In version 1, the delta is always applied against the previous node from 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 the changegroup or the first parent if this is the first entry in the
changegroup. changegroup.
In version 2 and up, the delta base node is encoded in the entry in the 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, changegroup. This allows the delta to be expressed against any parent,
which can result in smaller deltas and more efficient encoding of data. 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.
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.
Changeset Segment Changeset Segment
================= =================
The *changeset segment* consists of a single *delta group* holding The *changeset segment* consists of a single *delta group* holding
changelog data. The *empty chunk* at the end of the *delta group* denotes changelog data. The *empty chunk* at the end of the *delta group* denotes
the boundary to the *manifest segment*. the boundary to the *manifest segment*.
Manifest Segment Manifest Segment
<p> <p>
Changegroups are representations of repository revlog data, specifically Changegroups are representations of repository revlog data, specifically
the changelog data, root/flat manifest data, treemanifest data, and the changelog data, root/flat manifest data, treemanifest data, and
filelogs. filelogs.
</p> </p>
<p> <p>
There are 3 versions of changegroups: &quot;1&quot;, &quot;2&quot;, and &quot;3&quot;. From a There are 3 versions of changegroups: &quot;1&quot;, &quot;2&quot;, and &quot;3&quot;. From a
high-level, versions &quot;1&quot; and &quot;2&quot; are almost exactly the same, with the high-level, versions &quot;1&quot; and &quot;2&quot; are almost exactly the same, with the
only difference being an additional item in the *delta header*. Version only difference being an additional item in the *delta header*. Version
&quot;3&quot; adds support for revlog flags in the *delta header* and optionally &quot;3&quot; adds support for storage flags in the *delta header* and optionally
exchanging treemanifests (enabled by setting an option on the exchanging treemanifests (enabled by setting an option on the
&quot;changegroup&quot; part in the bundle2). &quot;changegroup&quot; part in the bundle2).
</p> </p>
<p> <p>
Changegroups when not exchanging treemanifests consist of 3 logical Changegroups when not exchanging treemanifests consist of 3 logical
segments: segments:
</p> </p>
<pre> <pre>
the changegroup or the first parent if this is the first entry in the the changegroup or the first parent if this is the first entry in the
changegroup. changegroup.
</p> </p>
<p> <p>
In version 2 and up, the delta base node is encoded in the entry in the 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, changegroup. This allows the delta to be expressed against any parent,
which can result in smaller deltas and more efficient encoding of data. which can result in smaller deltas and more efficient encoding of data.
</p> </p>
<p>
The *flags* field holds bitwise flags affecting the processing of revision
data. The following flags are defined:
</p>
<dl>
<dt>32768
<dd>Censored revision. The revision's fulltext has been replaced by censor metadata. May only occur on file revisions.
<dt>16384
<dd>Ellipsis revision. Revision hash does not match data (likely due to rewritten parents).
<dt>8192
<dd>Externally stored. The revision fulltext contains &quot;key:value&quot; &quot;\n&quot; delimited metadata defining an object stored elsewhere. Used by the LFS extension.
</dl>
<p>
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.
</p>
<h2>Changeset Segment</h2> <h2>Changeset Segment</h2>
<p> <p>
The *changeset segment* consists of a single *delta group* holding The *changeset segment* consists of a single *delta group* holding
changelog data. The *empty chunk* at the end of the *delta group* denotes changelog data. The *empty chunk* at the end of the *delta group* denotes
the boundary to the *manifest segment*. the boundary to the *manifest segment*.
</p> </p>
<h2>Manifest Segment</h2> <h2>Manifest Segment</h2>
<p> <p>