| # 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 node import nullid |
| from i18n import _ |
| import os |
| import util, mdiff, cmdutil, scmutil |
| import localrepo, changelog, manifest, filelog, revlog |
| |
| class unionrevlog(revlog.revlog): |
| def __init__(self, opener, indexfile, 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 = scmutil.readonlyvfs(opener) |
| revlog.revlog.__init__(self, opener, indexfile) |
| 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 = rev |
| |
| 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 node in self.nodemap: |
| # this happens for the common revlog revisions |
| self.bundlerevs.add(self.nodemap[node]) |
| continue |
| |
| p1node = self.revlog2.node(p1rev) |
| p2node = self.revlog2.node(p2rev) |
| |
| e = (None, None, None, None, |
| link, self.rev(p1node), self.rev(p2node), node) |
| self.index.insert(-1, e) |
| self.nodemap[node] = n |
| 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 revlog.revlog.revdiff(self, rev1, rev2) |
| |
| return mdiff.textdiff(self.revision(self.node(rev1)), |
| self.revision(self.node(rev2))) |
| |
| def revision(self, nodeorrev): |
| """return an uncompressed revision of a given node or revision |
| number. |
| """ |
| if isinstance(nodeorrev, int): |
| rev = nodeorrev |
| node = self.node(rev) |
| else: |
| node = nodeorrev |
| rev = self.rev(node) |
| |
| if node == nullid: |
| return "" |
| |
| if rev > self.repotiprev: |
| text = self.revlog2.revision(node) |
| self._cache = (node, rev, text) |
| else: |
| text = revlog.revlog.revision(self, rev) |
| # already cached |
| return text |
| |
| def addrevision(self, text, transaction, link, p1=None, p2=None, d=None): |
| raise NotImplementedError |
| def addgroup(self, revs, linkmapper, transaction): |
| raise NotImplementedError |
| def strip(self, rev, minlink): |
| 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.indexfile, changelog2, |
| linkmapper) |
| |
| class unionmanifest(unionrevlog, manifest.manifest): |
| def __init__(self, opener, opener2, linkmapper): |
| manifest.manifest.__init__(self, opener) |
| manifest2 = manifest.manifest(opener2) |
| unionrevlog.__init__(self, opener, self.indexfile, manifest2, |
| linkmapper) |
| |
| class unionfilelog(unionrevlog, filelog.filelog): |
| def __init__(self, opener, path, opener2, linkmapper, repo): |
| filelog.filelog.__init__(self, opener, path) |
| filelog2 = filelog.filelog(opener2, path) |
| unionrevlog.__init__(self, opener, self.indexfile, filelog2, |
| linkmapper) |
| self._repo = repo |
| |
| def _file(self, f): |
| self._repo.file(f) |
| |
| class unionpeer(localrepo.localpeer): |
| def canpush(self): |
| return False |
| |
| class unionrepository(localrepo.localrepository): |
| def __init__(self, ui, path, path2): |
| localrepo.localrepository.__init__(self, ui, path) |
| self.ui.setconfig('phases', 'publish', False) |
| |
| self._url = 'union:%s+%s' % (util.expandpath(path), |
| util.expandpath(path2)) |
| self.repo2 = localrepo.localrepository(ui, path2) |
| |
| @localrepo.unfilteredpropertycache |
| def changelog(self): |
| return unionchangelog(self.sopener, self.repo2.sopener) |
| |
| 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) |
| |
| @localrepo.unfilteredpropertycache |
| def manifest(self): |
| return unionmanifest(self.sopener, self.repo2.sopener, |
| self._clrev) |
| |
| def url(self): |
| return self._url |
| |
| def file(self, f): |
| return unionfilelog(self.sopener, f, self.repo2.sopener, |
| self._clrev, self) |
| |
| def close(self): |
| self.repo2.close() |
| |
| def cancopy(self): |
| return False |
| |
| def peer(self): |
| return unionpeer(self) |
| |
| def getcwd(self): |
| return os.getcwd() # always outside the repo |
| |
| def instance(ui, path, create): |
| if create: |
| raise util.Abort(_('cannot create new union repository')) |
| parentpath = ui.config("bundle", "mainreporoot", "") |
| if not parentpath: |
| # try to find the correct path to the working directory repo |
| parentpath = cmdutil.findrepo(os.getcwd()) |
| if parentpath is None: |
| parentpath = '' |
| 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 = os.getcwd() |
| if parentpath == cwd: |
| parentpath = '' |
| else: |
| cwd = os.path.join(cwd,'') |
| if parentpath.startswith(cwd): |
| parentpath = parentpath[len(cwd):] |
| if path.startswith('union:'): |
| s = path.split(":", 1)[1].split("+", 1) |
| if len(s) == 1: |
| repopath, repopath2 = parentpath, s[0] |
| else: |
| repopath, repopath2 = s |
| else: |
| repopath, repopath2 = parentpath, path |
| return unionrepository(ui, repopath, repopath2) |
