This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2102

infinitepush: drop the scratchbookmarksparttype bundle2 part
ClosedPublic

Authored by pulkit on Feb 9 2018, 6:46 AM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG5a9692d0d6fc: infinitepush: drop the scratchbookmarksparttype bundle2 part
Summary

The scratchbookmarksparttype bundle2 part was used in backupcommands.py which we
deleted in an earlier changeset. We don't need this part anymore. Moreover we
now have bookmarks bundle2 part in core which we can use. This patch also drops
the related encoding and decoding functions.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

pulkit created this revision.Feb 9 2018, 6:46 AM
indygreg accepted this revision.Feb 9 2018, 10:06 PM
This revision is now accepted and ready to land.Feb 9 2018, 10:06 PM
Closed by commit rHG5a9692d0d6fc: infinitepush: drop the scratchbookmarksparttype bundle2 part (authored by pulkit). · Explain WhyMar 30 2018, 3:52 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 7417

hgext/infinitepush/__init__.py

""" """
from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
import contextlib import contextlib
import errno import errno
import functools import functools
import json
import logging import logging
import os import os
import random import random
import re import re
import socket import socket
import struct
import subprocess import subprocess
import sys import sys
import tempfile import tempfile
import time import time
from mercurial.node import ( from mercurial.node import (
bin, bin,
hex, hex,
except Exception as inst: except Exception as inst:
if repo.bundlestore.index.getbundle(localkey): if repo.bundlestore.index.getbundle(localkey):
return "%s %s\n" % (1, localkey) return "%s %s\n" % (1, localkey)
else: else:
r = str(inst) r = str(inst)
return "%s %s\n" % (0, r) return "%s %s\n" % (0, r)
return _lookup return _lookup
def _decodebookmarks(stream):
sizeofjsonsize = struct.calcsize('>i')
size = struct.unpack('>i', stream.read(sizeofjsonsize))[0]
unicodedict = json.loads(stream.read(size))
# python json module always returns unicode strings. We need to convert
# it back to bytes string
result = {}
for bookmark, node in unicodedict.iteritems():
bookmark = bookmark.encode('ascii')
node = node.encode('ascii')
result[bookmark] = node
return result
def _update(orig, ui, repo, node=None, rev=None, **opts): def _update(orig, ui, repo, node=None, rev=None, **opts):
if rev and node: if rev and node:
raise error.Abort(_("please specify just one revision")) raise error.Abort(_("please specify just one revision"))
if not opts.get('date') and (rev or node) not in repo: if not opts.get('date') and (rev or node) not in repo:
mayberemote = rev or node mayberemote = rev or node
mayberemote = _tryhoist(ui, mayberemote) mayberemote = _tryhoist(ui, mayberemote)
dopull = False dopull = False
def handlereply(op): def handlereply(op):
# server either succeeds or aborts; no code to read # server either succeeds or aborts; no code to read
pushop.cgresult = 1 pushop.cgresult = 1
return handlereply return handlereply
bundle2.capabilities[bundleparts.scratchbranchparttype] = () bundle2.capabilities[bundleparts.scratchbranchparttype] = ()
bundle2.capabilities[bundleparts.scratchbookmarksparttype] = ()
def _getrevs(bundle, oldnode, force, bookmark): def _getrevs(bundle, oldnode, force, bookmark):
'extracts and validates the revs to be imported' 'extracts and validates the revs to be imported'
revs = [bundle[r] for r in bundle.revs('sort(bundle())')] revs = [bundle[r] for r in bundle.revs('sort(bundle())')]
# new bookmark # new bookmark
if oldnode is None: if oldnode is None:
return revs return revs
try: try:
treemfmod = extensions.find('treemanifest') treemfmod = extensions.find('treemanifest')
partforwardingwhitelist.append(treemfmod.TREEGROUP_PARTTYPE2) partforwardingwhitelist.append(treemfmod.TREEGROUP_PARTTYPE2)
except KeyError: except KeyError:
pass pass
bundler = bundle2.bundle20(repo.ui) bundler = bundle2.bundle20(repo.ui)
cgparams = None cgparams = None
scratchbookpart = None
with bundle2.partiterator(repo, op, unbundler) as parts: with bundle2.partiterator(repo, op, unbundler) as parts:
for part in parts: for part in parts:
bundlepart = None bundlepart = None
if part.type == 'replycaps': if part.type == 'replycaps':
# This configures the current operation to allow reply parts. # This configures the current operation to allow reply parts.
bundle2._processpart(op, part) bundle2._processpart(op, part)
elif part.type == bundleparts.scratchbranchparttype: elif part.type == bundleparts.scratchbranchparttype:
# Scratch branch parts need to be converted to normal # Scratch branch parts need to be converted to normal
# changegroup parts, and the extra parameters stored for later # changegroup parts, and the extra parameters stored for later
# when we upload to the store. Eventually those parameters will # when we upload to the store. Eventually those parameters will
# be put on the actual bundle instead of this part, then we can # be put on the actual bundle instead of this part, then we can
# send a vanilla changegroup instead of the scratchbranch part. # send a vanilla changegroup instead of the scratchbranch part.
cgversion = part.params.get('cgversion', '01') cgversion = part.params.get('cgversion', '01')
bundlepart = bundle2.bundlepart('changegroup', data=part.read()) bundlepart = bundle2.bundlepart('changegroup', data=part.read())
bundlepart.addparam('version', cgversion) bundlepart.addparam('version', cgversion)
cgparams = part.params cgparams = part.params
# If we're not dumping all parts into the new bundle, we need to # If we're not dumping all parts into the new bundle, we need to
# alert the future pushkey and phase-heads handler to skip # alert the future pushkey and phase-heads handler to skip
# the part. # the part.
if not handleallparts: if not handleallparts:
op.records.add(scratchbranchparttype + '_skippushkey', True) op.records.add(scratchbranchparttype + '_skippushkey', True)
op.records.add(scratchbranchparttype + '_skipphaseheads', op.records.add(scratchbranchparttype + '_skipphaseheads',
True) True)
elif part.type == bundleparts.scratchbookmarksparttype:
# Save this for later processing. Details below.
#
# Upstream https://phab.mercurial-scm.org/D1389 and its
# follow-ups stop part.seek support to reduce memory usage
# (https://bz.mercurial-scm.org/5691). So we need to copy
# the part so it can be consumed later.
scratchbookpart = bundleparts.copiedpart(part)
else: else:
if handleallparts or part.type in partforwardingwhitelist: if handleallparts or part.type in partforwardingwhitelist:
# Ideally we would not process any parts, and instead just # Ideally we would not process any parts, and instead just
# forward them to the bundle for storage, but since this # forward them to the bundle for storage, but since this
# differs from previous behavior, we need to put it behind a # differs from previous behavior, we need to put it behind a
# config flag for incremental rollout. # config flag for incremental rollout.
bundlepart = bundle2.bundlepart(part.type, data=part.read()) bundlepart = bundle2.bundlepart(part.type, data=part.read())
for key, value in part.params.iteritems(): for key, value in part.params.iteritems():
storebundle(op, cgparams, bundlefile) storebundle(op, cgparams, bundlefile)
finally: finally:
try: try:
os.unlink(bundlefile) os.unlink(bundlefile)
except Exception: except Exception:
# we would rather see the original exception # we would rather see the original exception
pass pass
# The scratch bookmark part is sent as part of a push backup. It needs to be
# processed after the main bundle has been stored, so that any commits it
# references are available in the store.
if scratchbookpart:
bundle2._processpart(op, scratchbookpart)
def storebundle(op, params, bundlefile): def storebundle(op, params, bundlefile):
log = _getorcreateinfinitepushlogger(op) log = _getorcreateinfinitepushlogger(op)
parthandlerstart = time.time() parthandlerstart = time.time()
log(scratchbranchparttype, eventtype='start') log(scratchbranchparttype, eventtype='start')
index = op.repo.bundlestore.index index = op.repo.bundlestore.index
store = op.repo.bundlestore.store store = op.repo.bundlestore.store
op.records.add(scratchbranchparttype + '_skippushkey', True) op.records.add(scratchbranchparttype + '_skippushkey', True)
try: try:
os.unlink(bundlefile) os.unlink(bundlefile)
except OSError as e: except OSError as e:
if e.errno != errno.ENOENT: if e.errno != errno.ENOENT:
raise raise
return 1 return 1
@bundle2.parthandler(bundleparts.scratchbookmarksparttype)
def bundle2scratchbookmarks(op, part):
'''Handler deletes bookmarks first then adds new bookmarks.
'''
index = op.repo.bundlestore.index
decodedbookmarks = _decodebookmarks(part)
toinsert = {}
todelete = []
for bookmark, node in decodedbookmarks.iteritems():
if node:
toinsert[bookmark] = node
else:
todelete.append(bookmark)
log = _getorcreateinfinitepushlogger(op)
with logservicecall(log, bundleparts.scratchbookmarksparttype), index:
if todelete:
index.deletebookmarks(todelete)
if toinsert:
index.addmanybookmarks(toinsert)
def _maybeaddpushbackpart(op, bookmark, newnode, oldnode, params): def _maybeaddpushbackpart(op, bookmark, newnode, oldnode, params):
if params.get('pushbackbookmarks'): if params.get('pushbackbookmarks'):
if op.reply and 'pushback' in op.reply.capabilities: if op.reply and 'pushback' in op.reply.capabilities:
params = { params = {
'namespace': 'bookmarks', 'namespace': 'bookmarks',
'key': bookmark, 'key': bookmark,
'new': newnode, 'new': newnode,
'old': oldnode, 'old': oldnode,

hgext/infinitepush/bundleparts.py

error, error,
extensions, extensions,
revsetlang, revsetlang,
util, util,
) )
from . import common from . import common
encodebookmarks = common.encodebookmarks
isremotebooksenabled = common.isremotebooksenabled isremotebooksenabled = common.isremotebooksenabled
scratchbranchparttype = 'b2x:infinitepush' scratchbranchparttype = 'b2x:infinitepush'
scratchbookmarksparttype = 'b2x:infinitepushscratchbookmarks'
def getscratchbranchparts(repo, peer, outgoing, confignonforwardmove, def getscratchbranchparts(repo, peer, outgoing, confignonforwardmove,
ui, bookmark, create): ui, bookmark, create):
if not outgoing.missing: if not outgoing.missing:
raise error.Abort(_('no commits to push')) raise error.Abort(_('no commits to push'))
if scratchbranchparttype not in bundle2.bundle2caps(peer): if scratchbranchparttype not in bundle2.bundle2caps(peer):
raise error.Abort(_('no server support for %r') % scratchbranchparttype) raise error.Abort(_('no server support for %r') % scratchbranchparttype)
if not repo.manifestlog.datastore.getmissing(mfnodes): if not repo.manifestlog.datastore.getmissing(mfnodes):
parts.append(treemod.createtreepackpart( parts.append(treemod.createtreepackpart(
repo, outgoing, treemod.TREEGROUP_PARTTYPE2)) repo, outgoing, treemod.TREEGROUP_PARTTYPE2))
except KeyError: except KeyError:
pass pass
return parts return parts
def getscratchbookmarkspart(peer, bookmarks):
if scratchbookmarksparttype not in bundle2.bundle2caps(peer):
raise error.Abort(
_('no server support for %r') % scratchbookmarksparttype)
return bundle2.bundlepart(
scratchbookmarksparttype.upper(),
data=encodebookmarks(bookmarks))
def _validaterevset(repo, revset, bookmark): def _validaterevset(repo, revset, bookmark):
"""Abort if the revs to be pushed aren't valid for a scratch branch.""" """Abort if the revs to be pushed aren't valid for a scratch branch."""
if not repo.revs(revset): if not repo.revs(revset):
raise error.Abort(_('nothing to push')) raise error.Abort(_('nothing to push'))
if bookmark: if bookmark:
# Allow bundle with many heads only if no bookmark is specified # Allow bundle with many heads only if no bookmark is specified
heads = repo.revs('heads(%r)', revset) heads = repo.revs('heads(%r)', revset)
if len(heads) > 1: if len(heads) > 1:

hgext/infinitepush/common.py

# Copyright 2017 Facebook, Inc. # Copyright 2017 Facebook, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import json
import os import os
import struct
import tempfile import tempfile
from mercurial.node import hex from mercurial.node import hex
from mercurial import ( from mercurial import (
error, error,
extensions, extensions,
) )
def isremotebooksenabled(ui): def isremotebooksenabled(ui):
return ('remotenames' in extensions._extensions and return ('remotenames' in extensions._extensions and
ui.configbool('remotenames', 'bookmarks')) ui.configbool('remotenames', 'bookmarks'))
def encodebookmarks(bookmarks):
encoded = {}
for bookmark, node in bookmarks.iteritems():
encoded[bookmark] = node
dumped = json.dumps(encoded)
result = struct.pack('>i', len(dumped)) + dumped
return result
def downloadbundle(repo, unknownbinhead): def downloadbundle(repo, unknownbinhead):
index = repo.bundlestore.index index = repo.bundlestore.index
store = repo.bundlestore.store store = repo.bundlestore.store
bundleid = index.getbundle(hex(unknownbinhead)) bundleid = index.getbundle(hex(unknownbinhead))
if bundleid is None: if bundleid is None:
raise error.Abort('%s head is not known' % hex(unknownbinhead)) raise error.Abort('%s head is not known' % hex(unknownbinhead))
bundleraw = store.read(bundleid) bundleraw = store.read(bundleid)
return _makebundlefromraw(bundleraw) return _makebundlefromraw(bundleraw)