mercurial-scm/hg: mercurial/bundlerepo.py comparison

comparison mercurial/bundlerepo.py @ 43076:2372284d9457

formatting: blacken the codebase This is using my patch to black (https://github.com/psf/black/pull/826) so we don't un-wrap collection literals. Done with: hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"' | xargs black -S # skip-blame mass-reformatting only # no-check-commit reformats foo_bar functions Differential Revision: https://phab.mercurial-scm.org/D6971

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:45:02 -0400
parents	5ba8c328a895
children	687b865b95ad

comparison

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 import os
 import shutil
 from .i18n import _
-from .node import (
+from .node import nullid, nullrev
-nullid,
-nullrev
-)
 from . import (
 bundle2,
 changegroup,
 changelog,
 revlog,
 util,
 vfs as vfsmod,
 )
 class bundlerevlog(revlog.revlog):
 def __init__(self, opener, indexfile, cgunpacker, linkmapper):
 # How it works:
 # 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
 opener = vfsmod.readonlyvfs(opener)
 revlog.revlog.__init__(self, opener, indexfile)
 self.bundle = cgunpacker
 n = len(self)
 self.repotiprev = n - 1
-self.bundlerevs = set() # used by 'bundle()' revset expression
+self.bundlerevs = set()  # used by 'bundle()' revset expression
 for deltadata in cgunpacker.deltaiter():
 node, p1, p2, cs, deltabase, delta, flags = deltadata
 size = len(delta)
 start = cgunpacker.tell() - size
 self.bundlerevs.add(self.nodemap[node])
 continue
 for p in (p1, p2):
 if p not in self.nodemap:
-raise error.LookupError(p, self.indexfile,
+raise error.LookupError(
-_("unknown parent"))
+p, self.indexfile, _("unknown parent")
+)
 if deltabase not in self.nodemap:
-raise LookupError(deltabase, self.indexfile,
+raise LookupError(
-_('unknown delta base'))
+deltabase, self.indexfile, _('unknown delta base')
+)
 baserev = self.rev(deltabase)
 # start, size, full unc. size, base (unused), link, p1, p2, node
-e = (revlog.offset_type(start, flags), size, -1, baserev, link,
+e = (
-self.rev(p1), self.rev(p2), node)
+revlog.offset_type(start, flags),
+size,
+-1,
+baserev,
+link,
+self.rev(p1),
+self.rev(p2),
+node,
+)
 self.index.append(e)
 self.nodemap[node] = n
 self.bundlerevs.add(n)
 n += 1
 if revb == rev1:
 return self._chunk(rev2)
 elif rev1 <= self.repotiprev and rev2 <= self.repotiprev:
 return revlog.revlog.revdiff(self, rev1, rev2)
-return mdiff.textdiff(self.rawdata(rev1),
+return mdiff.textdiff(self.rawdata(rev1), self.rawdata(rev2))
-self.rawdata(rev2))
 def _rawtext(self, node, rev, _df=None):
 if rev is None:
 rev = self.rev(node)
 validated = False
 chain.append(iterrev)
 iterrev = self.index[iterrev][3]
 if iterrev == nullrev:
 rawtext = ''
 elif rawtext is None:
-r = super(bundlerevlog, self)._rawtext(self.node(iterrev),
+r = super(bundlerevlog, self)._rawtext(
-iterrev,
+self.node(iterrev), iterrev, _df=_df
-_df=_df)
+)
 __, rawtext, validated = r
 if chain:
 validated = False
 while chain:
 delta = self._chunk(chain.pop())
 raise NotImplementedError
 def checksize(self):
 raise NotImplementedError
 class bundlechangelog(bundlerevlog, changelog.changelog):
 def __init__(self, opener, cgunpacker):
 changelog.changelog.__init__(self, opener)
 linkmapper = lambda x: x
-bundlerevlog.__init__(self, opener, self.indexfile, cgunpacker,
+bundlerevlog.__init__(
-linkmapper)
+self, opener, self.indexfile, cgunpacker, linkmapper
+)
 class bundlemanifest(bundlerevlog, manifest.manifestrevlog):
-def __init__(self, opener, cgunpacker, linkmapper, dirlogstarts=None,
+def __init__(
-dir=''):
+self, opener, cgunpacker, linkmapper, dirlogstarts=None, dir=''
+):
 manifest.manifestrevlog.__init__(self, opener, tree=dir)
-bundlerevlog.__init__(self, opener, self.indexfile, cgunpacker,
+bundlerevlog.__init__(
-linkmapper)
+self, opener, self.indexfile, cgunpacker, linkmapper
+)
 if dirlogstarts is None:
 dirlogstarts = {}
 if self.bundle.version == "03":
 dirlogstarts = _getfilestarts(self.bundle)
 self._dirlogstarts = dirlogstarts
 def dirlog(self, d):
 if d in self._dirlogstarts:
 self.bundle.seek(self._dirlogstarts[d])
 return bundlemanifest(
-self.opener, self.bundle, self._linkmapper,
+self.opener,
-self._dirlogstarts, dir=d)
+self.bundle,
+self._linkmapper,
+self._dirlogstarts,
+dir=d,
+)
 return super(bundlemanifest, self).dirlog(d)
 class bundlefilelog(filelog.filelog):
 def __init__(self, opener, path, cgunpacker, linkmapper):
 filelog.filelog.__init__(self, opener, path)
-self._revlog = bundlerevlog(opener, self.indexfile,
+self._revlog = bundlerevlog(
-cgunpacker, linkmapper)
+opener, self.indexfile, cgunpacker, linkmapper
+)
 class bundlepeer(localrepo.localpeer):
 def canpush(self):
 return False
 class bundlephasecache(phases.phasecache):
 def __init__(self, *args, **kwargs):
 super(bundlephasecache, self).__init__(*args, **kwargs)
 if util.safehasattr(self, 'opener'):
 def _updateroots(self, phase, newroots, tr):
 self.phaseroots[phase] = newroots
 self.invalidate()
 self.dirty = True
 def _getfilestarts(cgunpacker):
 filespos = {}
 for chunkdata in iter(cgunpacker.filelogheader, {}):
 fname = chunkdata['filename']
 filespos[fname] = cgunpacker.tell()
 for chunk in iter(lambda: cgunpacker.deltachunk(None), {}):
 pass
 return filespos
 class bundlerepository(object):
 """A repository instance that is a union of a local repo and a bundle.
 Instances represent a read-only repository composed of a local repository
 with the contents of a bundle file applied. The repository instance is
 applied to the actual base repository.
 Instances constructed directly are not usable as repository objects.
 Use instance() or makebundlerepository() to create instances.
 """
 def __init__(self, bundlepath, url, tempparent):
 self._tempparent = tempparent
 self._url = url
 self.ui.setconfig('phases', 'publish', False, 'bundlerepo')
 cgpart = None
 for part in bundle.iterparts(seekable=True):
 if part.type == 'changegroup':
 if cgpart:
-raise NotImplementedError("can't process "
+raise NotImplementedError(
-"multiple changegroups")
+"can't process " "multiple changegroups"
+)
 cgpart = part
 self._handlebundle2part(bundle, part)
 if not cgpart:
 # generator returns control to iterparts().
 cgpart.seek(0, os.SEEK_SET)
 elif isinstance(bundle, changegroup.cg1unpacker):
 if bundle.compressed():
-f = self._writetempbundle(bundle.read, '.hg10un',
+f = self._writetempbundle(
-header='HG10UN')
+bundle.read, '.hg10un', header='HG10UN'
+)
 bundle = exchange.readbundle(self.ui, f, bundlepath, self.vfs)
 self._bundlefile = bundle
 self._cgunpacker = bundle
 else:
-raise error.Abort(_('bundle type %s cannot be read') %
+raise error.Abort(_('bundle type %s cannot be read') % type(bundle))
-type(bundle))
 # dict with the mapping 'filename' -> position in the changegroup.
 self._cgfilespos = {}
 self.firstnewrev = self.changelog.repotiprev + 1
-phases.retractboundary(self, None, phases.draft,
+phases.retractboundary(
-[ctx.node() for ctx in self[self.firstnewrev:]])
+self,
+None,
+phases.draft,
+[ctx.node() for ctx in self[self.firstnewrev :]],
+)
 def _handlebundle2part(self, bundle, part):
 if part.type != 'changegroup':
 return
 self._cgunpacker = changegroup.getunbundler(version, cgstream, 'UN')
 def _writetempbundle(self, readfn, suffix, header=''):
 """Write a temporary file to disk
 """
-fdtemp, temp = self.vfs.mkstemp(prefix="hg-bundle-",
+fdtemp, temp = self.vfs.mkstemp(prefix="hg-bundle-", suffix=suffix)
-suffix=suffix)
 self.tempfile = temp
 with os.fdopen(fdtemp, r'wb') as fptemp:
 fptemp.write(header)
 while True:
-chunk = readfn(2**18)
+chunk = readfn(2 ** 18)
 if not chunk:
 break
 fptemp.write(chunk)
 return self.vfs.open(self.tempfile, mode="rb")
 self._cgunpacker.manifestheader()
 linkmapper = self.unfiltered().changelog.rev
 rootstore = bundlemanifest(self.svfs, self._cgunpacker, linkmapper)
 self.filestart = self._cgunpacker.tell()
-return manifest.manifestlog(self.svfs, self, rootstore,
+return manifest.manifestlog(
-self.narrowmatch())
+self.svfs, self, rootstore, self.narrowmatch()
+)
 def _consumemanifest(self):
 """Consumes the manifest portion of the bundle, setting filestart so the
 file portion can be read."""
 self._cgunpacker.seek(self.manstart)
 def peer(self):
 return bundlepeer(self)
 def getcwd(self):
-return encoding.getcwd() # always outside the repo
+return encoding.getcwd()  # always outside the repo
 # Check if parents exist in localrepo before setting
 def setparents(self, p1, p2=nullid):
 p1rev = self.changelog.rev(p1)
 p2rev = self.changelog.rev(p2)
 if self.changelog.repotiprev < p1rev:
 self.ui.warn(msg % nodemod.hex(p1))
 if self.changelog.repotiprev < p2rev:
 self.ui.warn(msg % nodemod.hex(p2))
 return super(bundlerepository, self).setparents(p1, p2)
 def instance(ui, path, create, intents=None, createopts=None):
 if create:
 raise error.Abort(_('cannot create new bundle repository'))
 # internal config: bundle.mainreporoot
 if parentpath == cwd:
 parentpath = ''
 else:
 cwd = pathutil.normasprefix(cwd)
 if parentpath.startswith(cwd):
-parentpath = parentpath[len(cwd):]
+parentpath = parentpath[len(cwd) :]
 u = util.url(path)
 path = u.localpath()
 if u.scheme == 'bundle':
 s = path.split("+", 1)
 if len(s) == 1:
 else:
 repopath, bundlename = parentpath, path
 return makebundlerepository(ui, repopath, bundlename)
 def makebundlerepository(ui, repopath, bundlepath):
 """Make a bundle repository object based on repo and bundle paths."""
 if repopath:
 url = 'bundle:%s+%s' % (util.expandpath(repopath), bundlepath)
 else:
 repo.__class__ = derivedbundlerepository
 bundlerepository.__init__(repo, bundlepath, url, tempparent)
 return repo
 class bundletransactionmanager(object):
 def transaction(self):
 return None
 def close(self):
 raise NotImplementedError
 def release(self):
 raise NotImplementedError
-def getremotechanges(ui, repo, peer, onlyheads=None, bundlename=None,
-force=False):
+def getremotechanges(
+ui, repo, peer, onlyheads=None, bundlename=None, force=False
+):
 '''obtains a bundle of changes incoming from peer
 "onlyheads" restricts the returned changes to those reachable from the
 specified heads.
 "bundlename", if given, stores the bundle to this file path permanently;
 "csets" lists the incoming changeset node ids.
 "cleanupfn" must be called without arguments when you're done processing
 the changes; it closes both the original "peer" and the one returned
 here.
 '''
-tmp = discovery.findcommonincoming(repo, peer, heads=onlyheads,
+tmp = discovery.findcommonincoming(repo, peer, heads=onlyheads, force=force)
-force=force)
 common, incoming, rheads = tmp
 if not incoming:
 try:
 if bundlename:
 os.unlink(bundlename)
 # create a bundle (uncompressed if peer repo is not local)
 # developer config: devel.legacy.exchange
 legexc = ui.configlist('devel', 'legacy.exchange')
 forcebundle1 = 'bundle2' not in legexc and 'bundle1' in legexc
-canbundle2 = (not forcebundle1
+canbundle2 = (
-and peer.capable('getbundle')
+not forcebundle1
-and peer.capable('bundle2'))
+and peer.capable('getbundle')
+and peer.capable('bundle2')
+)
 if canbundle2:
 with peer.commandexecutor() as e:
-b2 = e.callcommand('getbundle', {
+b2 = e.callcommand(
-'source': 'incoming',
+'getbundle',
-'common': common,
+{
-'heads': rheads,
+'source': 'incoming',
-'bundlecaps': exchange.caps20to10(repo, role='client'),
+'common': common,
-'cg': True,
+'heads': rheads,
-}).result()
+'bundlecaps': exchange.caps20to10(repo, role='client'),
+'cg': True,
-fname = bundle = changegroup.writechunks(ui,
+},
-b2._forwardchunks(),
+).result()
-bundlename)
+fname = bundle = changegroup.writechunks(
+ui, b2._forwardchunks(), bundlename
+)
 else:
 if peer.capable('getbundle'):
 with peer.commandexecutor() as e:
-cg = e.callcommand('getbundle', {
+cg = e.callcommand(
-'source': 'incoming',
+'getbundle',
-'common': common,
+{
-'heads': rheads,
+'source': 'incoming',
-}).result()
+'common': common,
+'heads': rheads,
+},
+).result()
 elif onlyheads is None and not peer.capable('changegroupsubset'):
 # compat with older servers when pulling all remote heads
 with peer.commandexecutor() as e:
-cg = e.callcommand('changegroup', {
+cg = e.callcommand(
-'nodes': incoming,
+'changegroup',
-'source': 'incoming',
+{'nodes': incoming, 'source': 'incoming',},
-}).result()
+).result()
 rheads = None
 else:
 with peer.commandexecutor() as e:
-cg = e.callcommand('changegroupsubset', {
+cg = e.callcommand(
-'bases': incoming,
+'changegroupsubset',
-'heads': rheads,
+{
-'source': 'incoming',
+'bases': incoming,
-}).result()
+'heads': rheads,
+'source': 'incoming',
+},
+).result()
 if localrepo:
 bundletype = "HG10BZ"
 else:
 bundletype = "HG10UN"
-fname = bundle = bundle2.writebundle(ui, cg, bundlename,
+fname = bundle = bundle2.writebundle(ui, cg, bundlename, bundletype)
-bundletype)
 # keep written bundle?
 if bundlename:
 bundle = None
 if not localrepo:
 # use the created uncompressed bundlerepo
-localrepo = bundlerepo = makebundlerepository(repo. baseui,
+localrepo = bundlerepo = makebundlerepository(
-repo.root,
+repo.baseui, repo.root, fname
-fname)
+)
 # this repo contains local and peer now, so filter out local again
 common = repo.heads()
 if localrepo:
 # Part of common may be remotely filtered
 localrepo = localrepo.unfiltered()
 csets = localrepo.changelog.findmissing(common, rheads)
 if bundlerepo:
-reponodes = [ctx.node() for ctx in bundlerepo[bundlerepo.firstnewrev:]]
+reponodes = [ctx.node() for ctx in bundlerepo[bundlerepo.firstnewrev :]]
 with peer.commandexecutor() as e:
-remotephases = e.callcommand('listkeys', {
+remotephases = e.callcommand(
-'namespace': 'phases',
+'listkeys', {'namespace': 'phases',}
-}).result()
+).result()
 pullop = exchange.pulloperation(bundlerepo, peer, heads=reponodes)
 pullop.trmanager = bundletransactionmanager()
 exchange._pullapplyphases(pullop, remotephases)

Mercurial > public > mercurial-scm > hg

comparison mercurial/bundlerepo.py @ 43076:2372284d9457