Mercurial > hg
view mercurial/unionrepo.py @ 48598:a6f16ec07ed7
stream-clone: add a explicit test for format change during stream clone
They are different kind of requirements, the one which impact the data storage
and are relevant to the files being streamed and the one which does not. For
example some requirements are only relevant to the working copy, like sparse, or
dirstate-v2.
Since they are irrelevant to the content being streamed, they do not prevent the
receiving side to use streaming clone and mercurial skip adverting them over
the wire and, ideally, within the bundle.
In addition, this let the client decide to use whichever format it desire for
the part that does not affect the store itself. So the configuration related to
these format are used as normal when doing a streaming clone.
In practice, the feature was not really tested and is badly broken with bundle-2,
since the requirements are not filtered out from the stream bundle.
So we start with adding simple tests as a good base before the fix and adjust
the feature.
Differential Revision: https://phab.mercurial-scm.org/D12029
author | Pierre-Yves David <pierre-yves.david@octobus.net> |
---|---|
date | Mon, 17 Jan 2022 18:51:47 +0100 |
parents | 52034c42c09d |
children | 6000f5b25c9b |
line wrap: on
line source
# unionrepo.py - repository class for viewing union of repository changesets # # Derived from bundlerepo.py # Copyright 2006, 2007 Benoit Boissinot <bboissin@gmail.com> # Copyright 2013 Unity Technologies, Mads Kiilerich <madski@unity3d.com> # # This software may be used and distributed according to the terms of the # GNU General Public License version 2 or any later version. """Repository class for "in-memory pull" of one local repository to another, allowing operations like diff and log with revsets. """ from __future__ import absolute_import from .i18n import _ from .pycompat import getattr from . import ( changelog, cmdutil, encoding, error, filelog, localrepo, manifest, mdiff, pathutil, revlog, util, vfs as vfsmod, ) from .revlogutils import ( constants as revlog_constants, ) class unionrevlog(revlog.revlog): def __init__(self, opener, radix, revlog2, linkmapper): # How it works: # To retrieve a revision, we just need to know the node id so we can # look it up in revlog2. # # To differentiate a rev in the second revlog from a rev in the revlog, # we check revision against repotiprev. opener = vfsmod.readonlyvfs(opener) target = getattr(revlog2, 'target', None) if target is None: # a revlog wrapper, eg: the manifestlog that is not an actual revlog target = revlog2._revlog.target revlog.revlog.__init__(self, opener, target=target, radix=radix) self.revlog2 = revlog2 n = len(self) self.repotiprev = n - 1 self.bundlerevs = set() # used by 'bundle()' revset expression for rev2 in self.revlog2: rev = self.revlog2.index[rev2] # rev numbers - in revlog2, very different from self.rev ( _start, _csize, rsize, base, linkrev, p1rev, p2rev, node, _sdo, _sds, _dcm, _sdcm, rank, ) = rev flags = _start & 0xFFFF if linkmapper is None: # link is to same revlog assert linkrev == rev2 # we never link back link = n else: # rev must be mapped from repo2 cl to unified cl by linkmapper link = linkmapper(linkrev) if linkmapper is not None: # link is to same revlog base = linkmapper(base) this_rev = self.index.get_rev(node) if this_rev is not None: # this happens for the common revlog revisions self.bundlerevs.add(this_rev) continue p1node = self.revlog2.node(p1rev) p2node = self.revlog2.node(p2rev) # TODO: it's probably wrong to set compressed length to -1, but # I have no idea if csize is valid in the base revlog context. e = ( flags, -1, rsize, base, link, self.rev(p1node), self.rev(p2node), node, 0, # sidedata offset 0, # sidedata size revlog_constants.COMP_MODE_INLINE, revlog_constants.COMP_MODE_INLINE, rank, ) self.index.append(e) self.bundlerevs.add(n) n += 1 def _chunk(self, rev): if rev <= self.repotiprev: return revlog.revlog._chunk(self, rev) return self.revlog2._chunk(self.node(rev)) def revdiff(self, rev1, rev2): """return or calculate a delta between two revisions""" if rev1 > self.repotiprev and rev2 > self.repotiprev: return self.revlog2.revdiff( self.revlog2.rev(self.node(rev1)), self.revlog2.rev(self.node(rev2)), ) elif rev1 <= self.repotiprev and rev2 <= self.repotiprev: return super(unionrevlog, self).revdiff(rev1, rev2) return mdiff.textdiff(self.rawdata(rev1), self.rawdata(rev2)) def _revisiondata(self, nodeorrev, _df=None, raw=False): if isinstance(nodeorrev, int): rev = nodeorrev node = self.node(rev) else: node = nodeorrev rev = self.rev(node) if rev > self.repotiprev: # work around manifestrevlog NOT being a revlog revlog2 = getattr(self.revlog2, '_revlog', self.revlog2) func = revlog2._revisiondata else: func = super(unionrevlog, self)._revisiondata return func(node, _df=_df, raw=raw) def addrevision(self, text, transaction, link, p1=None, p2=None, d=None): raise NotImplementedError def addgroup( self, deltas, linkmapper, transaction, alwayscache=False, addrevisioncb=None, duplicaterevisioncb=None, maybemissingparents=False, ): raise NotImplementedError def strip(self, minlink, transaction): raise NotImplementedError def checksize(self): raise NotImplementedError class unionchangelog(unionrevlog, changelog.changelog): def __init__(self, opener, opener2): changelog.changelog.__init__(self, opener) linkmapper = None changelog2 = changelog.changelog(opener2) unionrevlog.__init__(self, opener, self.radix, changelog2, linkmapper) class unionmanifest(unionrevlog, manifest.manifestrevlog): def __init__(self, nodeconstants, opener, opener2, linkmapper): manifest.manifestrevlog.__init__(self, nodeconstants, opener) manifest2 = manifest.manifestrevlog(nodeconstants, opener2) unionrevlog.__init__( self, opener, self._revlog.radix, manifest2, linkmapper ) class unionfilelog(filelog.filelog): def __init__(self, opener, path, opener2, linkmapper, repo): filelog.filelog.__init__(self, opener, path) filelog2 = filelog.filelog(opener2, path) self._revlog = unionrevlog( opener, self._revlog.radix, filelog2._revlog, linkmapper ) self._repo = repo self.repotiprev = self._revlog.repotiprev self.revlog2 = self._revlog.revlog2 def iscensored(self, rev): """Check if a revision is censored.""" if rev <= self.repotiprev: return filelog.filelog.iscensored(self, rev) node = self.node(rev) return self.revlog2.iscensored(self.revlog2.rev(node)) class unionpeer(localrepo.localpeer): def canpush(self): return False class unionrepository(object): """Represents the union of data in 2 repositories. Instances are not usable if constructed directly. Use ``instance()`` or ``makeunionrepository()`` to create a usable instance. """ def __init__(self, repo2, url): self.repo2 = repo2 self._url = url self.ui.setconfig(b'phases', b'publish', False, b'unionrepo') @localrepo.unfilteredpropertycache def changelog(self): return unionchangelog(self.svfs, self.repo2.svfs) @localrepo.unfilteredpropertycache def manifestlog(self): rootstore = unionmanifest( self.nodeconstants, self.svfs, self.repo2.svfs, self.unfiltered()._clrev, ) return manifest.manifestlog( self.svfs, self, rootstore, self.narrowmatch() ) def _clrev(self, rev2): """map from repo2 changelog rev to temporary rev in self.changelog""" node = self.repo2.changelog.node(rev2) return self.changelog.rev(node) def url(self): return self._url def file(self, f): return unionfilelog( self.svfs, f, self.repo2.svfs, self.unfiltered()._clrev, self ) def close(self): self.repo2.close() def cancopy(self): return False def peer(self): return unionpeer(self) def getcwd(self): return encoding.getcwd() # always outside the repo def instance(ui, path, create, intents=None, createopts=None): if create: raise error.Abort(_(b'cannot create new union repository')) parentpath = ui.config(b"bundle", b"mainreporoot") if not parentpath: # try to find the correct path to the working directory repo parentpath = cmdutil.findrepo(encoding.getcwd()) if parentpath is None: parentpath = b'' if parentpath: # Try to make the full path relative so we get a nice, short URL. # In particular, we don't want temp dir names in test outputs. cwd = encoding.getcwd() if parentpath == cwd: parentpath = b'' else: cwd = pathutil.normasprefix(cwd) if parentpath.startswith(cwd): parentpath = parentpath[len(cwd) :] if path.startswith(b'union:'): s = path.split(b":", 1)[1].split(b"+", 1) if len(s) == 1: repopath, repopath2 = parentpath, s[0] else: repopath, repopath2 = s else: repopath, repopath2 = parentpath, path return makeunionrepository(ui, repopath, repopath2) def makeunionrepository(ui, repopath1, repopath2): """Make a union repository object from 2 local repo paths.""" repo1 = localrepo.instance(ui, repopath1, create=False) repo2 = localrepo.instance(ui, repopath2, create=False) url = b'union:%s+%s' % ( util.expandpath(repopath1), util.expandpath(repopath2), ) class derivedunionrepository(unionrepository, repo1.__class__): pass repo = repo1 repo.__class__ = derivedunionrepository unionrepository.__init__(repo1, repo2, url) return repo