( )⚙ D10663 changelogv2: use a dedicated version number

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10663

changelogv2: use a dedicated version number
ClosedPublic

Authored by marmoute on May 4 2021, 10:16 AM.

Details

Reviewers
indygreg
Alphare
Group Reviewers
hg-reviewers
Commits
rHG921648d31553: changelogv2: use a dedicated version number
Summary

If we want to change the format, we need a new version number. We start with
that.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

marmoute created this revision.May 4 2021, 10:16 AM
marmoute updated this revision to Diff 27619.May 6 2021, 5:22 AM
baymax updated this revision to Diff 27902.May 11 2021, 1:47 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Alphare accepted this revision.May 17 2021, 5:49 PM
This revision is now accepted and ready to land.May 17 2021, 5:49 PM
marmoute added a commit: rHG921648d31553: changelogv2: use a dedicated version number.May 17 2021, 5:58 PM
Closed by commit rHG921648d31553: changelogv2: use a dedicated version number (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 27902

mercurial/revlog.py

sha1nodeconstants, sha1nodeconstants,
short, short,
wdirrev, wdirrev,
) )
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .revlogutils.constants import ( from .revlogutils.constants import (
ALL_KINDS, ALL_KINDS,
CHANGELOGV2,
COMP_MODE_DEFAULT, COMP_MODE_DEFAULT,
COMP_MODE_INLINE, COMP_MODE_INLINE,
COMP_MODE_PLAIN, COMP_MODE_PLAIN,
FEATURES_BY_VERSION, FEATURES_BY_VERSION,
FLAG_GENERALDELTA, FLAG_GENERALDELTA,
FLAG_INLINE_DATA, FLAG_INLINE_DATA,
INDEX_HEADER, INDEX_HEADER,
KIND_CHANGELOG, KIND_CHANGELOG,
* force_nodemap: * force_nodemap:
force the usage of a "development" version of the nodemap code force the usage of a "development" version of the nodemap code
""" """
mmapindexthreshold = None mmapindexthreshold = None
opts = self.opener.options opts = self.opener.options
if b'changelogv2' in opts and self.revlog_kind == KIND_CHANGELOG: if b'changelogv2' in opts and self.revlog_kind == KIND_CHANGELOG:
new_header = REVLOGV2 new_header = CHANGELOGV2
elif b'revlogv2' in opts: elif b'revlogv2' in opts:
new_header = REVLOGV2 new_header = REVLOGV2
elif b'revlogv1' in opts: elif b'revlogv1' in opts:
new_header = REVLOGV1 | FLAG_INLINE_DATA new_header = REVLOGV1 | FLAG_INLINE_DATA
if b'generaldelta' in opts: if b'generaldelta' in opts:
new_header |= FLAG_GENERALDELTA new_header |= FLAG_GENERALDELTA
elif b'revlogv0' in self.opener.options: elif b'revlogv0' in self.opener.options:
new_header = REVLOGV0 new_header = REVLOGV0
else: else:
use_rust_index = self.opener.options.get(b'rust.index') use_rust_index = self.opener.options.get(b'rust.index')
self._parse_index = parse_index_v1 self._parse_index = parse_index_v1
if self._format_version == REVLOGV0: if self._format_version == REVLOGV0:
self._parse_index = revlogv0.parse_index_v0 self._parse_index = revlogv0.parse_index_v0
elif self._format_version == REVLOGV2: elif self._format_version == REVLOGV2:
self._parse_index = parse_index_v2 self._parse_index = parse_index_v2
elif self._format_version == CHANGELOGV2:
self._parse_index = parse_index_v2
elif devel_nodemap: elif devel_nodemap:
self._parse_index = parse_index_v1_nodemap self._parse_index = parse_index_v1_nodemap
elif use_rust_index: elif use_rust_index:
self._parse_index = parse_index_v1_mixed self._parse_index = parse_index_v1_mixed
try: try:
d = self._parse_index(index_data, self._inline) d = self._parse_index(index_data, self._inline)
index, _chunkcache = d index, _chunkcache = d
use_nodemap = ( use_nodemap = (

mercurial/revlogutils/constants.py

INDEX_HEADER = struct.Struct(b">I") INDEX_HEADER = struct.Struct(b">I")
## revlog version ## revlog version
REVLOGV0 = 0 REVLOGV0 = 0
REVLOGV1 = 1 REVLOGV1 = 1
# Dummy value until file format is finalized. # Dummy value until file format is finalized.
REVLOGV2 = 0xDEAD REVLOGV2 = 0xDEAD
# Dummy value until file format is finalized.
CHANGELOGV2 = 0xD34D
## global revlog header flags ## global revlog header flags
# Shared across v1 and v2. # Shared across v1 and v2.
FLAG_INLINE_DATA = 1 << 16 FLAG_INLINE_DATA = 1 << 16
# Only used by v1, implied by v2. # Only used by v1, implied by v2.
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
REVLOGV0_FLAGS = 0 REVLOGV0_FLAGS = 0
REVLOGV1_FLAGS = FLAG_INLINE_DATA | FLAG_GENERALDELTA REVLOGV1_FLAGS = FLAG_INLINE_DATA | FLAG_GENERALDELTA
REVLOGV2_FLAGS = FLAG_INLINE_DATA REVLOGV2_FLAGS = FLAG_INLINE_DATA
CHANGELOGV2_FLAGS = 0
### individual entry ### individual entry
## index v0: ## index v0:
# 4 bytes: offset # 4 bytes: offset
# 4 bytes: compressed length # 4 bytes: compressed length
# 4 bytes: base rev # 4 bytes: base rev
# 4 bytes: link rev # 4 bytes: link rev
# Chunk use a compression mode stored "inline" at the start of the chunk # Chunk use a compression mode stored "inline" at the start of the chunk
# itself. This is the mode always used for revlog version "0" and "1" # itself. This is the mode always used for revlog version "0" and "1"
COMP_MODE_INLINE = 2 COMP_MODE_INLINE = 2
SUPPORTED_FLAGS = { SUPPORTED_FLAGS = {
REVLOGV0: REVLOGV0_FLAGS, REVLOGV0: REVLOGV0_FLAGS,
REVLOGV1: REVLOGV1_FLAGS, REVLOGV1: REVLOGV1_FLAGS,
REVLOGV2: REVLOGV2_FLAGS, REVLOGV2: REVLOGV2_FLAGS,
CHANGELOGV2: CHANGELOGV2_FLAGS,
} }
_no = lambda flags: False _no = lambda flags: False
_yes = lambda flags: True _yes = lambda flags: True
def _from_flag(flag): def _from_flag(flag):
return lambda flags: bool(flags & flag) return lambda flags: bool(flags & flag)
# The point of inline-revlog is to reduce the number of files used in # The point of inline-revlog is to reduce the number of files used in
# the store. Using a docket defeat this purpose. So we needs other # the store. Using a docket defeat this purpose. So we needs other
# means to reduce the number of files for revlogv2. # means to reduce the number of files for revlogv2.
b'inline': _no, b'inline': _no,
b'generaldelta': _yes, b'generaldelta': _yes,
b'sidedata': True, b'sidedata': True,
b'docket': True, b'docket': True,
}, },
CHANGELOGV2: {
b'inline': _no,
# General delta is useless for changelog since we don't do any delta
b'generaldelta': _no,
b'sidedata': True,
b'docket': True,
},
} }
SPARSE_REVLOG_MAX_CHAIN_LENGTH = 1000 SPARSE_REVLOG_MAX_CHAIN_LENGTH = 1000

mercurial/revlogutils/docket.py

self._data_end, self._data_end,
self.default_compression_header, self.default_compression_header,
) )
return S_HEADER.pack(*data) return S_HEADER.pack(*data)
def default_docket(revlog, version_header): def default_docket(revlog, version_header):
"""given a revlog version a new docket object for the given revlog""" """given a revlog version a new docket object for the given revlog"""
if (version_header & 0xFFFF) != constants.REVLOGV2: rl_version = version_header & 0xFFFF
if rl_version not in (constants.REVLOGV2, constants.CHANGELOGV2):
return None return None
comp = util.compengines[revlog._compengine].revlogheader() comp = util.compengines[revlog._compengine].revlogheader()
docket = RevlogDocket( docket = RevlogDocket(
revlog, revlog,
version_header=version_header, version_header=version_header,
default_compression_header=comp, default_compression_header=comp,
) )
docket._dirty = True docket._dirty = True