def _rebundle(bundlerepo, bundleroots, unknownhead, cgversion, bundlecaps):
"""
Bundle may include more revision then user requested. For example,
if user asks for revision but bundle also consists its descendants.
This function will filter out all revision that user is not requested.
"""
parts = []
outgoing = discovery.outgoing(bundlerepo,
commonheads=bundleroots,
missingheads=[unknownhead])
cgstream = changegroup.makestream(bundlerepo,
outgoing,
cgversion,
"pull",
bundlecaps=bundlecaps)
cgstream = util.chunkbuffer(cgstream).read()
cgpart = bundle2.bundlepart("changegroup", data=cgstream)
cgpart.addparam("version", cgversion)
parts.append(cgpart)
# This parsing should be refactored to be shared with
# exchange.getbundlechunks. But I'll do that in a separate diff.
if bundlecaps is None:
bundlecaps = set()
b2caps = {}
for bcaps in bundlecaps:
if bcaps.startswith("bundle2="):
blob = util.urlreq.unquote(bcaps[len("bundle2="):])
b2caps.update(bundle2.decodecaps(blob))
if constants.scratchmutationparttype in b2caps:
mutdata = mutation.bundle(bundlerepo, outgoing.missing)
parts.append(
bundle2.bundlepart(constants.scratchmutationparttype,
data=mutdata))
try:
treemod = extensions.find("treemanifest")
remotefilelog = extensions.find("remotefilelog")
except KeyError:
pass
else:
missing = outgoing.missing
if remotefilelog.shallowbundle.cansendtrees(bundlerepo,
missing,
source="pull",
bundlecaps=bundlecaps,
b2caps=b2caps):
try:
treepart = treemod.createtreepackpart(
bundlerepo, outgoing, treemod.TREEGROUP_PARTTYPE2)
parts.append(treepart)
except BaseException as ex:
parts.append(bundle2.createerrorpart(str(ex)))
return parts
def pushbackupbundledraftheads(ui, repo, getconnection, heads):
"""
push a backup bundle containing non-public heads to the server
Pushes an infinitepush bundle containing the commits that are non-public
ancestors of `heads`, to the `other` server.
"""
if heads:
# Calculate the commits to back-up. The bundle needs to cleanly
# apply to the server, so we need to include the whole draft stack.
commitstobackup = [
ctx.node() for ctx in repo.set("not public() & ::%ln", heads)
]
# Calculate the parent commits of the commits we are backing up.
# These are the public commits that should be on the server.
parentcommits = [
ctx.node()
for ctx in repo.set("parents(roots(%ln))", commitstobackup)
]
# Build a discovery object encapsulating the commits to backup.
# Skip the actual discovery process, as we know exactly which
# commits are missing. For the common commits, include all the
# parents of the commits we are sending. In the unlikely event that
# the server is missing public commits, we will try again with
# discovery enabled.
og = discovery.outgoing(repo,
commonheads=parentcommits,
missingheads=heads)
og._missing = commitstobackup
og._common = parentcommits
else:
og = None
try:
with getconnection() as conn:
return pushbackupbundle(ui, repo, conn.peer, og, None)
except Exception as e:
ui.warn(_("push failed: %s\n") % e)
ui.warn(_("retrying push with discovery\n"))
with getconnection() as conn:
return pushbackupbundlewithdiscovery(ui, repo, conn.peer, heads, None)
