( )⚙ 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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 27296

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,