( )⚙ D10353 revlog: replace the old `revlog_kind` approach with the new `target` one

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10353

revlog: replace the old `revlog_kind` approach with the new `target` one
ClosedPublic

Authored by Alphare on Apr 9 2021, 8:30 AM.

Details

Reviewers
indygreg
marmoute
Group Reviewers
hg-reviewers
Commits
rHG64cd1496bb70: revlog: replace the old `revlog_kind` approach with the new `target` one
Summary

The new target attribute supersedes the previous one.

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

Alphare created this revision.Apr 9 2021, 8:30 AM
marmoute accepted this revision.Apr 19 2021, 8:44 AM
marmoute added a subscriber: marmoute.

I co-authored this revision with Alphare. So I am accepting it on the behalf of both of use since it already got two pairs on eyes on it.

baymax updated this revision to Diff 27093.Apr 20 2021, 5:55 AM

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

baymax updated this revision to Diff 27095.Apr 20 2021, 9:33 AM

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

baymax updated this revision to Diff 27224.Apr 30 2021, 6:52 AM

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

baymax updated this revision to Diff 27296.May 3 2021, 4:14 AM

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

baymax updated this revision to Diff 27465.May 3 2021, 9:02 PM

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

marmoute added a commit: rHG64cd1496bb70: revlog: replace the old `revlog_kind` approach with the new `target` one.May 5 2021, 6:38 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG64cd1496bb70: revlog: replace the old `revlog_kind` approach with the new `target` one (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 27599

mercurial/changegroup.py

pycompat, pycompat,
requirements, requirements,
scmutil, scmutil,
util, util,
) )
from .interfaces import repository from .interfaces import repository
from .revlogutils import sidedata as sidedatamod from .revlogutils import sidedata as sidedatamod
from .revlogutils import constants as revlog_constants
_CHANGEGROUPV1_DELTA_HEADER = struct.Struct(b"20s20s20s20s") _CHANGEGROUPV1_DELTA_HEADER = struct.Struct(b"20s20s20s20s")
_CHANGEGROUPV2_DELTA_HEADER = struct.Struct(b"20s20s20s20s20s") _CHANGEGROUPV2_DELTA_HEADER = struct.Struct(b"20s20s20s20s20s")
_CHANGEGROUPV3_DELTA_HEADER = struct.Struct(b">20s20s20s20s20sH") _CHANGEGROUPV3_DELTA_HEADER = struct.Struct(b">20s20s20s20s20sH")
LFS_REQUIREMENT = b'lfs' LFS_REQUIREMENT = b'lfs'
readexactly = util.readexactly readexactly = util.readexactly
# pull off the manifest group # pull off the manifest group
repo.ui.status(_(b"adding manifests\n")) repo.ui.status(_(b"adding manifests\n"))
# We know that we'll never have more manifests than we had # We know that we'll never have more manifests than we had
# changesets. # changesets.
progress = repo.ui.makeprogress( progress = repo.ui.makeprogress(
_(b'manifests'), unit=_(b'chunks'), total=changesets _(b'manifests'), unit=_(b'chunks'), total=changesets
) )
on_manifest_rev = None on_manifest_rev = None
if sidedata_helpers and b'manifest' in sidedata_helpers[1]: if sidedata_helpers:
if revlog_constants.KIND_MANIFESTLOG in sidedata_helpers[1]:
def on_manifest_rev(manifest, rev): def on_manifest_rev(manifest, rev):
range = touched_manifests.get(manifest) range = touched_manifests.get(manifest)
if not range: if not range:
touched_manifests[manifest] = (rev, rev) touched_manifests[manifest] = (rev, rev)
else: else:
assert rev == range[1] + 1 assert rev == range[1] + 1
touched_manifests[manifest] = (range[0], rev) touched_manifests[manifest] = (range[0], rev)
self._unpackmanifests( self._unpackmanifests(
repo, repo,
revmap, revmap,
trp, trp,
progress, progress,
addrevisioncb=on_manifest_rev, addrevisioncb=on_manifest_rev,
) )
needfiles = {} needfiles = {}
if repo.ui.configbool(b'server', b'validate'): if repo.ui.configbool(b'server', b'validate'):
cl = repo.changelog cl = repo.changelog
ml = repo.manifestlog ml = repo.manifestlog
# validate incoming csets have their manifests # validate incoming csets have their manifests
for cset in pycompat.xrange(clstart, clend): for cset in pycompat.xrange(clstart, clend):
mfnode = cl.changelogrevision(cset).manifest mfnode = cl.changelogrevision(cset).manifest
mfest = ml[mfnode].readdelta() mfest = ml[mfnode].readdelta()
# store file nodes we must see # store file nodes we must see
for f, n in pycompat.iteritems(mfest): for f, n in pycompat.iteritems(mfest):
needfiles.setdefault(f, set()).add(n) needfiles.setdefault(f, set()).add(n)
on_filelog_rev = None on_filelog_rev = None
if sidedata_helpers and b'filelog' in sidedata_helpers[1]: if sidedata_helpers:
if revlog_constants.KIND_FILELOG in sidedata_helpers[1]:
def on_filelog_rev(filelog, rev): def on_filelog_rev(filelog, rev):
range = touched_filelogs.get(filelog) range = touched_filelogs.get(filelog)
if not range: if not range:
touched_filelogs[filelog] = (rev, rev) touched_filelogs[filelog] = (rev, rev)
else: else:
assert rev == range[1] + 1 assert rev == range[1] + 1
touched_filelogs[filelog] = (range[0], rev) touched_filelogs[filelog] = (range[0], rev)
# process the files # process the files
repo.ui.status(_(b"adding file changes\n")) repo.ui.status(_(b"adding file changes\n"))
newrevs, newfiles = _addchangegroupfiles( newrevs, newfiles = _addchangegroupfiles(
repo, repo,
self, self,
revmap, revmap,
trp, trp,
efiles, efiles,
needfiles, needfiles,
addrevisioncb=on_filelog_rev, addrevisioncb=on_filelog_rev,
) )
if sidedata_helpers: if sidedata_helpers:
if b'changelog' in sidedata_helpers[1]: if revlog_constants.KIND_CHANGELOG in sidedata_helpers[1]:
cl.rewrite_sidedata(sidedata_helpers, clstart, clend - 1) cl.rewrite_sidedata(sidedata_helpers, clstart, clend - 1)
for mf, (startrev, endrev) in touched_manifests.items(): for mf, (startrev, endrev) in touched_manifests.items():
mf.rewrite_sidedata(sidedata_helpers, startrev, endrev) mf.rewrite_sidedata(sidedata_helpers, startrev, endrev)
for fl, (startrev, endrev) in touched_filelogs.items(): for fl, (startrev, endrev) in touched_filelogs.items():
fl.rewrite_sidedata(sidedata_helpers, startrev, endrev) fl.rewrite_sidedata(sidedata_helpers, startrev, endrev)
# making sure the value exists # making sure the value exists
tr.changes.setdefault(b'changegroup-count-changesets', 0) tr.changes.setdefault(b'changegroup-count-changesets', 0)

mercurial/changelog.py

self._realopener = opener self._realopener = opener
self._delayed = False self._delayed = False
self._delaybuf = None self._delaybuf = None
self._divert = False self._divert = False
self._filteredrevs = frozenset() self._filteredrevs = frozenset()
self._filteredrevs_hashcache = {} self._filteredrevs_hashcache = {}
self._copiesstorage = opener.options.get(b'copies-storage') self._copiesstorage = opener.options.get(b'copies-storage')
self.revlog_kind = b'changelog'
@property @property
def filteredrevs(self): def filteredrevs(self):
return self._filteredrevs return self._filteredrevs
@filteredrevs.setter @filteredrevs.setter
def filteredrevs(self, val): def filteredrevs(self, val):
# Ensure all updates go through this function # Ensure all updates go through this function

mercurial/filelog.py

# XXX should use the unencoded path # XXX should use the unencoded path
target=(revlog_constants.KIND_FILELOG, path), target=(revlog_constants.KIND_FILELOG, path),
indexfile=b'/'.join((b'data', path + b'.i')), indexfile=b'/'.join((b'data', path + b'.i')),
censorable=True, censorable=True,
) )
# Full name of the user visible file, relative to the repository root. # Full name of the user visible file, relative to the repository root.
# Used by LFS. # Used by LFS.
self._revlog.filename = path self._revlog.filename = path
self._revlog.revlog_kind = b'filelog'
self.nullid = self._revlog.nullid self.nullid = self._revlog.nullid
def __len__(self): def __len__(self):
return len(self._revlog) return len(self._revlog)
def __iter__(self): def __iter__(self):
return self._revlog.__iter__() return self._revlog.__iter__()

mercurial/localrepo.py

finally: finally:
fp.close() fp.close()
return self.pathto(fp.name[len(self.root) + 1 :]) return self.pathto(fp.name[len(self.root) + 1 :])
def register_wanted_sidedata(self, category): def register_wanted_sidedata(self, category):
self._wanted_sidedata.add(pycompat.bytestr(category)) self._wanted_sidedata.add(pycompat.bytestr(category))
def register_sidedata_computer(self, kind, category, keys, computer): def register_sidedata_computer(self, kind, category, keys, computer):
if kind not in (b"changelog", b"manifest", b"filelog"): if kind not in revlogconst.ALL_KINDS:
msg = _(b"unexpected revlog kind '%s'.") msg = _(b"unexpected revlog kind %r.")
raise error.ProgrammingError(msg % kind) raise error.ProgrammingError(msg % kind)
category = pycompat.bytestr(category) category = pycompat.bytestr(category)
if category in self._sidedata_computers.get(kind, []): if category in self._sidedata_computers.get(kind, []):
msg = _( msg = _(
b"cannot register a sidedata computer twice for category '%s'." b"cannot register a sidedata computer twice for category '%s'."
) )
raise error.ProgrammingError(msg % category) raise error.ProgrammingError(msg % category)
self._sidedata_computers.setdefault(kind, {}) self._sidedata_computers.setdefault(kind, {})

mercurial/manifest.py

mmaplargeindex=True, mmaplargeindex=True,
upperboundcomp=MAXCOMPRESSION, upperboundcomp=MAXCOMPRESSION,
persistentnodemap=opener.options.get(b'persistent-nodemap', False), persistentnodemap=opener.options.get(b'persistent-nodemap', False),
) )
self.index = self._revlog.index self.index = self._revlog.index
self.version = self._revlog.version self.version = self._revlog.version
self._generaldelta = self._revlog._generaldelta self._generaldelta = self._revlog._generaldelta
self._revlog.revlog_kind = b'manifest'
def _setupmanifestcachehooks(self, repo): def _setupmanifestcachehooks(self, repo):
"""Persist the manifestfulltextcache on lock release""" """Persist the manifestfulltextcache on lock release"""
if not util.safehasattr(repo, b'_wlockref'): if not util.safehasattr(repo, b'_wlockref'):
return return
self._fulltextcache._opener = repo.wcachevfs self._fulltextcache._opener = repo.wcachevfs
if repo._currentlock(repo._wlockref) is None: if repo._currentlock(repo._wlockref) is None:

mercurial/metadata.py

from . import ( from . import (
error, error,
pycompat, pycompat,
requirements as requirementsmod, requirements as requirementsmod,
util, util,
) )
from .revlogutils import ( from .revlogutils import (
constants as revlogconst,
flagutil as sidedataflag, flagutil as sidedataflag,
sidedata as sidedatamod, sidedata as sidedatamod,
) )
class ChangingFiles(object): class ChangingFiles(object):
"""A class recording the changes made to files by a changeset """A class recording the changes made to files by a changeset
def copies_sidedata_computer(repo, revlog, rev, existing_sidedata): def copies_sidedata_computer(repo, revlog, rev, existing_sidedata):
return _getsidedata(repo, rev)[0] return _getsidedata(repo, rev)[0]
def set_sidedata_spec_for_repo(repo): def set_sidedata_spec_for_repo(repo):
if requirementsmod.COPIESSDC_REQUIREMENT in repo.requirements: if requirementsmod.COPIESSDC_REQUIREMENT in repo.requirements:
repo.register_wanted_sidedata(sidedatamod.SD_FILES) repo.register_wanted_sidedata(sidedatamod.SD_FILES)
repo.register_sidedata_computer( repo.register_sidedata_computer(
b"changelog", revlogconst.KIND_CHANGELOG,
sidedatamod.SD_FILES, sidedatamod.SD_FILES,
(sidedatamod.SD_FILES,), (sidedatamod.SD_FILES,),
copies_sidedata_computer, copies_sidedata_computer,
) )
def getsidedataadder(srcrepo, destrepo): def getsidedataadder(srcrepo, destrepo):
use_w = srcrepo.ui.configbool(b'experimental', b'worker.repository-upgrade') use_w = srcrepo.ui.configbool(b'experimental', b'worker.repository-upgrade')

mercurial/revlog.py

if not self._chunkcache: if not self._chunkcache:
self._chunkclear() self._chunkclear()
# revnum -> (chain-length, sum-delta-length) # revnum -> (chain-length, sum-delta-length)
self._chaininfocache = util.lrucachedict(500) self._chaininfocache = util.lrucachedict(500)
# revlog header -> revlog compressor # revlog header -> revlog compressor
self._decompressors = {} self._decompressors = {}
@util.propertycache @util.propertycache
def revlog_kind(self):
return self.target[0]
@util.propertycache
def _compressor(self): def _compressor(self):
engine = util.compengines[self._compengine] engine = util.compengines[self._compengine]
return engine.revlogcompressor(self._compengineopts) return engine.revlogcompressor(self._compengineopts)
def _indexfp(self, mode=b'r'): def _indexfp(self, mode=b'r'):
"""file object for the revlog's index file""" """file object for the revlog's index file"""
args = {'mode': mode} args = {'mode': mode}
if mode != b'r': if mode != b'r':

tests/testlib/ext-sidedata-2.py

# coding: utf8 # coding: utf8
# ext-sidedata-2.py - small extension to test (differently) the sidedata logic # ext-sidedata-2.py - small extension to test (differently) the sidedata logic
# #
# Simulates a client for a complex sidedata exchange. # Simulates a client for a complex sidedata exchange.
# #
# Copyright 2021 Raphaël Gomès <rgomes@octobus.net> # Copyright 2021 Raphaël Gomès <rgomes@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
import hashlib import hashlib
import struct import struct
from mercurial.revlogutils import sidedata as sidedatamod from mercurial.revlogutils import sidedata as sidedatamod
from mercurial.revlogutils import constants
def compute_sidedata_1(repo, revlog, rev, sidedata, text=None): def compute_sidedata_1(repo, revlog, rev, sidedata, text=None):
sidedata = sidedata.copy() sidedata = sidedata.copy()
if text is None: if text is None:
text = revlog.revision(rev) text = revlog.revision(rev)
sidedata[sidedatamod.SD_TEST1] = struct.pack('>I', len(text)) sidedata[sidedatamod.SD_TEST1] = struct.pack('>I', len(text))
return sidedata return sidedata
def compute_sidedata_2(repo, revlog, rev, sidedata, text=None): def compute_sidedata_2(repo, revlog, rev, sidedata, text=None):
sidedata = sidedata.copy() sidedata = sidedata.copy()
if text is None: if text is None:
text = revlog.revision(rev) text = revlog.revision(rev)
sha256 = hashlib.sha256(text).digest() sha256 = hashlib.sha256(text).digest()
sidedata[sidedatamod.SD_TEST2] = struct.pack('>32s', sha256) sidedata[sidedatamod.SD_TEST2] = struct.pack('>32s', sha256)
return sidedata return sidedata
def reposetup(ui, repo): def reposetup(ui, repo):
# Sidedata keys happen to be the same as the categories, easier for testing. # Sidedata keys happen to be the same as the categories, easier for testing.
for kind in (b'changelog', b'manifest', b'filelog'): for kind in constants.ALL_KINDS:
repo.register_sidedata_computer( repo.register_sidedata_computer(
kind, kind,
sidedatamod.SD_TEST1, sidedatamod.SD_TEST1,
(sidedatamod.SD_TEST1,), (sidedatamod.SD_TEST1,),
compute_sidedata_1, compute_sidedata_1,
) )
repo.register_sidedata_computer( repo.register_sidedata_computer(
kind, kind,
sidedatamod.SD_TEST2, sidedatamod.SD_TEST2,
(sidedatamod.SD_TEST2,), (sidedatamod.SD_TEST2,),
compute_sidedata_2, compute_sidedata_2,
) )

tests/testlib/ext-sidedata-3.py

import struct import struct
from mercurial import ( from mercurial import (
extensions, extensions,
revlog, revlog,
) )
from mercurial.revlogutils import sidedata as sidedatamod from mercurial.revlogutils import sidedata as sidedatamod
from mercurial.revlogutils import constants
def compute_sidedata_1(repo, revlog, rev, sidedata, text=None): def compute_sidedata_1(repo, revlog, rev, sidedata, text=None):
sidedata = sidedata.copy() sidedata = sidedata.copy()
if text is None: if text is None:
text = revlog.revision(rev) text = revlog.revision(rev)
sidedata[sidedatamod.SD_TEST1] = struct.pack('>I', len(text)) sidedata[sidedatamod.SD_TEST1] = struct.pack('>I', len(text))
return sidedata return sidedata
def extsetup(ui): def extsetup(ui):
extensions.wrapfunction(revlog.revlog, 'addrevision', wrapaddrevision) extensions.wrapfunction(revlog.revlog, 'addrevision', wrapaddrevision)
def reposetup(ui, repo): def reposetup(ui, repo):
# Sidedata keys happen to be the same as the categories, easier for testing. # Sidedata keys happen to be the same as the categories, easier for testing.
for kind in (b'changelog', b'manifest', b'filelog'): for kind in constants.ALL_KINDS:
repo.register_sidedata_computer( repo.register_sidedata_computer(
kind, kind,
sidedatamod.SD_TEST1, sidedatamod.SD_TEST1,
(sidedatamod.SD_TEST1,), (sidedatamod.SD_TEST1,),
compute_sidedata_1, compute_sidedata_1,
) )
repo.register_sidedata_computer( repo.register_sidedata_computer(
kind, kind,

tests/testlib/ext-sidedata-5.py

from mercurial import ( from mercurial import (
extensions, extensions,
revlog, revlog,
) )
from mercurial.revlogutils import sidedata as sidedatamod from mercurial.revlogutils import sidedata as sidedatamod
from mercurial.revlogutils import constants
def compute_sidedata_1(repo, revlog, rev, sidedata, text=None): def compute_sidedata_1(repo, revlog, rev, sidedata, text=None):
sidedata = sidedata.copy() sidedata = sidedata.copy()
if text is None: if text is None:
text = revlog.revision(rev) text = revlog.revision(rev)
sidedata[sidedatamod.SD_TEST1] = struct.pack('>I', len(text)) sidedata[sidedatamod.SD_TEST1] = struct.pack('>I', len(text))
return sidedata return sidedata
def compute_sidedata_2(repo, revlog, rev, sidedata, text=None): def compute_sidedata_2(repo, revlog, rev, sidedata, text=None):
sidedata = sidedata.copy() sidedata = sidedata.copy()
if text is None: if text is None:
text = revlog.revision(rev) text = revlog.revision(rev)
sha256 = hashlib.sha256(text).digest() sha256 = hashlib.sha256(text).digest()
sidedata[sidedatamod.SD_TEST2] = struct.pack('>32s', sha256) sidedata[sidedatamod.SD_TEST2] = struct.pack('>32s', sha256)
return sidedata return sidedata
def reposetup(ui, repo): def reposetup(ui, repo):
# Sidedata keys happen to be the same as the categories, easier for testing. # Sidedata keys happen to be the same as the categories, easier for testing.
for kind in (b'changelog', b'manifest', b'filelog'): for kind in constants.ALL_KINDS:
repo.register_sidedata_computer( repo.register_sidedata_computer(
kind, kind,
sidedatamod.SD_TEST1, sidedatamod.SD_TEST1,
(sidedatamod.SD_TEST1,), (sidedatamod.SD_TEST1,),
compute_sidedata_1, compute_sidedata_1,
) )
repo.register_sidedata_computer( repo.register_sidedata_computer(
kind, kind,