bundlerepo.py
403 lines
| 14.3 KiB
| text/x-python
|
PythonLexer
/ mercurial / bundlerepo.py
Martin Geisler
|
r8226 | # bundlerepo.py - repository class for viewing uncompressed bundles | ||
# | ||||
# Copyright 2006, 2007 Benoit Boissinot <bboissin@gmail.com> | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
Matt Mackall
|
r10263 | # GNU General Public License version 2 or any later version. | ||
Benoit Boissinot
|
r1942 | |||
Martin Geisler
|
r8227 | """Repository class for viewing uncompressed bundles. | ||
This provides a read-only repository interface to bundles as if they | ||||
were part of the actual repository. | ||||
""" | ||||
Peter Arrenbrecht
|
r7873 | from node import nullid | ||
Matt Mackall
|
r3891 | from i18n import _ | ||
Matt Mackall
|
r14158 | import os, tempfile, shutil | ||
Pierre-Yves David
|
r21063 | import changegroup, util, mdiff, discovery, cmdutil, scmutil, exchange | ||
Brodie Rao
|
r14076 | import localrepo, changelog, manifest, filelog, revlog, error | ||
Benoit Boissinot
|
r1942 | |||
Benoit Boissinot
|
r1946 | class bundlerevlog(revlog.revlog): | ||
Benoit Boissinot
|
r14142 | def __init__(self, opener, indexfile, bundle, linkmapper): | ||
Benoit Boissinot
|
r1942 | # How it works: | ||
Mads Kiilerich
|
r18410 | # To retrieve a revision, we need to know the offset of the revision in | ||
# the bundle (an unbundle object). We store this offset in the index | ||||
Mads Kiilerich
|
r18643 | # (start). The base of the delta is stored in the base field. | ||
Benoit Boissinot
|
r1942 | # | ||
Mads Kiilerich
|
r18410 | # To differentiate a rev in the bundle from a rev in the revlog, we | ||
Mads Kiilerich
|
r18643 | # check revision against repotiprev. | ||
Pierre-Yves David
|
r18215 | opener = scmutil.readonlyvfs(opener) | ||
Matt Mackall
|
r4257 | revlog.revlog.__init__(self, opener, indexfile) | ||
Matt Mackall
|
r12332 | self.bundle = bundle | ||
Matt Mackall
|
r6750 | n = len(self) | ||
Mads Kiilerich
|
r18643 | self.repotiprev = n - 1 | ||
Benoit Boissinot
|
r14142 | chain = None | ||
Mads Kiilerich
|
r18411 | self.bundlerevs = set() # used by 'bundle()' revset expression | ||
Martin Geisler
|
r14494 | while True: | ||
Benoit Boissinot
|
r14144 | chunkdata = bundle.deltachunk(chain) | ||
Benoit Boissinot
|
r14142 | if not chunkdata: | ||
break | ||||
node = chunkdata['node'] | ||||
p1 = chunkdata['p1'] | ||||
p2 = chunkdata['p2'] | ||||
cs = chunkdata['cs'] | ||||
deltabase = chunkdata['deltabase'] | ||||
delta = chunkdata['delta'] | ||||
size = len(delta) | ||||
start = bundle.tell() - size | ||||
link = linkmapper(cs) | ||||
Benoit Boissinot
|
r1942 | if node in self.nodemap: | ||
Benoit Boissinot
|
r14142 | # this can happen if two branches make the same change | ||
chain = node | ||||
Mads Kiilerich
|
r18411 | self.bundlerevs.add(self.nodemap[node]) | ||
Benoit Boissinot
|
r1942 | continue | ||
Benoit Boissinot
|
r14142 | |||
Benoit Boissinot
|
r1942 | for p in (p1, p2): | ||
Brodie Rao
|
r16686 | if p not in self.nodemap: | ||
Sune Foldager
|
r9650 | raise error.LookupError(p, self.indexfile, | ||
Matt Mackall
|
r7633 | _("unknown parent")) | ||
Mads Kiilerich
|
r18416 | |||
if deltabase not in self.nodemap: | ||||
raise LookupError(deltabase, self.indexfile, | ||||
_('unknown delta base')) | ||||
baserev = self.rev(deltabase) | ||||
Benoit Boissinot
|
r5167 | # start, size, full unc. size, base (unused), link, p1, p2, node | ||
Mads Kiilerich
|
r18643 | e = (revlog.offset_type(start, 0), size, -1, baserev, link, | ||
Matt Mackall
|
r4979 | self.rev(p1), self.rev(p2), node) | ||
self.index.insert(-1, e) | ||||
Benoit Boissinot
|
r1942 | self.nodemap[node] = n | ||
Mads Kiilerich
|
r18411 | self.bundlerevs.add(n) | ||
Benoit Boissinot
|
r14142 | chain = node | ||
Benoit Boissinot
|
r1942 | n += 1 | ||
Benoit Boissinot
|
r9676 | def _chunk(self, rev): | ||
Mads Kiilerich
|
r18643 | # Warning: in case of bundle, the diff is against what we stored as | ||
# delta base, not against rev - 1 | ||||
Benoit Boissinot
|
r1942 | # XXX: could use some caching | ||
Mads Kiilerich
|
r18643 | if rev <= self.repotiprev: | ||
Benoit Boissinot
|
r9676 | return revlog.revlog._chunk(self, rev) | ||
Matt Mackall
|
r12332 | self.bundle.seek(self.start(rev)) | ||
return self.bundle.read(self.length(rev)) | ||||
Benoit Boissinot
|
r1942 | |||
def revdiff(self, rev1, rev2): | ||||
"""return or calculate a delta between two revisions""" | ||||
Mads Kiilerich
|
r18643 | if rev1 > self.repotiprev and rev2 > self.repotiprev: | ||
Benoit Boissinot
|
r1942 | # hot path for bundle | ||
Mads Kiilerich
|
r18643 | revb = self.index[rev2][3] | ||
Benoit Boissinot
|
r1942 | if revb == rev1: | ||
Benoit Boissinot
|
r9676 | return self._chunk(rev2) | ||
Mads Kiilerich
|
r18643 | elif rev1 <= self.repotiprev and rev2 <= self.repotiprev: | ||
Benoit Boissinot
|
r4028 | return revlog.revlog.revdiff(self, rev1, rev2) | ||
Benoit Boissinot
|
r1942 | |||
Matt Mackall
|
r4989 | return mdiff.textdiff(self.revision(self.node(rev1)), | ||
Mads Kiilerich
|
r18413 | self.revision(self.node(rev2))) | ||
Benoit Boissinot
|
r1942 | |||
Matt Mackall
|
r16375 | def revision(self, nodeorrev): | ||
Patrick Mezard
|
r16435 | """return an uncompressed revision of a given node or revision | ||
number. | ||||
""" | ||||
Matt Mackall
|
r16375 | if isinstance(nodeorrev, int): | ||
rev = nodeorrev | ||||
node = self.node(rev) | ||||
else: | ||||
node = nodeorrev | ||||
rev = self.rev(node) | ||||
Matt Mackall
|
r10282 | if node == nullid: | ||
return "" | ||||
Benoit Boissinot
|
r1942 | |||
text = None | ||||
chain = [] | ||||
Mads Kiilerich
|
r18415 | iterrev = rev | ||
Benoit Boissinot
|
r1942 | # reconstruct the revision if it is from a changegroup | ||
Mads Kiilerich
|
r18643 | while iterrev > self.repotiprev: | ||
Mads Kiilerich
|
r18415 | if self._cache and self._cache[1] == iterrev: | ||
Matt Mackall
|
r4984 | text = self._cache[2] | ||
Benoit Boissinot
|
r1942 | break | ||
Mads Kiilerich
|
r18415 | chain.append(iterrev) | ||
Mads Kiilerich
|
r18643 | iterrev = self.index[iterrev][3] | ||
Benoit Boissinot
|
r1942 | if text is None: | ||
Wojciech Lopata
|
r19629 | text = self.baserevision(iterrev) | ||
Benoit Boissinot
|
r1942 | |||
while chain: | ||||
Benoit Boissinot
|
r9676 | delta = self._chunk(chain.pop()) | ||
Matt Mackall
|
r4989 | text = mdiff.patches(text, [delta]) | ||
Benoit Boissinot
|
r1942 | |||
Mads Kiilerich
|
r18417 | self._checkhash(text, node, rev) | ||
Mads Kiilerich
|
r18415 | self._cache = (node, rev, text) | ||
Benoit Boissinot
|
r1942 | return text | ||
Wojciech Lopata
|
r19629 | def baserevision(self, nodeorrev): | ||
# Revlog subclasses may override 'revision' method to modify format of | ||||
# content retrieved from revlog. To use bundlerevlog with such class one | ||||
# needs to override 'baserevision' and make more specific call here. | ||||
return revlog.revlog.revision(self, nodeorrev) | ||||
Benoit Boissinot
|
r1942 | def addrevision(self, text, transaction, link, p1=None, p2=None, d=None): | ||
raise NotImplementedError | ||||
Peter Arrenbrecht
|
r6647 | def addgroup(self, revs, linkmapper, transaction): | ||
Benoit Boissinot
|
r1942 | raise NotImplementedError | ||
def strip(self, rev, minlink): | ||||
raise NotImplementedError | ||||
def checksize(self): | ||||
raise NotImplementedError | ||||
Benoit Boissinot
|
r1946 | class bundlechangelog(bundlerevlog, changelog.changelog): | ||
Matt Mackall
|
r12332 | def __init__(self, opener, bundle): | ||
Benoit Boissinot
|
r1946 | changelog.changelog.__init__(self, opener) | ||
Benoit Boissinot
|
r14142 | linkmapper = lambda x: x | ||
bundlerevlog.__init__(self, opener, self.indexfile, bundle, | ||||
linkmapper) | ||||
Benoit Boissinot
|
r1942 | |||
Wojciech Lopata
|
r19629 | def baserevision(self, nodeorrev): | ||
# Although changelog doesn't override 'revision' method, some extensions | ||||
# may replace this class with another that does. Same story with | ||||
# manifest and filelog classes. | ||||
return changelog.changelog.revision(self, nodeorrev) | ||||
Benoit Boissinot
|
r1946 | class bundlemanifest(bundlerevlog, manifest.manifest): | ||
Matt Mackall
|
r12332 | def __init__(self, opener, bundle, linkmapper): | ||
Benoit Boissinot
|
r1946 | manifest.manifest.__init__(self, opener) | ||
Matt Mackall
|
r12332 | bundlerevlog.__init__(self, opener, self.indexfile, bundle, | ||
Matt Mackall
|
r4257 | linkmapper) | ||
Benoit Boissinot
|
r1942 | |||
Wojciech Lopata
|
r19629 | def baserevision(self, nodeorrev): | ||
return manifest.manifest.revision(self, nodeorrev) | ||||
Benoit Boissinot
|
r1946 | class bundlefilelog(bundlerevlog, filelog.filelog): | ||
Sune Foldager
|
r14287 | def __init__(self, opener, path, bundle, linkmapper, repo): | ||
Benoit Boissinot
|
r1946 | filelog.filelog.__init__(self, opener, path) | ||
Matt Mackall
|
r12332 | bundlerevlog.__init__(self, opener, self.indexfile, bundle, | ||
Matt Mackall
|
r4257 | linkmapper) | ||
Sune Foldager
|
r14287 | self._repo = repo | ||
Wojciech Lopata
|
r19629 | def baserevision(self, nodeorrev): | ||
return filelog.filelog.revision(self, nodeorrev) | ||||
Sune Foldager
|
r14287 | def _file(self, f): | ||
self._repo.file(f) | ||||
Benoit Boissinot
|
r1942 | |||
Sune Foldager
|
r17193 | class bundlepeer(localrepo.localpeer): | ||
def canpush(self): | ||||
return False | ||||
Benoit Boissinot
|
r1946 | class bundlerepository(localrepo.localrepository): | ||
Benoit Boissinot
|
r1942 | def __init__(self, ui, path, bundlename): | ||
John Mulligan
|
r6314 | self._tempparent = None | ||
try: | ||||
localrepo.localrepository.__init__(self, ui, path) | ||||
Matt Mackall
|
r7637 | except error.RepoError: | ||
John Mulligan
|
r6314 | self._tempparent = tempfile.mkdtemp() | ||
Martin Geisler
|
r9198 | localrepo.instance(ui, self._tempparent, 1) | ||
John Mulligan
|
r6314 | localrepo.localrepository.__init__(self, ui, self._tempparent) | ||
Mads Kiilerich
|
r20790 | self.ui.setconfig('phases', 'publish', False, 'bundlerepo') | ||
Vadim Gelfer
|
r2673 | |||
Peter Arrenbrecht
|
r6129 | if path: | ||
Alexander Solovyov
|
r11154 | self._url = 'bundle:' + util.expandpath(path) + '+' + bundlename | ||
Peter Arrenbrecht
|
r6129 | else: | ||
self._url = 'bundle:' + bundlename | ||||
Vadim Gelfer
|
r2673 | |||
Benoit Boissinot
|
r2273 | self.tempfile = None | ||
Adrian Buehlmann
|
r13274 | f = util.posixfile(bundlename, "rb") | ||
Pierre-Yves David
|
r21064 | self.bundle = exchange.readbundle(ui, f, bundlename) | ||
Matt Mackall
|
r12332 | if self.bundle.compressed(): | ||
FUJIWARA Katsunori
|
r20981 | fdtemp, temp = self.vfs.mkstemp(prefix="hg-bundle-", | ||
suffix=".hg10un") | ||||
Benoit Boissinot
|
r2273 | self.tempfile = temp | ||
fptemp = os.fdopen(fdtemp, 'wb') | ||||
try: | ||||
fptemp.write("HG10UN") | ||||
Martin Geisler
|
r14494 | while True: | ||
Matt Mackall
|
r12332 | chunk = self.bundle.read(2**18) | ||
Matt Mackall
|
r12044 | if not chunk: | ||
break | ||||
Benoit Boissinot
|
r2273 | fptemp.write(chunk) | ||
finally: | ||||
fptemp.close() | ||||
FUJIWARA Katsunori
|
r20981 | f = self.vfs.open(self.tempfile, mode="rb") | ||
Pierre-Yves David
|
r21064 | self.bundle = exchange.readbundle(ui, f, bundlename, self.vfs) | ||
Matt Mackall
|
r12044 | |||
Benoit Boissinot
|
r1942 | # dict with the mapping 'filename' -> position in the bundle | ||
self.bundlefilespos = {} | ||||
Brendan Cully
|
r5262 | |||
Pierre-Yves David
|
r18014 | @localrepo.unfilteredpropertycache | ||
Matt Mackall
|
r8260 | def changelog(self): | ||
Benoit Boissinot
|
r14144 | # consume the header if it exists | ||
self.bundle.changelogheader() | ||||
Matt Mackall
|
r12332 | c = bundlechangelog(self.sopener, self.bundle) | ||
self.manstart = self.bundle.tell() | ||||
Matt Mackall
|
r8260 | return c | ||
Pierre-Yves David
|
r18014 | @localrepo.unfilteredpropertycache | ||
Matt Mackall
|
r8260 | def manifest(self): | ||
Matt Mackall
|
r12332 | self.bundle.seek(self.manstart) | ||
Benoit Boissinot
|
r14144 | # consume the header if it exists | ||
self.bundle.manifestheader() | ||||
Matt Mackall
|
r12332 | m = bundlemanifest(self.sopener, self.bundle, self.changelog.rev) | ||
self.filestart = self.bundle.tell() | ||||
Matt Mackall
|
r8260 | return m | ||
Pierre-Yves David
|
r18014 | @localrepo.unfilteredpropertycache | ||
Matt Mackall
|
r8260 | def manstart(self): | ||
self.changelog | ||||
return self.manstart | ||||
Pierre-Yves David
|
r18014 | @localrepo.unfilteredpropertycache | ||
Matt Mackall
|
r8260 | def filestart(self): | ||
self.manifest | ||||
return self.filestart | ||||
Benoit Boissinot
|
r1942 | |||
Vadim Gelfer
|
r2673 | def url(self): | ||
return self._url | ||||
Benoit Boissinot
|
r1942 | def file(self, f): | ||
Brendan Cully
|
r5262 | if not self.bundlefilespos: | ||
Matt Mackall
|
r12332 | self.bundle.seek(self.filestart) | ||
Martin Geisler
|
r14494 | while True: | ||
Benoit Boissinot
|
r14144 | chunkdata = self.bundle.filelogheader() | ||
if not chunkdata: | ||||
Brendan Cully
|
r5262 | break | ||
Benoit Boissinot
|
r14144 | fname = chunkdata['filename'] | ||
self.bundlefilespos[fname] = self.bundle.tell() | ||||
Martin Geisler
|
r14494 | while True: | ||
Benoit Boissinot
|
r14144 | c = self.bundle.deltachunk(None) | ||
Matt Mackall
|
r12335 | if not c: | ||
break | ||||
Brendan Cully
|
r5262 | |||
Benoit Boissinot
|
r1942 | if f in self.bundlefilespos: | ||
Matt Mackall
|
r12332 | self.bundle.seek(self.bundlefilespos[f]) | ||
return bundlefilelog(self.sopener, f, self.bundle, | ||||
Sune Foldager
|
r14287 | self.changelog.rev, self) | ||
Benoit Boissinot
|
r1942 | else: | ||
Benoit Boissinot
|
r3791 | return filelog.filelog(self.sopener, f) | ||
Benoit Boissinot
|
r1942 | |||
Matt Mackall
|
r12347 | def close(self): | ||
"""Close assigned bundle file immediately.""" | ||||
self.bundle.close() | ||||
Klaus Koch
|
r12962 | if self.tempfile is not None: | ||
FUJIWARA Katsunori
|
r20981 | self.vfs.unlink(self.tempfile) | ||
John Mulligan
|
r6314 | if self._tempparent: | ||
shutil.rmtree(self._tempparent, True) | ||||
Vadim Gelfer
|
r2740 | |||
Matt Mackall
|
r6315 | def cancopy(self): | ||
return False | ||||
Sune Foldager
|
r17193 | def peer(self): | ||
return bundlepeer(self) | ||||
Dirkjan Ochtman
|
r7435 | def getcwd(self): | ||
return os.getcwd() # always outside the repo | ||||
Sune Foldager
|
r15597 | |||
Vadim Gelfer
|
r2740 | def instance(ui, path, create): | ||
if create: | ||||
raise util.Abort(_('cannot create new bundle repository')) | ||||
Peter Arrenbrecht
|
r5664 | parentpath = ui.config("bundle", "mainreporoot", "") | ||
Matt Mackall
|
r16042 | if not parentpath: | ||
# try to find the correct path to the working directory repo | ||||
parentpath = cmdutil.findrepo(os.getcwd()) | ||||
if parentpath is None: | ||||
parentpath = '' | ||||
Peter Arrenbrecht
|
r5664 | 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):] | ||||
Brodie Rao
|
r14076 | u = util.url(path) | ||
Brodie Rao
|
r13826 | path = u.localpath() | ||
if u.scheme == 'bundle': | ||||
Vadim Gelfer
|
r2740 | s = path.split("+", 1) | ||
if len(s) == 1: | ||||
Peter Arrenbrecht
|
r5664 | repopath, bundlename = parentpath, s[0] | ||
Vadim Gelfer
|
r2740 | else: | ||
repopath, bundlename = s | ||||
else: | ||||
Peter Arrenbrecht
|
r5664 | repopath, bundlename = parentpath, path | ||
Vadim Gelfer
|
r2740 | return bundlerepository(ui, repopath, bundlename) | ||
Nicolas Dumazet
|
r12734 | |||
Peter Arrenbrecht
|
r14161 | def getremotechanges(ui, repo, other, onlyheads=None, bundlename=None, | ||
Peter Arrenbrecht
|
r14073 | force=False): | ||
Peter Arrenbrecht
|
r14161 | '''obtains a bundle of changes incoming from other | ||
"onlyheads" restricts the returned changes to those reachable from the | ||||
specified heads. | ||||
"bundlename", if given, stores the bundle to this file path permanently; | ||||
Peter Arrenbrecht
|
r14190 | otherwise it's stored to a temp file and gets deleted again when you call | ||
the returned "cleanupfn". | ||||
Peter Arrenbrecht
|
r14161 | "force" indicates whether to proceed on unrelated repos. | ||
Returns a tuple (local, csets, cleanupfn): | ||||
Brodie Rao
|
r16683 | "local" is a local repo from which to obtain the actual incoming | ||
changesets; it is a bundlerepo for the obtained bundle when the | ||||
original "other" is remote. | ||||
Peter Arrenbrecht
|
r14161 | "csets" lists the incoming changeset node ids. | ||
Brodie Rao
|
r16683 | "cleanupfn" must be called without arguments when you're done processing | ||
the changes; it closes both the original "other" and the one returned | ||||
here. | ||||
Peter Arrenbrecht
|
r14161 | ''' | ||
Brodie Rao
|
r16683 | tmp = discovery.findcommonincoming(repo, other, heads=onlyheads, | ||
force=force) | ||||
Nicolas Dumazet
|
r12734 | common, incoming, rheads = tmp | ||
if not incoming: | ||||
try: | ||||
Sune Foldager
|
r15091 | if bundlename: | ||
Matt Mackall
|
r21694 | os.unlink(bundlename) | ||
Idan Kamara
|
r14004 | except OSError: | ||
Nicolas Dumazet
|
r12734 | pass | ||
Mads Kiilerich
|
r18138 | return repo, [], other.close | ||
Nicolas Dumazet
|
r12734 | |||
Mads Kiilerich
|
r22182 | commonset = set(common) | ||
rheads = [x for x in rheads if x not in commonset] | ||||
Nicolas Dumazet
|
r12734 | bundle = None | ||
Peter Arrenbrecht
|
r14161 | bundlerepo = None | ||
Sune Foldager
|
r17191 | localrepo = other.local() | ||
if bundlename or not localrepo: | ||||
Nicolas Dumazet
|
r12734 | # create a bundle (uncompressed if other repo is not local) | ||
Peter Arrenbrecht
|
r14073 | if other.capable('getbundle'): | ||
Peter Arrenbrecht
|
r14412 | cg = other.getbundle('incoming', common=common, heads=rheads) | ||
elif onlyheads is None and not other.capable('changegroupsubset'): | ||||
# compat with older servers when pulling all remote heads | ||||
Nicolas Dumazet
|
r12734 | cg = other.changegroup(incoming, "incoming") | ||
Peter Arrenbrecht
|
r14412 | rheads = None | ||
Nicolas Dumazet
|
r12734 | else: | ||
Peter Arrenbrecht
|
r14412 | cg = other.changegroupsubset(incoming, rheads, 'incoming') | ||
Sune Foldager
|
r17191 | bundletype = localrepo and "HG10BZ" or "HG10UN" | ||
Nicolas Dumazet
|
r12734 | fname = bundle = changegroup.writebundle(cg, bundlename, bundletype) | ||
# keep written bundle? | ||||
if bundlename: | ||||
bundle = None | ||||
Sune Foldager
|
r17191 | if not localrepo: | ||
Nicolas Dumazet
|
r12734 | # use the created uncompressed bundlerepo | ||
Simon Heimberg
|
r18825 | localrepo = bundlerepo = bundlerepository(repo.baseui, repo.root, | ||
fname) | ||||
Peter Arrenbrecht
|
r14161 | # this repo contains local and other now, so filter out local again | ||
common = repo.heads() | ||||
Pierre-Yves David
|
r18568 | if localrepo: | ||
# Part of common may be remotely filtered | ||||
# So use an unfiltered version | ||||
# The discovery process probably need cleanup to avoid that | ||||
localrepo = localrepo.unfiltered() | ||||
Peter Arrenbrecht
|
r14161 | |||
Peter Arrenbrecht
|
r14412 | csets = localrepo.changelog.findmissing(common, rheads) | ||
Nicolas Dumazet
|
r12734 | |||
Peter Arrenbrecht
|
r14161 | def cleanup(): | ||
if bundlerepo: | ||||
bundlerepo.close() | ||||
if bundle: | ||||
Matt Mackall
|
r21694 | os.unlink(bundle) | ||
Peter Arrenbrecht
|
r14190 | other.close() | ||
Peter Arrenbrecht
|
r14161 | |||
return (localrepo, csets, cleanup) | ||||