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

equal deleted inserted replaced

-:189491cea922
+:dabec69bd6fc
 def release(self):
 raise NotImplementedError
+class getremotechanges_state_tracker:
+def __init__(self, peer, incoming, common, rheads):
+# bundle file to be deleted
+self.bundle = None
+# bundle repo to be closed
+self.bundlerepo = None
+# remote peer connection to be closed
+self.peer = peer
+# if peer is remote, `localrepo` will be equal to
+# `bundlerepo` when bundle is created.
+self.localrepo = peer.local()
+# `incoming` operation parameters:
+# (these get mutated by _create_bundle)
+self.incoming = incoming
+self.common = common
+self.rheads = rheads
+def cleanup(self):
+try:
+if self.bundlerepo:
+self.bundlerepo.close()
+finally:
+try:
+if self.bundle:
+os.unlink(self.bundle)
+finally:
+self.peer.close()
 def getremotechanges(
 ui, repo, peer, onlyheads=None, bundlename=None, force=False
 ):
 """obtains a bundle of changes incoming from peer
 return repo, [], peer.close
 commonset = set(common)
 rheads = [x for x in rheads if x not in commonset]
-bundle = None
+state = getremotechanges_state_tracker(peer, incoming, common, rheads)
-bundlerepo = None
+csets = _getremotechanges_slowpath(
-localrepo = peer.local()
+state, ui, repo, bundlename=bundlename, onlyheads=onlyheads
-if bundlename or not localrepo:
+)
+return (state.localrepo, csets, state.cleanup)
+def _create_bundle(state, ui, repo, bundlename, onlyheads):
+if True:
 # create a bundle (uncompressed if peer repo is not local)
 # developer config: devel.legacy.exchange
 legexc = ui.configlist(b'devel', b'legacy.exchange')
 forcebundle1 = b'bundle2' not in legexc and b'bundle1' in legexc
 canbundle2 = (
 not forcebundle1
-and peer.capable(b'getbundle')
+and state.peer.capable(b'getbundle')
-and peer.capable(b'bundle2')
+and state.peer.capable(b'bundle2')
 )
 if canbundle2:
-with peer.commandexecutor() as e:
+with state.peer.commandexecutor() as e:
 b2 = e.callcommand(
 b'getbundle',
 {
 b'source': b'incoming',
-b'common': common,
+b'common': state.common,
-b'heads': rheads,
+b'heads': state.rheads,
 b'bundlecaps': exchange.caps20to10(
 repo, role=b'client'
 ),
 b'cg': True,
 },
 ).result()
-fname = bundle = changegroup.writechunks(
+fname = state.bundle = changegroup.writechunks(
 ui, b2._forwardchunks(), bundlename
 )
 else:
-if peer.capable(b'getbundle'):
+if state.peer.capable(b'getbundle'):
-with peer.commandexecutor() as e:
+with state.peer.commandexecutor() as e:
 cg = e.callcommand(
 b'getbundle',
 {
 b'source': b'incoming',
-b'common': common,
+b'common': state.common,
-b'heads': rheads,
+b'heads': state.rheads,
 },
 ).result()
-elif onlyheads is None and not peer.capable(b'changegroupsubset'):
+elif onlyheads is None and not state.peer.capable(
+b'changegroupsubset'
+):
 # compat with older servers when pulling all remote heads
-with peer.commandexecutor() as e:
+with state.peer.commandexecutor() as e:
 cg = e.callcommand(
 b'changegroup',
 {
-b'nodes': incoming,
+b'nodes': state.incoming,
 b'source': b'incoming',
 },
 ).result()
-rheads = None
+state.rheads = None
 else:
-with peer.commandexecutor() as e:
+with state.peer.commandexecutor() as e:
 cg = e.callcommand(
 b'changegroupsubset',
 {
-b'bases': incoming,
+b'bases': state.incoming,
-b'heads': rheads,
+b'heads': state.rheads,
 b'source': b'incoming',
 },
 ).result()
-if localrepo:
+if state.localrepo:
 bundletype = b"HG10BZ"
 else:
 bundletype = b"HG10UN"
-fname = bundle = bundle2.writebundle(ui, cg, bundlename, bundletype)
+fname = state.bundle = bundle2.writebundle(
+ui, cg, bundlename, bundletype
+)
 # keep written bundle?
 if bundlename:
-bundle = None
+state.bundle = None
-if not localrepo:
+return fname
+def _getremotechanges_slowpath(
+state, ui, repo, bundlename=None, onlyheads=None
+):
+if bundlename or not state.localrepo:
+fname = _create_bundle(
+state,
+ui,
+repo,
+bundlename=bundlename,
+onlyheads=onlyheads,
+)
+if not state.localrepo:
 # use the created uncompressed bundlerepo
-localrepo = bundlerepo = makebundlerepository(
+state.localrepo = state.bundlerepo = makebundlerepository(
 repo.baseui, repo.root, fname
 )
 # this repo contains local and peer now, so filter out local again
-common = repo.heads()
+state.common = repo.heads()
-if localrepo:
+if state.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()
+state.localrepo = state.localrepo.unfiltered()
-csets = localrepo.changelog.findmissing(common, rheads)
+csets = state.localrepo.changelog.findmissing(state.common, state.rheads)
-if bundlerepo:
+if state.bundlerepo:
+bundlerepo = state.bundlerepo
 reponodes = [ctx.node() for ctx in bundlerepo[bundlerepo.firstnewrev :]]
-with peer.commandexecutor() as e:
+with state.peer.commandexecutor() as e:
 remotephases = e.callcommand(
 b'listkeys',
 {
 b'namespace': b'phases',
 },
 ).result()
 pullop = exchange.pulloperation(
-bundlerepo, peer, path=None, heads=reponodes
+bundlerepo, state.peer, path=None, heads=reponodes
 )
 pullop.trmanager = bundletransactionmanager()
 exchange._pullapplyphases(pullop, remotephases)
-def cleanup():
+return csets
-if bundlerepo:
-bundlerepo.close()
-if bundle:
-os.unlink(bundle)
-peer.close()
-return (localrepo, csets, cleanup)

changeset 52844	dabec69bd6fc
parent 52643	5cc8deb96b48
child 52845	b25208655467