This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10792

revlog: move `offset_type` to `revlogutils`
ClosedPublic

Authored by marmoute on May 30 2021, 1:29 PM.

Details

Reviewers
indygreg
Alphare
Group Reviewers
hg-reviewers
Commits
rHGac60a1366a49: revlog: move `offset_type` to `revlogutils`
Summary

This multiple module are using this so it make sense to move it at the utility
level.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.May 30 2021, 1:29 PM
baymax updated this revision to Diff 28305.May 31 2021, 6:51 AM

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

Alphare requested changes to this revision.May 31 2021, 10:40 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
tests/flagprocessorext.py
135

Seems unrelated?

This revision now requires changes to proceed.May 31 2021, 10:40 AM
baymax updated this revision to Diff 28320.May 31 2021, 4:21 PM

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

baymax updated this revision to Diff 28402.Jun 1 2021, 11:17 PM

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

baymax updated this revision to Diff 28417.Jun 2 2021, 7:43 AM

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

marmoute added inline comments.Jun 4 2021, 9:20 AM
tests/flagprocessorext.py
135

This is related. This offset_type use a different "constant" we need to make sure it is up to date too (because it was not up to date previously)

baymax updated this revision to Diff 28451.Jun 4 2021, 11:05 AM

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

baymax updated this revision to Diff 28473.Jun 7 2021, 5:16 AM

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

marmoute added a commit: rHGac60a1366a49: revlog: move `offset_type` to `revlogutils`.Jun 7 2021, 5:24 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGac60a1366a49: revlog: move `offset_type` to `revlogutils` (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 28495

mercurial/bundlerepo.py

filelog, filelog,
localrepo, localrepo,
manifest, manifest,
mdiff, mdiff,
pathutil, pathutil,
phases, phases,
pycompat, pycompat,
revlog, revlog,
revlogutils,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from .utils import ( from .utils import (
urlutil, urlutil,
) )
from .revlogutils import ( from .revlogutils import (
if not self.index.has_node(deltabase): if not self.index.has_node(deltabase):
raise LookupError( raise LookupError(
deltabase, self.display_id, _(b'unknown delta base') deltabase, self.display_id, _(b'unknown delta base')
) )
baserev = self.rev(deltabase) baserev = self.rev(deltabase)
# start, size, full unc. size, base (unused), link, p1, p2, node, sidedata_offset (unused), sidedata_size (unused) # start, size, full unc. size, base (unused), link, p1, p2, node, sidedata_offset (unused), sidedata_size (unused)
e = ( e = (
revlog.offset_type(start, flags), revlogutils.offset_type(start, flags),
size, size,
-1, -1,
baserev, baserev,
linkrev, linkrev,
self.rev(p1), self.rev(p1),
self.rev(p2), self.rev(p2),
node, node,
0, 0,

mercurial/pure/parsers.py

from ..node import ( from ..node import (
nullrev, nullrev,
sha1nodeconstants, sha1nodeconstants,
) )
from .. import ( from .. import (
error, error,
pycompat, pycompat,
revlogutils,
util, util,
) )
from ..revlogutils import nodemap as nodemaputil from ..revlogutils import nodemap as nodemaputil
from ..revlogutils import constants as revlog_constants from ..revlogutils import constants as revlog_constants
stringio = pycompat.bytesio stringio = pycompat.bytesio
# x is a tuple # x is a tuple
return x return x
def gettype(q): def gettype(q):
return int(q & 0xFFFF) return int(q & 0xFFFF)
def offset_type(offset, type):
return int(int(offset) << 16 | type)
class BaseIndexObject(object): class BaseIndexObject(object):
# Can I be passed to an algorithme implemented in Rust ? # Can I be passed to an algorithme implemented in Rust ?
rust_ext_compat = 0 rust_ext_compat = 0
# Format of an index entry according to Python's `struct` language # Format of an index entry according to Python's `struct` language
index_format = revlog_constants.INDEX_ENTRY_V1 index_format = revlog_constants.INDEX_ENTRY_V1
# Size of a C unsigned long long int, platform independent # Size of a C unsigned long long int, platform independent
big_int_size = struct.calcsize(b'>Q') big_int_size = struct.calcsize(b'>Q')
# Size of a C long int, platform independent # Size of a C long int, platform independent
self._check_index(i) self._check_index(i)
if i >= self._lgt: if i >= self._lgt:
data = self._extra[i - self._lgt] data = self._extra[i - self._lgt]
else: else:
index = self._calculate_index(i) index = self._calculate_index(i)
data = self._data[index : index + self.entry_size] data = self._data[index : index + self.entry_size]
r = self._unpack_entry(i, data) r = self._unpack_entry(i, data)
if self._lgt and i == 0: if self._lgt and i == 0:
r = (offset_type(0, gettype(r[0])),) + r[1:] offset = revlogutils.offset_type(0, gettype(r[0]))
r = (offset,) + r[1:]
return r return r
def _unpack_entry(self, rev, data): def _unpack_entry(self, rev, data):
r = self.index_format.unpack(data) r = self.index_format.unpack(data)
r = r + ( r = r + (
0, 0,
0, 0,
revlog_constants.COMP_MODE_INLINE, revlog_constants.COMP_MODE_INLINE,

mercurial/revlog.py

from .thirdparty import attr from .thirdparty import attr
from . import ( from . import (
ancestor, ancestor,
dagop, dagop,
error, error,
mdiff, mdiff,
policy, policy,
pycompat, pycompat,
revlogutils,
templatefilters, templatefilters,
util, util,
) )
from .interfaces import ( from .interfaces import (
repository, repository,
util as interfaceutil, util as interfaceutil,
) )
from .revlogutils import ( from .revlogutils import (
ellipsisprocessor = ( ellipsisprocessor = (
ellipsisreadprocessor, ellipsisreadprocessor,
ellipsiswriteprocessor, ellipsiswriteprocessor,
ellipsisrawprocessor, ellipsisrawprocessor,
) )
def offset_type(offset, type):
if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0:
raise ValueError(b'unknown revlog index flags')
return int(int(offset) << 16 | type)
def _verify_revision(rl, skipflags, state, node): def _verify_revision(rl, skipflags, state, node):
"""Verify the integrity of the given revlog ``node`` while providing a hook """Verify the integrity of the given revlog ``node`` while providing a hook
point for extensions to influence the operation.""" point for extensions to influence the operation."""
if skipflags: if skipflags:
state[b'skipread'].add(node) state[b'skipread'].add(node)
else: else:
# Side-effect: read content and verify hash. # Side-effect: read content and verify hash.
rl.revision(node) rl.revision(node)
else: else:
serialized_sidedata = b"" serialized_sidedata = b""
# Don't store the offset if the sidedata is empty, that way # Don't store the offset if the sidedata is empty, that way
# we can easily detect empty sidedata and they will be no different # we can easily detect empty sidedata and they will be no different
# than ones we manually add. # than ones we manually add.
sidedata_offset = 0 sidedata_offset = 0
e = ( e = (
offset_type(offset, flags), revlogutils.offset_type(offset, flags),
deltainfo.deltalen, deltainfo.deltalen,
textlen, textlen,
deltainfo.base, deltainfo.base,
link, link,
p1r, p1r,
p2r, p2r,
node, node,
sidedata_offset, sidedata_offset,

mercurial/revlogutils/__init__.py

# mercurial.revlogutils -- basic utilities for revlog # mercurial.revlogutils -- basic utilities for revlog
# #
# Copyright 2019 Pierre-Yves David <pierre-yves.david@octobus.net> # Copyright 2019 Pierre-Yves David <pierre-yves.david@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.
from __future__ import absolute_import from __future__ import absolute_import
from ..interfaces import repository
def offset_type(offset, type):
if (type & ~repository.REVISION_FLAGS_KNOWN) != 0:
raise ValueError(b'unknown revlog index flags: %d' % type)
return int(int(offset) << 16 | type)

mercurial/revlogutils/revlogv0.py

INDEX_ENTRY_V0, INDEX_ENTRY_V0,
) )
from ..i18n import _ from ..i18n import _
from .. import ( from .. import (
error, error,
node, node,
pycompat, pycompat,
revlogutils,
util, util,
) )
from . import ( from . import (
flagutil, flagutil,
nodemap as nodemaputil, nodemap as nodemaputil,
) )
def getoffset(q): def getoffset(q):
return int(q >> 16) return int(q >> 16)
def gettype(q): def gettype(q):
return int(q & 0xFFFF) return int(q & 0xFFFF)
def offset_type(offset, type):
if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0:
raise ValueError(b'unknown revlog index flags')
return int(int(offset) << 16 | type)
class revlogoldindex(list): class revlogoldindex(list):
rust_ext_compat = 0 rust_ext_compat = 0
entry_size = INDEX_ENTRY_V0.size entry_size = INDEX_ENTRY_V0.size
null_item = ( null_item = (
0, 0,
0, 0,
0, 0,
-1, -1,
n = off = 0 n = off = 0
l = len(data) l = len(data)
while off + s <= l: while off + s <= l:
cur = data[off : off + s] cur = data[off : off + s]
off += s off += s
e = INDEX_ENTRY_V0.unpack(cur) e = INDEX_ENTRY_V0.unpack(cur)
# transform to revlogv1 format # transform to revlogv1 format
e2 = ( e2 = (
offset_type(e[0], 0), revlogutils.offset_type(e[0], 0),
e[1], e[1],
-1, -1,
e[2], e[2],
e[3], e[3],
nodemap.get(e[4], node.nullrev), nodemap.get(e[4], node.nullrev),
nodemap.get(e[5], node.nullrev), nodemap.get(e[5], node.nullrev),
e[6], e[6],
0, # no side data support 0, # no side data support

tests/flagprocessorext.py

# coding=UTF-8 # coding=UTF-8
from __future__ import absolute_import from __future__ import absolute_import
import base64 import base64
import zlib import zlib
from mercurial import ( from mercurial import (
bundlecaches, bundlecaches,
changegroup, changegroup,
extensions, extensions,
revlog, revlog,
util, util,
) )
from mercurial.revlogutils import flagutil from mercurial.revlogutils import flagutil
from mercurial.interfaces import repository
# Test only: These flags are defined here only in the context of testing the # Test only: These flags are defined here only in the context of testing the
# behavior of the flag processor. The canonical way to add flags is to get in # behavior of the flag processor. The canonical way to add flags is to get in
# touch with the community and make them known in revlog. # touch with the community and make them known in revlog.
REVIDX_NOOP = 1 << 3 REVIDX_NOOP = 1 << 3
REVIDX_BASE64 = 1 << 2 REVIDX_BASE64 = 1 << 2
REVIDX_GZIP = 1 << 1 REVIDX_GZIP = 1 << 1
REVIDX_FAIL = 1 REVIDX_FAIL = 1
wrapfunction( wrapfunction(
changegroup, 'supportedoutgoingversions', supportedoutgoingversions changegroup, 'supportedoutgoingversions', supportedoutgoingversions
) )
wrapfunction(changegroup, 'allsupportedversions', allsupportedversions) wrapfunction(changegroup, 'allsupportedversions', allsupportedversions)
# Teach revlog about our test flags # Teach revlog about our test flags
flags = [REVIDX_NOOP, REVIDX_BASE64, REVIDX_GZIP, REVIDX_FAIL] flags = [REVIDX_NOOP, REVIDX_BASE64, REVIDX_GZIP, REVIDX_FAIL]
flagutil.REVIDX_KNOWN_FLAGS |= util.bitsfrom(flags) flagutil.REVIDX_KNOWN_FLAGS |= util.bitsfrom(flags)
repository.REVISION_FLAGS_KNOWN |= util.bitsfrom(flags)
AlphareUnsubmitted
Not Done

Seems unrelated?

Alphare: Seems unrelated?
marmouteAuthorUnsubmitted
Done

This is related. This offset_type use a different "constant" we need to make sure it is up to date too (because it was not up to date previously)

marmoute: This is related. This offset_type use a different "constant" we need to make sure it is up to…
revlog.REVIDX_FLAGS_ORDER.extend(flags) revlog.REVIDX_FLAGS_ORDER.extend(flags)
# Teach exchange to use changegroup 3 # Teach exchange to use changegroup 3
for k in bundlecaches._bundlespeccontentopts.keys(): for k in bundlecaches._bundlespeccontentopts.keys():
bundlecaches._bundlespeccontentopts[k][b"cg.version"] = b"03" bundlecaches._bundlespeccontentopts[k][b"cg.version"] = b"03"
# Register flag processors for each extension # Register flag processors for each extension
flagutil.addflagprocessor( flagutil.addflagprocessor(