--- a/mercurial/bundle2.py Sun Oct 06 09:45:02 2019 -0400
+++ b/mercurial/bundle2.py Sun Oct 06 09:48:39 2019 -0400
@@ -179,28 +179,28 @@
_pack = struct.pack
_unpack = struct.unpack
-_fstreamparamsize = '>i'
-_fpartheadersize = '>i'
-_fparttypesize = '>B'
-_fpartid = '>I'
-_fpayloadsize = '>i'
-_fpartparamcount = '>BB'
+_fstreamparamsize = b'>i'
+_fpartheadersize = b'>i'
+_fparttypesize = b'>B'
+_fpartid = b'>I'
+_fpayloadsize = b'>i'
+_fpartparamcount = b'>BB'
preferedchunksize = 32768
-_parttypeforbidden = re.compile('[^a-zA-Z0-9_:-]')
+_parttypeforbidden = re.compile(b'[^a-zA-Z0-9_:-]')
def outdebug(ui, message):
"""debug regarding output stream (bundling)"""
- if ui.configbool('devel', 'bundle2.debug'):
- ui.debug('bundle2-output: %s\n' % message)
+ if ui.configbool(b'devel', b'bundle2.debug'):
+ ui.debug(b'bundle2-output: %s\n' % message)
def indebug(ui, message):
"""debug on input stream (unbundling)"""
- if ui.configbool('devel', 'bundle2.debug'):
- ui.debug('bundle2-input: %s\n' % message)
+ if ui.configbool(b'devel', b'bundle2.debug'):
+ ui.debug(b'bundle2-input: %s\n' % message)
def validateparttype(parttype):
@@ -215,7 +215,7 @@
The number parameters is variable so we need to build that format
dynamically.
"""
- return '>' + ('BB' * nbparams)
+ return b'>' + (b'BB' * nbparams)
parthandlermapping = {}
@@ -307,7 +307,7 @@
* a way to construct a bundle response when applicable.
"""
- def __init__(self, repo, transactiongetter, captureoutput=True, source=''):
+ def __init__(self, repo, transactiongetter, captureoutput=True, source=b''):
self.repo = repo
self.ui = repo.ui
self.records = unbundlerecords()
@@ -337,8 +337,8 @@
def addhookargs(self, hookargs):
if self.hookargs is None:
raise error.ProgrammingError(
- 'attempted to add hookargs to '
- 'operation after transaction started'
+ b'attempted to add hookargs to '
+ b'operation after transaction started'
)
self.hookargs.update(hookargs)
@@ -358,11 +358,11 @@
def applybundle(repo, unbundler, tr, source, url=None, **kwargs):
# transform me into unbundler.apply() as soon as the freeze is lifted
if isinstance(unbundler, unbundle20):
- tr.hookargs['bundle2'] = '1'
- if source is not None and 'source' not in tr.hookargs:
- tr.hookargs['source'] = source
- if url is not None and 'url' not in tr.hookargs:
- tr.hookargs['url'] = url
+ tr.hookargs[b'bundle2'] = b'1'
+ if source is not None and b'source' not in tr.hookargs:
+ tr.hookargs[b'source'] = source
+ if url is not None and b'url' not in tr.hookargs:
+ tr.hookargs[b'url'] = url
return processbundle(repo, unbundler, lambda: tr, source=source)
else:
# the transactiongetter won't be used, but we might as well set it
@@ -438,11 +438,11 @@
raise exc
self.repo.ui.debug(
- 'bundle2-input-bundle: %i parts total\n' % self.count
+ b'bundle2-input-bundle: %i parts total\n' % self.count
)
-def processbundle(repo, unbundler, transactiongetter=None, op=None, source=''):
+def processbundle(repo, unbundler, transactiongetter=None, op=None, source=b''):
"""This function process a bundle, apply effect to/from a repo
It iterates over each part then searches for and uses the proper handling
@@ -464,15 +464,15 @@
# - exception catching
unbundler.params
if repo.ui.debugflag:
- msg = ['bundle2-input-bundle:']
+ msg = [b'bundle2-input-bundle:']
if unbundler.params:
- msg.append(' %i params' % len(unbundler.params))
+ msg.append(b' %i params' % len(unbundler.params))
if op._gettransaction is None or op._gettransaction is _notransaction:
- msg.append(' no-transaction')
+ msg.append(b' no-transaction')
else:
- msg.append(' with-transaction')
- msg.append('\n')
- repo.ui.debug(''.join(msg))
+ msg.append(b' with-transaction')
+ msg.append(b'\n')
+ repo.ui.debug(b''.join(msg))
processparts(repo, op, unbundler)
@@ -487,48 +487,48 @@
def _processchangegroup(op, cg, tr, source, url, **kwargs):
ret = cg.apply(op.repo, tr, source, url, **kwargs)
- op.records.add('changegroup', {'return': ret,})
+ op.records.add(b'changegroup', {b'return': ret,})
return ret
def _gethandler(op, part):
- status = 'unknown' # used by debug output
+ status = b'unknown' # used by debug output
try:
handler = parthandlermapping.get(part.type)
if handler is None:
- status = 'unsupported-type'
+ status = b'unsupported-type'
raise error.BundleUnknownFeatureError(parttype=part.type)
- indebug(op.ui, 'found a handler for part %s' % part.type)
+ indebug(op.ui, b'found a handler for part %s' % part.type)
unknownparams = part.mandatorykeys - handler.params
if unknownparams:
unknownparams = list(unknownparams)
unknownparams.sort()
- status = 'unsupported-params (%s)' % ', '.join(unknownparams)
+ status = b'unsupported-params (%s)' % b', '.join(unknownparams)
raise error.BundleUnknownFeatureError(
parttype=part.type, params=unknownparams
)
- status = 'supported'
+ status = b'supported'
except error.BundleUnknownFeatureError as exc:
if part.mandatory: # mandatory parts
raise
- indebug(op.ui, 'ignoring unsupported advisory part %s' % exc)
+ indebug(op.ui, b'ignoring unsupported advisory part %s' % exc)
return # skip to part processing
finally:
if op.ui.debugflag:
- msg = ['bundle2-input-part: "%s"' % part.type]
+ msg = [b'bundle2-input-part: "%s"' % part.type]
if not part.mandatory:
- msg.append(' (advisory)')
+ msg.append(b' (advisory)')
nbmp = len(part.mandatorykeys)
nbap = len(part.params) - nbmp
if nbmp or nbap:
- msg.append(' (params:')
+ msg.append(b' (params:')
if nbmp:
- msg.append(' %i mandatory' % nbmp)
+ msg.append(b' %i mandatory' % nbmp)
if nbap:
- msg.append(' %i advisory' % nbmp)
- msg.append(')')
- msg.append(' %s\n' % status)
- op.ui.debug(''.join(msg))
+ msg.append(b' %i advisory' % nbmp)
+ msg.append(b')')
+ msg.append(b' %s\n' % status)
+ op.ui.debug(b''.join(msg))
return handler
@@ -549,16 +549,16 @@
output = None
if op.captureoutput and op.reply is not None:
op.ui.pushbuffer(error=True, subproc=True)
- output = ''
+ output = b''
try:
handler(op, part)
finally:
if output is not None:
output = op.ui.popbuffer()
if output:
- outpart = op.reply.newpart('output', data=output, mandatory=False)
+ outpart = op.reply.newpart(b'output', data=output, mandatory=False)
outpart.addparam(
- 'in-reply-to', pycompat.bytestr(part.id), mandatory=False
+ b'in-reply-to', pycompat.bytestr(part.id), mandatory=False
)
@@ -575,11 +575,11 @@
for line in blob.splitlines():
if not line:
continue
- if '=' not in line:
+ if b'=' not in line:
key, vals = line, ()
else:
- key, vals = line.split('=', 1)
- vals = vals.split(',')
+ key, vals = line.split(b'=', 1)
+ vals = vals.split(b',')
key = urlreq.unquote(key)
vals = [urlreq.unquote(v) for v in vals]
caps[key] = vals
@@ -594,23 +594,23 @@
ca = urlreq.quote(ca)
vals = [urlreq.quote(v) for v in vals]
if vals:
- ca = "%s=%s" % (ca, ','.join(vals))
+ ca = b"%s=%s" % (ca, b','.join(vals))
chunks.append(ca)
- return '\n'.join(chunks)
+ return b'\n'.join(chunks)
bundletypes = {
- "": ("", 'UN'), # only when using unbundle on ssh and old http servers
+ b"": (b"", b'UN'), # only when using unbundle on ssh and old http servers
# since the unification ssh accepts a header but there
# is no capability signaling it.
- "HG20": (), # special-cased below
- "HG10UN": ("HG10UN", 'UN'),
- "HG10BZ": ("HG10", 'BZ'),
- "HG10GZ": ("HG10GZ", 'GZ'),
+ b"HG20": (), # special-cased below
+ b"HG10UN": (b"HG10UN", b'UN'),
+ b"HG10BZ": (b"HG10", b'BZ'),
+ b"HG10GZ": (b"HG10GZ", b'GZ'),
}
# hgweb uses this list to communicate its preferred type
-bundlepriority = ['HG10GZ', 'HG10BZ', 'HG10UN']
+bundlepriority = [b'HG10GZ', b'HG10BZ', b'HG10UN']
class bundle20(object):
@@ -620,14 +620,14 @@
populate it. Then call `getchunks` to retrieve all the binary chunks of
data that compose the bundle2 container."""
- _magicstring = 'HG20'
+ _magicstring = b'HG20'
def __init__(self, ui, capabilities=()):
self.ui = ui
self._params = []
self._parts = []
self.capabilities = dict(capabilities)
- self._compengine = util.compengines.forbundletype('UN')
+ self._compengine = util.compengines.forbundletype(b'UN')
self._compopts = None
# If compression is being handled by a consumer of the raw
# data (e.g. the wire protocol), unsetting this flag tells
@@ -636,10 +636,10 @@
def setcompression(self, alg, compopts=None):
"""setup core part compression to <alg>"""
- if alg in (None, 'UN'):
+ if alg in (None, b'UN'):
return
- assert not any(n.lower() == 'compression' for n, v in self._params)
- self.addparam('Compression', alg)
+ assert not any(n.lower() == b'compression' for n, v in self._params)
+ self.addparam(b'Compression', alg)
self._compengine = util.compengines.forbundletype(alg)
self._compopts = compopts
@@ -683,15 +683,15 @@
# methods used to generate the bundle2 stream
def getchunks(self):
if self.ui.debugflag:
- msg = ['bundle2-output-bundle: "%s",' % self._magicstring]
+ msg = [b'bundle2-output-bundle: "%s",' % self._magicstring]
if self._params:
- msg.append(' (%i params)' % len(self._params))
- msg.append(' %i parts total\n' % len(self._parts))
- self.ui.debug(''.join(msg))
- outdebug(self.ui, 'start emission of %s stream' % self._magicstring)
+ msg.append(b' (%i params)' % len(self._params))
+ msg.append(b' %i parts total\n' % len(self._parts))
+ self.ui.debug(b''.join(msg))
+ outdebug(self.ui, b'start emission of %s stream' % self._magicstring)
yield self._magicstring
param = self._paramchunk()
- outdebug(self.ui, 'bundle parameter: %s' % param)
+ outdebug(self.ui, b'bundle parameter: %s' % param)
yield _pack(_fstreamparamsize, len(param))
if param:
yield param
@@ -707,20 +707,20 @@
par = urlreq.quote(par)
if value is not None:
value = urlreq.quote(value)
- par = '%s=%s' % (par, value)
+ par = b'%s=%s' % (par, value)
blocks.append(par)
- return ' '.join(blocks)
+ return b' '.join(blocks)
def _getcorechunk(self):
"""yield chunk for the core part of the bundle
(all but headers and parameters)"""
- outdebug(self.ui, 'start of parts')
+ outdebug(self.ui, b'start of parts')
for part in self._parts:
- outdebug(self.ui, 'bundle part: "%s"' % part.type)
+ outdebug(self.ui, b'bundle part: "%s"' % part.type)
for chunk in part.getchunks(ui=self.ui):
yield chunk
- outdebug(self.ui, 'end of bundle')
+ outdebug(self.ui, b'end of bundle')
yield _pack(_fpartheadersize, 0)
def salvageoutput(self):
@@ -730,7 +730,7 @@
server output"""
salvaged = []
for part in self._parts:
- if part.type.startswith('output'):
+ if part.type.startswith(b'output'):
salvaged.append(part.copy())
return salvaged
@@ -768,17 +768,17 @@
if magicstring is None:
magicstring = changegroup.readexactly(fp, 4)
magic, version = magicstring[0:2], magicstring[2:4]
- if magic != 'HG':
+ if magic != b'HG':
ui.debug(
- "error: invalid magic: %r (version %r), should be 'HG'\n"
+ b"error: invalid magic: %r (version %r), should be 'HG'\n"
% (magic, version)
)
- raise error.Abort(_('not a Mercurial bundle'))
+ raise error.Abort(_(b'not a Mercurial bundle'))
unbundlerclass = formatmap.get(version)
if unbundlerclass is None:
- raise error.Abort(_('unknown bundle version %s') % version)
+ raise error.Abort(_(b'unknown bundle version %s') % version)
unbundler = unbundlerclass(ui, fp)
- indebug(ui, 'start processing of %s stream' % magicstring)
+ indebug(ui, b'start processing of %s stream' % magicstring)
return unbundler
@@ -788,24 +788,24 @@
This class is fed with a binary stream and yields parts through its
`iterparts` methods."""
- _magicstring = 'HG20'
+ _magicstring = b'HG20'
def __init__(self, ui, fp):
"""If header is specified, we do not read it out of the stream."""
self.ui = ui
- self._compengine = util.compengines.forbundletype('UN')
+ self._compengine = util.compengines.forbundletype(b'UN')
self._compressed = None
super(unbundle20, self).__init__(fp)
@util.propertycache
def params(self):
"""dictionary of stream level parameters"""
- indebug(self.ui, 'reading bundle2 stream parameters')
+ indebug(self.ui, b'reading bundle2 stream parameters')
params = {}
paramssize = self._unpack(_fstreamparamsize)[0]
if paramssize < 0:
raise error.BundleValueError(
- 'negative bundle param size: %i' % paramssize
+ b'negative bundle param size: %i' % paramssize
)
if paramssize:
params = self._readexact(paramssize)
@@ -815,8 +815,8 @@
def _processallparams(self, paramsblock):
""""""
params = util.sortdict()
- for p in paramsblock.split(' '):
- p = p.split('=', 1)
+ for p in paramsblock.split(b' '):
+ p = p.split(b'=', 1)
p = [urlreq.unquote(i) for i in p]
if len(p) < 2:
p.append(None)
@@ -842,7 +842,7 @@
handler = b2streamparamsmap[name.lower()]
except KeyError:
if name[0:1].islower():
- indebug(self.ui, "ignoring unknown parameter %s" % name)
+ indebug(self.ui, b"ignoring unknown parameter %s" % name)
else:
raise error.BundleUnknownFeatureError(params=(name,))
else:
@@ -857,11 +857,11 @@
needed to move forward to get general delta enabled.
"""
yield self._magicstring
- assert 'params' not in vars(self)
+ assert b'params' not in vars(self)
paramssize = self._unpack(_fstreamparamsize)[0]
if paramssize < 0:
raise error.BundleValueError(
- 'negative bundle param size: %i' % paramssize
+ b'negative bundle param size: %i' % paramssize
)
if paramssize:
params = self._readexact(paramssize)
@@ -869,11 +869,11 @@
# The payload itself is decompressed below, so drop
# the compression parameter passed down to compensate.
outparams = []
- for p in params.split(' '):
- k, v = p.split('=', 1)
- if k.lower() != 'compression':
+ for p in params.split(b' '):
+ k, v = p.split(b'=', 1)
+ if k.lower() != b'compression':
outparams.append(p)
- outparams = ' '.join(outparams)
+ outparams = b' '.join(outparams)
yield _pack(_fstreamparamsize, len(outparams))
yield outparams
else:
@@ -894,7 +894,7 @@
if size == flaginterrupt:
continue
elif size < 0:
- raise error.BundleValueError('negative chunk size: %i')
+ raise error.BundleValueError(b'negative chunk size: %i')
yield self._readexact(size)
def iterparts(self, seekable=False):
@@ -904,7 +904,7 @@
self.params
# From there, payload need to be decompressed
self._fp = self._compengine.decompressorreader(self._fp)
- indebug(self.ui, 'start extraction of bundle2 parts')
+ indebug(self.ui, b'start extraction of bundle2 parts')
headerblock = self._readpartheader()
while headerblock is not None:
part = cls(self.ui, headerblock, self._fp)
@@ -914,7 +914,7 @@
part.consume()
headerblock = self._readpartheader()
- indebug(self.ui, 'end of bundle2 stream')
+ indebug(self.ui, b'end of bundle2 stream')
def _readpartheader(self):
"""reads a part header size and return the bytes blob
@@ -923,9 +923,9 @@
headersize = self._unpack(_fpartheadersize)[0]
if headersize < 0:
raise error.BundleValueError(
- 'negative part header size: %i' % headersize
+ b'negative part header size: %i' % headersize
)
- indebug(self.ui, 'part header size: %i' % headersize)
+ indebug(self.ui, b'part header size: %i' % headersize)
if headersize:
return self._readexact(headersize)
return None
@@ -936,11 +936,11 @@
def close(self):
"""close underlying file"""
- if util.safehasattr(self._fp, 'close'):
+ if util.safehasattr(self._fp, b'close'):
return self._fp.close()
-formatmap = {'20': unbundle20}
+formatmap = {b'20': unbundle20}
b2streamparamsmap = {}
@@ -956,7 +956,7 @@
return decorator
-@b2streamparamhandler('compression')
+@b2streamparamhandler(b'compression')
def processcompression(unbundler, param, value):
"""read compression parameter and install payload decompression"""
if value not in util.compengines.supportedbundletypes:
@@ -987,7 +987,7 @@
parttype,
mandatoryparams=(),
advisoryparams=(),
- data='',
+ data=b'',
mandatory=True,
):
validateparttype(parttype)
@@ -1000,7 +1000,7 @@
self._seenparams = set()
for pname, __ in self._mandatoryparams + self._advisoryparams:
if pname in self._seenparams:
- raise error.ProgrammingError('duplicated params: %s' % pname)
+ raise error.ProgrammingError(b'duplicated params: %s' % pname)
self._seenparams.add(pname)
# status of the part's generation:
# - None: not started,
@@ -1010,8 +1010,8 @@
self.mandatory = mandatory
def __repr__(self):
- cls = "%s.%s" % (self.__class__.__module__, self.__class__.__name__)
- return '<%s object at %x; id: %s; type: %s; mandatory: %s>' % (
+ cls = b"%s.%s" % (self.__class__.__module__, self.__class__.__name__)
+ return b'<%s object at %x; id: %s; type: %s; mandatory: %s>' % (
cls,
id(self),
self.id,
@@ -1024,7 +1024,7 @@
The new part have the very same content but no partid assigned yet.
Parts with generated data cannot be copied."""
- assert not util.safehasattr(self.data, 'next')
+ assert not util.safehasattr(self.data, b'next')
return self.__class__(
self.type,
self._mandatoryparams,
@@ -1041,7 +1041,7 @@
@data.setter
def data(self, data):
if self._generated is not None:
- raise error.ReadOnlyPartError('part is being generated')
+ raise error.ReadOnlyPartError(b'part is being generated')
self._data = data
@property
@@ -1054,7 +1054,7 @@
# make it an immutable tuple to force people through ``addparam``
return tuple(self._advisoryparams)
- def addparam(self, name, value='', mandatory=True):
+ def addparam(self, name, value=b'', mandatory=True):
"""add a parameter to the part
If 'mandatory' is set to True, the remote handler must claim support
@@ -1063,9 +1063,9 @@
The 'name' and 'value' cannot exceed 255 bytes each.
"""
if self._generated is not None:
- raise error.ReadOnlyPartError('part is being generated')
+ raise error.ReadOnlyPartError(b'part is being generated')
if name in self._seenparams:
- raise ValueError('duplicated params: %s' % name)
+ raise ValueError(b'duplicated params: %s' % name)
self._seenparams.add(name)
params = self._advisoryparams
if mandatory:
@@ -1075,39 +1075,39 @@
# methods used to generates the bundle2 stream
def getchunks(self, ui):
if self._generated is not None:
- raise error.ProgrammingError('part can only be consumed once')
+ raise error.ProgrammingError(b'part can only be consumed once')
self._generated = False
if ui.debugflag:
- msg = ['bundle2-output-part: "%s"' % self.type]
+ msg = [b'bundle2-output-part: "%s"' % self.type]
if not self.mandatory:
- msg.append(' (advisory)')
+ msg.append(b' (advisory)')
nbmp = len(self.mandatoryparams)
nbap = len(self.advisoryparams)
if nbmp or nbap:
- msg.append(' (params:')
+ msg.append(b' (params:')
if nbmp:
- msg.append(' %i mandatory' % nbmp)
+ msg.append(b' %i mandatory' % nbmp)
if nbap:
- msg.append(' %i advisory' % nbmp)
- msg.append(')')
+ msg.append(b' %i advisory' % nbmp)
+ msg.append(b')')
if not self.data:
- msg.append(' empty payload')
- elif util.safehasattr(self.data, 'next') or util.safehasattr(
- self.data, '__next__'
+ msg.append(b' empty payload')
+ elif util.safehasattr(self.data, b'next') or util.safehasattr(
+ self.data, b'__next__'
):
- msg.append(' streamed payload')
+ msg.append(b' streamed payload')
else:
- msg.append(' %i bytes payload' % len(self.data))
- msg.append('\n')
- ui.debug(''.join(msg))
+ msg.append(b' %i bytes payload' % len(self.data))
+ msg.append(b'\n')
+ ui.debug(b''.join(msg))
#### header
if self.mandatory:
parttype = self.type.upper()
else:
parttype = self.type.lower()
- outdebug(ui, 'part %s: "%s"' % (pycompat.bytestr(self.id), parttype))
+ outdebug(ui, b'part %s: "%s"' % (pycompat.bytestr(self.id), parttype))
## parttype
header = [
_pack(_fparttypesize, len(parttype)),
@@ -1138,48 +1138,48 @@
header.append(value)
## finalize header
try:
- headerchunk = ''.join(header)
+ headerchunk = b''.join(header)
except TypeError:
raise TypeError(
r'Found a non-bytes trying to '
r'build bundle part header: %r' % header
)
- outdebug(ui, 'header chunk size: %i' % len(headerchunk))
+ outdebug(ui, b'header chunk size: %i' % len(headerchunk))
yield _pack(_fpartheadersize, len(headerchunk))
yield headerchunk
## payload
try:
for chunk in self._payloadchunks():
- outdebug(ui, 'payload chunk size: %i' % len(chunk))
+ outdebug(ui, b'payload chunk size: %i' % len(chunk))
yield _pack(_fpayloadsize, len(chunk))
yield chunk
except GeneratorExit:
# GeneratorExit means that nobody is listening for our
# results anyway, so just bail quickly rather than trying
# to produce an error part.
- ui.debug('bundle2-generatorexit\n')
+ ui.debug(b'bundle2-generatorexit\n')
raise
except BaseException as exc:
bexc = stringutil.forcebytestr(exc)
# backup exception data for later
ui.debug(
- 'bundle2-input-stream-interrupt: encoding exception %s' % bexc
+ b'bundle2-input-stream-interrupt: encoding exception %s' % bexc
)
tb = sys.exc_info()[2]
- msg = 'unexpected error: %s' % bexc
+ msg = b'unexpected error: %s' % bexc
interpart = bundlepart(
- 'error:abort', [('message', msg)], mandatory=False
+ b'error:abort', [(b'message', msg)], mandatory=False
)
interpart.id = 0
yield _pack(_fpayloadsize, -1)
for chunk in interpart.getchunks(ui=ui):
yield chunk
- outdebug(ui, 'closing payload chunk')
+ outdebug(ui, b'closing payload chunk')
# abort current part payload
yield _pack(_fpayloadsize, 0)
pycompat.raisewithtb(exc, tb)
# end of payload
- outdebug(ui, 'closing payload chunk')
+ outdebug(ui, b'closing payload chunk')
yield _pack(_fpayloadsize, 0)
self._generated = True
@@ -1189,8 +1189,8 @@
Exists to handle the different methods to provide data to a part."""
# we only support fixed size data now.
# This will be improved in the future.
- if util.safehasattr(self.data, 'next') or util.safehasattr(
- self.data, '__next__'
+ if util.safehasattr(self.data, b'next') or util.safehasattr(
+ self.data, b'__next__'
):
buff = util.chunkbuffer(self.data)
chunk = buff.read(preferedchunksize)
@@ -1223,9 +1223,9 @@
headersize = self._unpack(_fpartheadersize)[0]
if headersize < 0:
raise error.BundleValueError(
- 'negative part header size: %i' % headersize
+ b'negative part header size: %i' % headersize
)
- indebug(self.ui, 'part header size: %i\n' % headersize)
+ indebug(self.ui, b'part header size: %i\n' % headersize)
if headersize:
return self._readexact(headersize)
return None
@@ -1233,12 +1233,12 @@
def __call__(self):
self.ui.debug(
- 'bundle2-input-stream-interrupt:' ' opening out of band context\n'
+ b'bundle2-input-stream-interrupt:' b' opening out of band context\n'
)
- indebug(self.ui, 'bundle2 stream interruption, looking for a part.')
+ indebug(self.ui, b'bundle2 stream interruption, looking for a part.')
headerblock = self._readpartheader()
if headerblock is None:
- indebug(self.ui, 'no part found during interruption.')
+ indebug(self.ui, b'no part found during interruption.')
return
part = unbundlepart(self.ui, headerblock, self._fp)
op = interruptoperation(self.ui)
@@ -1252,7 +1252,7 @@
if not hardabort:
part.consume()
self.ui.debug(
- 'bundle2-input-stream-interrupt:' ' closing out of band context\n'
+ b'bundle2-input-stream-interrupt:' b' closing out of band context\n'
)
@@ -1269,10 +1269,10 @@
@property
def repo(self):
- raise error.ProgrammingError('no repo access from stream interruption')
+ raise error.ProgrammingError(b'no repo access from stream interruption')
def gettransaction(self):
- raise TransactionUnavailable('no repo access from stream interruption')
+ raise TransactionUnavailable(b'no repo access from stream interruption')
def decodepayloadchunks(ui, fh):
@@ -1281,7 +1281,7 @@
Part payload data consists of framed chunks. This function takes
a file handle and emits those chunks.
"""
- dolog = ui.configbool('devel', 'bundle2.debug')
+ dolog = ui.configbool(b'devel', b'bundle2.debug')
debug = ui.debug
headerstruct = struct.Struct(_fpayloadsize)
@@ -1292,7 +1292,7 @@
read = fh.read
chunksize = unpack(readexactly(fh, headersize))[0]
- indebug(ui, 'payload chunk size: %i' % chunksize)
+ indebug(ui, b'payload chunk size: %i' % chunksize)
# changegroup.readexactly() is inlined below for performance.
while chunksize:
@@ -1301,8 +1301,8 @@
if len(s) < chunksize:
raise error.Abort(
_(
- 'stream ended unexpectedly '
- ' (got %d bytes, expected %d)'
+ b'stream ended unexpectedly '
+ b' (got %d bytes, expected %d)'
)
% (len(s), chunksize)
)
@@ -1314,13 +1314,13 @@
interrupthandler(ui, fh)()
else:
raise error.BundleValueError(
- 'negative payload chunk size: %s' % chunksize
+ b'negative payload chunk size: %s' % chunksize
)
s = read(headersize)
if len(s) < headersize:
raise error.Abort(
- _('stream ended unexpectedly ' ' (got %d bytes, expected %d)')
+ _(b'stream ended unexpectedly ' b' (got %d bytes, expected %d)')
% (len(s), chunksize)
)
@@ -1328,7 +1328,7 @@
# indebug() inlined for performance.
if dolog:
- debug('bundle2-input: payload chunk size: %i\n' % chunksize)
+ debug(b'bundle2-input: payload chunk size: %i\n' % chunksize)
class unbundlepart(unpackermixin):
@@ -1336,8 +1336,8 @@
def __init__(self, ui, header, fp):
super(unbundlepart, self).__init__(fp)
- self._seekable = util.safehasattr(fp, 'seek') and util.safehasattr(
- fp, 'tell'
+ self._seekable = util.safehasattr(fp, b'seek') and util.safehasattr(
+ fp, b'tell'
)
self.ui = ui
# unbundle state attr
@@ -1384,16 +1384,16 @@
"""read the header and setup the object"""
typesize = self._unpackheader(_fparttypesize)[0]
self.type = self._fromheader(typesize)
- indebug(self.ui, 'part type: "%s"' % self.type)
+ indebug(self.ui, b'part type: "%s"' % self.type)
self.id = self._unpackheader(_fpartid)[0]
- indebug(self.ui, 'part id: "%s"' % pycompat.bytestr(self.id))
+ indebug(self.ui, b'part id: "%s"' % pycompat.bytestr(self.id))
# extract mandatory bit from type
self.mandatory = self.type != self.type.lower()
self.type = self.type.lower()
## reading parameters
# param count
mancount, advcount = self._unpackheader(_fpartparamcount)
- indebug(self.ui, 'part parameters: %i' % (mancount + advcount))
+ indebug(self.ui, b'part parameters: %i' % (mancount + advcount))
# param size
fparamsizes = _makefpartparamsizes(mancount + advcount)
paramsizes = self._unpackheader(fparamsizes)
@@ -1445,7 +1445,7 @@
if size is None or len(data) < size:
if not self.consumed and self._pos:
self.ui.debug(
- 'bundle2-input-part: total payload size %i\n' % self._pos
+ b'bundle2-input-part: total payload size %i\n' % self._pos
)
self.consumed = True
return data
@@ -1478,11 +1478,11 @@
def _payloadchunks(self, chunknum=0):
'''seek to specified chunk and start yielding data'''
if len(self._chunkindex) == 0:
- assert chunknum == 0, 'Must start with chunk 0'
+ assert chunknum == 0, b'Must start with chunk 0'
self._chunkindex.append((0, self._tellfp()))
else:
assert chunknum < len(self._chunkindex), (
- 'Unknown chunk %d' % chunknum
+ b'Unknown chunk %d' % chunknum
)
self._seekfp(self._chunkindex[chunknum][1])
@@ -1503,7 +1503,7 @@
return chunk, 0
elif ppos > pos:
return chunk - 1, pos - self._chunkindex[chunk - 1][0]
- raise ValueError('Unknown chunk')
+ raise ValueError(b'Unknown chunk')
def tell(self):
return self._pos
@@ -1521,7 +1521,7 @@
chunk = self.read(32768)
newpos = self._chunkindex[-1][0] - offset
else:
- raise ValueError('Unknown whence value: %r' % (whence,))
+ raise ValueError(b'Unknown whence value: %r' % (whence,))
if newpos > self._chunkindex[-1][0] and not self.consumed:
# Can't use self.consume() here because it advances self._pos.
@@ -1530,14 +1530,14 @@
chunk = self.read(32668)
if not 0 <= newpos <= self._chunkindex[-1][0]:
- raise ValueError('Offset out of range')
+ raise ValueError(b'Offset out of range')
if self._pos != newpos:
chunk, internaloffset = self._findchunk(newpos)
self._payloadstream = util.chunkbuffer(self._payloadchunks(chunk))
adjust = self.read(internaloffset)
if len(adjust) != internaloffset:
- raise error.Abort(_('Seek failed\n'))
+ raise error.Abort(_(b'Seek failed\n'))
self._pos = newpos
def _seekfp(self, offset, whence=0):
@@ -1551,7 +1551,7 @@
if self._seekable:
return self._fp.seek(offset, whence)
else:
- raise NotImplementedError(_('File pointer is not seekable'))
+ raise NotImplementedError(_(b'File pointer is not seekable'))
def _tellfp(self):
"""return the file offset, or None if file is not seekable
@@ -1575,17 +1575,17 @@
# These are only the static capabilities.
# Check the 'getrepocaps' function for the rest.
capabilities = {
- 'HG20': (),
- 'bookmarks': (),
- 'error': ('abort', 'unsupportedcontent', 'pushraced', 'pushkey'),
- 'listkeys': (),
- 'pushkey': (),
- 'digests': tuple(sorted(util.DIGESTS.keys())),
- 'remote-changegroup': ('http', 'https'),
- 'hgtagsfnodes': (),
- 'rev-branch-cache': (),
- 'phases': ('heads',),
- 'stream': ('v2',),
+ b'HG20': (),
+ b'bookmarks': (),
+ b'error': (b'abort', b'unsupportedcontent', b'pushraced', b'pushkey'),
+ b'listkeys': (),
+ b'pushkey': (),
+ b'digests': tuple(sorted(util.DIGESTS.keys())),
+ b'remote-changegroup': (b'http', b'https'),
+ b'hgtagsfnodes': (),
+ b'rev-branch-cache': (),
+ b'phases': (b'heads',),
+ b'stream': (b'v2',),
}
@@ -1598,33 +1598,33 @@
well as clients advertising their capabilities to servers as part of
bundle2 requests. The ``role`` argument specifies which is which.
"""
- if role not in ('client', 'server'):
- raise error.ProgrammingError('role argument must be client or server')
+ if role not in (b'client', b'server'):
+ raise error.ProgrammingError(b'role argument must be client or server')
caps = capabilities.copy()
- caps['changegroup'] = tuple(
+ caps[b'changegroup'] = tuple(
sorted(changegroup.supportedincomingversions(repo))
)
if obsolete.isenabled(repo, obsolete.exchangeopt):
- supportedformat = tuple('V%i' % v for v in obsolete.formats)
- caps['obsmarkers'] = supportedformat
+ supportedformat = tuple(b'V%i' % v for v in obsolete.formats)
+ caps[b'obsmarkers'] = supportedformat
if allowpushback:
- caps['pushback'] = ()
- cpmode = repo.ui.config('server', 'concurrent-push-mode')
- if cpmode == 'check-related':
- caps['checkheads'] = ('related',)
- if 'phases' in repo.ui.configlist('devel', 'legacy.exchange'):
- caps.pop('phases')
+ caps[b'pushback'] = ()
+ cpmode = repo.ui.config(b'server', b'concurrent-push-mode')
+ if cpmode == b'check-related':
+ caps[b'checkheads'] = (b'related',)
+ if b'phases' in repo.ui.configlist(b'devel', b'legacy.exchange'):
+ caps.pop(b'phases')
# Don't advertise stream clone support in server mode if not configured.
- if role == 'server':
+ if role == b'server':
streamsupported = repo.ui.configbool(
- 'server', 'uncompressed', untrusted=True
+ b'server', b'uncompressed', untrusted=True
)
- featuresupported = repo.ui.configbool('server', 'bundle2.stream')
+ featuresupported = repo.ui.configbool(b'server', b'bundle2.stream')
if not streamsupported or not featuresupported:
- caps.pop('stream')
+ caps.pop(b'stream')
# Else always advertise support on client, because payload support
# should always be advertised.
@@ -1633,18 +1633,18 @@
def bundle2caps(remote):
"""return the bundle capabilities of a peer as dict"""
- raw = remote.capable('bundle2')
- if not raw and raw != '':
+ raw = remote.capable(b'bundle2')
+ if not raw and raw != b'':
return {}
- capsblob = urlreq.unquote(remote.capable('bundle2'))
+ capsblob = urlreq.unquote(remote.capable(b'bundle2'))
return decodecaps(capsblob)
def obsmarkersversion(caps):
"""extract the list of supported obsmarkers versions from a bundle2caps dict
"""
- obscaps = caps.get('obsmarkers', ())
- return [int(c[1:]) for c in obscaps if c.startswith('V')]
+ obscaps = caps.get(b'obsmarkers', ())
+ return [int(c[1:]) for c in obscaps if c.startswith(b'V')]
def writenewbundle(
@@ -1659,8 +1659,8 @@
compression=None,
compopts=None,
):
- if bundletype.startswith('HG10'):
- cg = changegroup.makechangegroup(repo, outgoing, '01', source)
+ if bundletype.startswith(b'HG10'):
+ cg = changegroup.makechangegroup(repo, outgoing, b'01', source)
return writebundle(
ui,
cg,
@@ -1670,12 +1670,12 @@
compression=compression,
compopts=compopts,
)
- elif not bundletype.startswith('HG20'):
- raise error.ProgrammingError('unknown bundle type: %s' % bundletype)
+ elif not bundletype.startswith(b'HG20'):
+ raise error.ProgrammingError(b'unknown bundle type: %s' % bundletype)
caps = {}
- if 'obsolescence' in opts:
- caps['obsmarkers'] = ('V1',)
+ if b'obsolescence' in opts:
+ caps[b'obsmarkers'] = (b'V1',)
bundle = bundle20(ui, caps)
bundle.setcompression(compression, compopts)
_addpartsfromopts(ui, repo, bundle, source, outgoing, opts)
@@ -1694,39 +1694,41 @@
# we might not always want a changegroup in such bundle, for example in
# stream bundles
- if opts.get('changegroup', True):
- cgversion = opts.get('cg.version')
+ if opts.get(b'changegroup', True):
+ cgversion = opts.get(b'cg.version')
if cgversion is None:
cgversion = changegroup.safeversion(repo)
cg = changegroup.makechangegroup(repo, outgoing, cgversion, source)
- part = bundler.newpart('changegroup', data=cg.getchunks())
- part.addparam('version', cg.version)
- if 'clcount' in cg.extras:
+ part = bundler.newpart(b'changegroup', data=cg.getchunks())
+ part.addparam(b'version', cg.version)
+ if b'clcount' in cg.extras:
part.addparam(
- 'nbchanges', '%d' % cg.extras['clcount'], mandatory=False
+ b'nbchanges', b'%d' % cg.extras[b'clcount'], mandatory=False
)
- if opts.get('phases') and repo.revs(
- '%ln and secret()', outgoing.missingheads
+ if opts.get(b'phases') and repo.revs(
+ b'%ln and secret()', outgoing.missingheads
):
- part.addparam('targetphase', '%d' % phases.secret, mandatory=False)
-
- if opts.get('streamv2', False):
+ part.addparam(
+ b'targetphase', b'%d' % phases.secret, mandatory=False
+ )
+
+ if opts.get(b'streamv2', False):
addpartbundlestream2(bundler, repo, stream=True)
- if opts.get('tagsfnodescache', True):
+ if opts.get(b'tagsfnodescache', True):
addparttagsfnodescache(repo, bundler, outgoing)
- if opts.get('revbranchcache', True):
+ if opts.get(b'revbranchcache', True):
addpartrevbranchcache(repo, bundler, outgoing)
- if opts.get('obsolescence', False):
+ if opts.get(b'obsolescence', False):
obsmarkers = repo.obsstore.relevantmarkers(outgoing.missing)
buildobsmarkerspart(bundler, obsmarkers)
- if opts.get('phases', False):
+ if opts.get(b'phases', False):
headsbyphase = phases.subsetphaseheads(repo, outgoing.missing)
phasedata = phases.binaryencode(headsbyphase)
- bundler.newpart('phase-heads', data=phasedata)
+ bundler.newpart(b'phase-heads', data=phasedata)
def addparttagsfnodescache(repo, bundler, outgoing):
@@ -1751,7 +1753,7 @@
chunks.extend([node, fnode])
if chunks:
- bundler.newpart('hgtagsfnodes', data=''.join(chunks))
+ bundler.newpart(b'hgtagsfnodes', data=b''.join(chunks))
def addpartrevbranchcache(repo, bundler, outgoing):
@@ -1774,17 +1776,17 @@
for n in sorted(closed):
yield n
- bundler.newpart('cache:rev-branch-cache', data=generate(), mandatory=False)
+ bundler.newpart(b'cache:rev-branch-cache', data=generate(), mandatory=False)
def _formatrequirementsspec(requirements):
- requirements = [req for req in requirements if req != "shared"]
- return urlreq.quote(','.join(sorted(requirements)))
+ requirements = [req for req in requirements if req != b"shared"]
+ return urlreq.quote(b','.join(sorted(requirements)))
def _formatrequirementsparams(requirements):
requirements = _formatrequirementsspec(requirements)
- params = "%s%s" % (urlreq.quote("requirements="), requirements)
+ params = b"%s%s" % (urlreq.quote(b"requirements="), requirements)
return params
@@ -1795,13 +1797,13 @@
if not streamclone.allowservergeneration(repo):
raise error.Abort(
_(
- 'stream data requested but server does not allow '
- 'this feature'
+ b'stream data requested but server does not allow '
+ b'this feature'
),
hint=_(
- 'well-behaved clients should not be '
- 'requesting stream data from servers not '
- 'advertising it; the client may be buggy'
+ b'well-behaved clients should not be '
+ b'requesting stream data from servers not '
+ b'advertising it; the client may be buggy'
),
)
@@ -1815,11 +1817,11 @@
excludepats = kwargs.get(r'excludepats')
narrowstream = repo.ui.configbool(
- 'experimental', 'server.stream-narrow-clones'
+ b'experimental', b'server.stream-narrow-clones'
)
if (includepats or excludepats) and not narrowstream:
- raise error.Abort(_('server does not support narrow stream clones'))
+ raise error.Abort(_(b'server does not support narrow stream clones'))
includeobsmarkers = False
if repo.obsstore:
@@ -1827,8 +1829,8 @@
if not remoteversions:
raise error.Abort(
_(
- 'server has obsolescence markers, but client '
- 'cannot receive them via stream clone'
+ b'server has obsolescence markers, but client '
+ b'cannot receive them via stream clone'
)
)
elif repo.obsstore._version in remoteversions:
@@ -1838,10 +1840,10 @@
repo, includepats, excludepats, includeobsmarkers
)
requirements = _formatrequirementsspec(repo.requirements)
- part = bundler.newpart('stream2', data=it)
- part.addparam('bytecount', '%d' % bytecount, mandatory=True)
- part.addparam('filecount', '%d' % filecount, mandatory=True)
- part.addparam('requirements', requirements, mandatory=True)
+ part = bundler.newpart(b'stream2', data=it)
+ part.addparam(b'bytecount', b'%d' % bytecount, mandatory=True)
+ part.addparam(b'filecount', b'%d' % filecount, mandatory=True)
+ part.addparam(b'requirements', requirements, mandatory=True)
def buildobsmarkerspart(bundler, markers):
@@ -1856,9 +1858,9 @@
remoteversions = obsmarkersversion(bundler.capabilities)
version = obsolete.commonversion(remoteversions)
if version is None:
- raise ValueError('bundler does not support common obsmarker format')
+ raise ValueError(b'bundler does not support common obsmarker format')
stream = obsolete.encodemarkers(markers, True, version=version)
- return bundler.newpart('obsmarkers', data=stream)
+ return bundler.newpart(b'obsmarkers', data=stream)
def writebundle(
@@ -1872,26 +1874,26 @@
The bundle file will be deleted in case of errors.
"""
- if bundletype == "HG20":
+ if bundletype == b"HG20":
bundle = bundle20(ui)
bundle.setcompression(compression, compopts)
- part = bundle.newpart('changegroup', data=cg.getchunks())
- part.addparam('version', cg.version)
- if 'clcount' in cg.extras:
+ part = bundle.newpart(b'changegroup', data=cg.getchunks())
+ part.addparam(b'version', cg.version)
+ if b'clcount' in cg.extras:
part.addparam(
- 'nbchanges', '%d' % cg.extras['clcount'], mandatory=False
+ b'nbchanges', b'%d' % cg.extras[b'clcount'], mandatory=False
)
chunkiter = bundle.getchunks()
else:
# compression argument is only for the bundle2 case
assert compression is None
- if cg.version != '01':
+ if cg.version != b'01':
raise error.Abort(
- _('old bundle types only supports v1 ' 'changegroups')
+ _(b'old bundle types only supports v1 ' b'changegroups')
)
header, comp = bundletypes[bundletype]
if comp not in util.compengines.supportedbundletypes:
- raise error.Abort(_('unknown stream compression type: %s') % comp)
+ raise error.Abort(_(b'unknown stream compression type: %s') % comp)
compengine = util.compengines.forbundletype(comp)
def chunkiter():
@@ -1908,7 +1910,7 @@
def combinechangegroupresults(op):
"""logic to combine 0 or more addchangegroup results into one"""
- results = [r.get('return', 0) for r in op.records['changegroup']]
+ results = [r.get(b'return', 0) for r in op.records[b'changegroup']]
changedheads = 0
result = 1
for ret in results:
@@ -1928,7 +1930,7 @@
@parthandler(
- 'changegroup', ('version', 'nbchanges', 'treemanifest', 'targetphase')
+ b'changegroup', (b'version', b'nbchanges', b'treemanifest', b'targetphase')
)
def handlechangegroup(op, inpart):
"""apply a changegroup part on the repo
@@ -1939,60 +1941,61 @@
from . import localrepo
tr = op.gettransaction()
- unpackerversion = inpart.params.get('version', '01')
+ unpackerversion = inpart.params.get(b'version', b'01')
# We should raise an appropriate exception here
cg = changegroup.getunbundler(unpackerversion, inpart, None)
# the source and url passed here are overwritten by the one contained in
# the transaction.hookargs argument. So 'bundle2' is a placeholder
nbchangesets = None
- if 'nbchanges' in inpart.params:
- nbchangesets = int(inpart.params.get('nbchanges'))
+ if b'nbchanges' in inpart.params:
+ nbchangesets = int(inpart.params.get(b'nbchanges'))
if (
- 'treemanifest' in inpart.params
- and 'treemanifest' not in op.repo.requirements
+ b'treemanifest' in inpart.params
+ and b'treemanifest' not in op.repo.requirements
):
if len(op.repo.changelog) != 0:
raise error.Abort(
_(
- "bundle contains tree manifests, but local repo is "
- "non-empty and does not use tree manifests"
+ b"bundle contains tree manifests, but local repo is "
+ b"non-empty and does not use tree manifests"
)
)
- op.repo.requirements.add('treemanifest')
+ op.repo.requirements.add(b'treemanifest')
op.repo.svfs.options = localrepo.resolvestorevfsoptions(
op.repo.ui, op.repo.requirements, op.repo.features
)
op.repo._writerequirements()
extrakwargs = {}
- targetphase = inpart.params.get('targetphase')
+ targetphase = inpart.params.get(b'targetphase')
if targetphase is not None:
extrakwargs[r'targetphase'] = int(targetphase)
ret = _processchangegroup(
op,
cg,
tr,
- 'bundle2',
- 'bundle2',
+ b'bundle2',
+ b'bundle2',
expectedtotal=nbchangesets,
**extrakwargs
)
if op.reply is not None:
# This is definitely not the final form of this
# return. But one need to start somewhere.
- part = op.reply.newpart('reply:changegroup', mandatory=False)
+ part = op.reply.newpart(b'reply:changegroup', mandatory=False)
part.addparam(
- 'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
+ b'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
)
- part.addparam('return', '%i' % ret, mandatory=False)
+ part.addparam(b'return', b'%i' % ret, mandatory=False)
assert not inpart.read()
_remotechangegroupparams = tuple(
- ['url', 'size', 'digests'] + ['digest:%s' % k for k in util.DIGESTS.keys()]
+ [b'url', b'size', b'digests']
+ + [b'digest:%s' % k for k in util.DIGESTS.keys()]
)
-@parthandler('remote-changegroup', _remotechangegroupparams)
+@parthandler(b'remote-changegroup', _remotechangegroupparams)
def handleremotechangegroup(op, inpart):
"""apply a bundle10 on the repo, given an url and validation information
@@ -2010,32 +2013,35 @@
When multiple digest types are given, all of them are checked.
"""
try:
- raw_url = inpart.params['url']
+ raw_url = inpart.params[b'url']
except KeyError:
- raise error.Abort(_('remote-changegroup: missing "%s" param') % 'url')
+ raise error.Abort(_(b'remote-changegroup: missing "%s" param') % b'url')
parsed_url = util.url(raw_url)
- if parsed_url.scheme not in capabilities['remote-changegroup']:
+ if parsed_url.scheme not in capabilities[b'remote-changegroup']:
raise error.Abort(
- _('remote-changegroup does not support %s urls') % parsed_url.scheme
+ _(b'remote-changegroup does not support %s urls')
+ % parsed_url.scheme
)
try:
- size = int(inpart.params['size'])
+ size = int(inpart.params[b'size'])
except ValueError:
raise error.Abort(
- _('remote-changegroup: invalid value for param "%s"') % 'size'
+ _(b'remote-changegroup: invalid value for param "%s"') % b'size'
)
except KeyError:
- raise error.Abort(_('remote-changegroup: missing "%s" param') % 'size')
+ raise error.Abort(
+ _(b'remote-changegroup: missing "%s" param') % b'size'
+ )
digests = {}
- for typ in inpart.params.get('digests', '').split():
- param = 'digest:%s' % typ
+ for typ in inpart.params.get(b'digests', b'').split():
+ param = b'digest:%s' % typ
try:
value = inpart.params[param]
except KeyError:
raise error.Abort(
- _('remote-changegroup: missing "%s" param') % param
+ _(b'remote-changegroup: missing "%s" param') % param
)
digests[typ] = value
@@ -2047,35 +2053,35 @@
cg = exchange.readbundle(op.repo.ui, real_part, raw_url)
if not isinstance(cg, changegroup.cg1unpacker):
raise error.Abort(
- _('%s: not a bundle version 1.0') % util.hidepassword(raw_url)
+ _(b'%s: not a bundle version 1.0') % util.hidepassword(raw_url)
)
- ret = _processchangegroup(op, cg, tr, 'bundle2', 'bundle2')
+ ret = _processchangegroup(op, cg, tr, b'bundle2', b'bundle2')
if op.reply is not None:
# This is definitely not the final form of this
# return. But one need to start somewhere.
- part = op.reply.newpart('reply:changegroup')
+ part = op.reply.newpart(b'reply:changegroup')
part.addparam(
- 'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
+ b'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
)
- part.addparam('return', '%i' % ret, mandatory=False)
+ part.addparam(b'return', b'%i' % ret, mandatory=False)
try:
real_part.validate()
except error.Abort as e:
raise error.Abort(
- _('bundle at %s is corrupted:\n%s')
+ _(b'bundle at %s is corrupted:\n%s')
% (util.hidepassword(raw_url), bytes(e))
)
assert not inpart.read()
-@parthandler('reply:changegroup', ('return', 'in-reply-to'))
+@parthandler(b'reply:changegroup', (b'return', b'in-reply-to'))
def handlereplychangegroup(op, inpart):
- ret = int(inpart.params['return'])
- replyto = int(inpart.params['in-reply-to'])
- op.records.add('changegroup', {'return': ret}, replyto)
-
-
-@parthandler('check:bookmarks')
+ ret = int(inpart.params[b'return'])
+ replyto = int(inpart.params[b'in-reply-to'])
+ op.records.add(b'changegroup', {b'return': ret}, replyto)
+
+
+@parthandler(b'check:bookmarks')
def handlecheckbookmarks(op, inpart):
"""check location of bookmarks
@@ -2086,16 +2092,16 @@
bookdata = bookmarks.binarydecode(inpart)
msgstandard = (
- 'remote repository changed while pushing - please try again '
- '(bookmark "%s" move from %s to %s)'
+ b'remote repository changed while pushing - please try again '
+ b'(bookmark "%s" move from %s to %s)'
)
msgmissing = (
- 'remote repository changed while pushing - please try again '
- '(bookmark "%s" is missing, expected %s)'
+ b'remote repository changed while pushing - please try again '
+ b'(bookmark "%s" is missing, expected %s)'
)
msgexist = (
- 'remote repository changed while pushing - please try again '
- '(bookmark "%s" set on %s, expected missing)'
+ b'remote repository changed while pushing - please try again '
+ b'(bookmark "%s" set on %s, expected missing)'
)
for book, node in bookdata:
currentnode = op.repo._bookmarks.get(book)
@@ -2113,7 +2119,7 @@
raise error.PushRaced(finalmsg)
-@parthandler('check:heads')
+@parthandler(b'check:heads')
def handlecheckheads(op, inpart):
"""check that head of the repo did not change
@@ -2126,15 +2132,15 @@
h = inpart.read(20)
assert not h
# Trigger a transaction so that we are guaranteed to have the lock now.
- if op.ui.configbool('experimental', 'bundle2lazylocking'):
+ if op.ui.configbool(b'experimental', b'bundle2lazylocking'):
op.gettransaction()
if sorted(heads) != sorted(op.repo.heads()):
raise error.PushRaced(
- 'remote repository changed while pushing - ' 'please try again'
+ b'remote repository changed while pushing - ' b'please try again'
)
-@parthandler('check:updated-heads')
+@parthandler(b'check:updated-heads')
def handlecheckupdatedheads(op, inpart):
"""check for race on the heads touched by a push
@@ -2151,7 +2157,7 @@
h = inpart.read(20)
assert not h
# trigger a transaction so that we are guaranteed to have the lock now.
- if op.ui.configbool('experimental', 'bundle2lazylocking'):
+ if op.ui.configbool(b'experimental', b'bundle2lazylocking'):
op.gettransaction()
currentheads = set()
@@ -2161,11 +2167,12 @@
for h in heads:
if h not in currentheads:
raise error.PushRaced(
- 'remote repository changed while pushing - ' 'please try again'
+ b'remote repository changed while pushing - '
+ b'please try again'
)
-@parthandler('check:phases')
+@parthandler(b'check:phases')
def handlecheckphases(op, inpart):
"""check that phase boundaries of the repository did not change
@@ -2176,8 +2183,8 @@
cl = unfi.changelog
phasecache = unfi._phasecache
msg = (
- 'remote repository changed while pushing - please try again '
- '(%s is %s expected %s)'
+ b'remote repository changed while pushing - please try again '
+ b'(%s is %s expected %s)'
)
for expectedphase, nodes in enumerate(phasetonodes):
for n in nodes:
@@ -2191,14 +2198,14 @@
raise error.PushRaced(finalmsg)
-@parthandler('output')
+@parthandler(b'output')
def handleoutput(op, inpart):
"""forward output captured on the server to the client"""
for line in inpart.read().splitlines():
- op.ui.status(_('remote: %s\n') % line)
-
-
-@parthandler('replycaps')
+ op.ui.status(_(b'remote: %s\n') % line)
+
+
+@parthandler(b'replycaps')
def handlereplycaps(op, inpart):
"""Notify that a reply bundle should be created
@@ -2212,89 +2219,90 @@
"""Sub-class of Abort that denotes an error from a bundle2 part."""
-@parthandler('error:abort', ('message', 'hint'))
+@parthandler(b'error:abort', (b'message', b'hint'))
def handleerrorabort(op, inpart):
"""Used to transmit abort error over the wire"""
raise AbortFromPart(
- inpart.params['message'], hint=inpart.params.get('hint')
+ inpart.params[b'message'], hint=inpart.params.get(b'hint')
)
@parthandler(
- 'error:pushkey', ('namespace', 'key', 'new', 'old', 'ret', 'in-reply-to')
+ b'error:pushkey',
+ (b'namespace', b'key', b'new', b'old', b'ret', b'in-reply-to'),
)
def handleerrorpushkey(op, inpart):
"""Used to transmit failure of a mandatory pushkey over the wire"""
kwargs = {}
- for name in ('namespace', 'key', 'new', 'old', 'ret'):
+ for name in (b'namespace', b'key', b'new', b'old', b'ret'):
value = inpart.params.get(name)
if value is not None:
kwargs[name] = value
raise error.PushkeyFailed(
- inpart.params['in-reply-to'], **pycompat.strkwargs(kwargs)
+ inpart.params[b'in-reply-to'], **pycompat.strkwargs(kwargs)
)
-@parthandler('error:unsupportedcontent', ('parttype', 'params'))
+@parthandler(b'error:unsupportedcontent', (b'parttype', b'params'))
def handleerrorunsupportedcontent(op, inpart):
"""Used to transmit unknown content error over the wire"""
kwargs = {}
- parttype = inpart.params.get('parttype')
+ parttype = inpart.params.get(b'parttype')
if parttype is not None:
- kwargs['parttype'] = parttype
- params = inpart.params.get('params')
+ kwargs[b'parttype'] = parttype
+ params = inpart.params.get(b'params')
if params is not None:
- kwargs['params'] = params.split('\0')
+ kwargs[b'params'] = params.split(b'\0')
raise error.BundleUnknownFeatureError(**pycompat.strkwargs(kwargs))
-@parthandler('error:pushraced', ('message',))
+@parthandler(b'error:pushraced', (b'message',))
def handleerrorpushraced(op, inpart):
"""Used to transmit push race error over the wire"""
- raise error.ResponseError(_('push failed:'), inpart.params['message'])
-
-
-@parthandler('listkeys', ('namespace',))
+ raise error.ResponseError(_(b'push failed:'), inpart.params[b'message'])
+
+
+@parthandler(b'listkeys', (b'namespace',))
def handlelistkeys(op, inpart):
"""retrieve pushkey namespace content stored in a bundle2"""
- namespace = inpart.params['namespace']
+ namespace = inpart.params[b'namespace']
r = pushkey.decodekeys(inpart.read())
- op.records.add('listkeys', (namespace, r))
-
-
-@parthandler('pushkey', ('namespace', 'key', 'old', 'new'))
+ op.records.add(b'listkeys', (namespace, r))
+
+
+@parthandler(b'pushkey', (b'namespace', b'key', b'old', b'new'))
def handlepushkey(op, inpart):
"""process a pushkey request"""
dec = pushkey.decode
- namespace = dec(inpart.params['namespace'])
- key = dec(inpart.params['key'])
- old = dec(inpart.params['old'])
- new = dec(inpart.params['new'])
+ namespace = dec(inpart.params[b'namespace'])
+ key = dec(inpart.params[b'key'])
+ old = dec(inpart.params[b'old'])
+ new = dec(inpart.params[b'new'])
# Grab the transaction to ensure that we have the lock before performing the
# pushkey.
- if op.ui.configbool('experimental', 'bundle2lazylocking'):
+ if op.ui.configbool(b'experimental', b'bundle2lazylocking'):
op.gettransaction()
ret = op.repo.pushkey(namespace, key, old, new)
- record = {'namespace': namespace, 'key': key, 'old': old, 'new': new}
- op.records.add('pushkey', record)
+ record = {b'namespace': namespace, b'key': key, b'old': old, b'new': new}
+ op.records.add(b'pushkey', record)
if op.reply is not None:
- rpart = op.reply.newpart('reply:pushkey')
+ rpart = op.reply.newpart(b'reply:pushkey')
rpart.addparam(
- 'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
+ b'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
)
- rpart.addparam('return', '%i' % ret, mandatory=False)
+ rpart.addparam(b'return', b'%i' % ret, mandatory=False)
if inpart.mandatory and not ret:
kwargs = {}
- for key in ('namespace', 'key', 'new', 'old', 'ret'):
+ for key in (b'namespace', b'key', b'new', b'old', b'ret'):
if key in inpart.params:
kwargs[key] = inpart.params[key]
raise error.PushkeyFailed(
- partid='%d' % inpart.id, **pycompat.strkwargs(kwargs)
+ partid=b'%d' % inpart.id, **pycompat.strkwargs(kwargs)
)
-@parthandler('bookmarks')
+@parthandler(b'bookmarks')
def handlebookmark(op, inpart):
"""transmit bookmark information
@@ -2313,26 +2321,30 @@
"""
changes = bookmarks.binarydecode(inpart)
- pushkeycompat = op.repo.ui.configbool('server', 'bookmarks-pushkey-compat')
- bookmarksmode = op.modes.get('bookmarks', 'apply')
-
- if bookmarksmode == 'apply':
+ pushkeycompat = op.repo.ui.configbool(
+ b'server', b'bookmarks-pushkey-compat'
+ )
+ bookmarksmode = op.modes.get(b'bookmarks', b'apply')
+
+ if bookmarksmode == b'apply':
tr = op.gettransaction()
bookstore = op.repo._bookmarks
if pushkeycompat:
allhooks = []
for book, node in changes:
hookargs = tr.hookargs.copy()
- hookargs['pushkeycompat'] = '1'
- hookargs['namespace'] = 'bookmarks'
- hookargs['key'] = book
- hookargs['old'] = nodemod.hex(bookstore.get(book, ''))
- hookargs['new'] = nodemod.hex(node if node is not None else '')
+ hookargs[b'pushkeycompat'] = b'1'
+ hookargs[b'namespace'] = b'bookmarks'
+ hookargs[b'key'] = book
+ hookargs[b'old'] = nodemod.hex(bookstore.get(book, b''))
+ hookargs[b'new'] = nodemod.hex(
+ node if node is not None else b''
+ )
allhooks.append(hookargs)
for hookargs in allhooks:
op.repo.hook(
- 'prepushkey', throw=True, **pycompat.strkwargs(hookargs)
+ b'prepushkey', throw=True, **pycompat.strkwargs(hookargs)
)
bookstore.applychanges(op.repo, op.gettransaction(), changes)
@@ -2341,72 +2353,78 @@
def runhook():
for hookargs in allhooks:
- op.repo.hook('pushkey', **pycompat.strkwargs(hookargs))
+ op.repo.hook(b'pushkey', **pycompat.strkwargs(hookargs))
op.repo._afterlock(runhook)
- elif bookmarksmode == 'records':
+ elif bookmarksmode == b'records':
for book, node in changes:
- record = {'bookmark': book, 'node': node}
- op.records.add('bookmarks', record)
+ record = {b'bookmark': book, b'node': node}
+ op.records.add(b'bookmarks', record)
else:
- raise error.ProgrammingError('unkown bookmark mode: %s' % bookmarksmode)
-
-
-@parthandler('phase-heads')
+ raise error.ProgrammingError(
+ b'unkown bookmark mode: %s' % bookmarksmode
+ )
+
+
+@parthandler(b'phase-heads')
def handlephases(op, inpart):
"""apply phases from bundle part to repo"""
headsbyphase = phases.binarydecode(inpart)
phases.updatephases(op.repo.unfiltered(), op.gettransaction, headsbyphase)
-@parthandler('reply:pushkey', ('return', 'in-reply-to'))
+@parthandler(b'reply:pushkey', (b'return', b'in-reply-to'))
def handlepushkeyreply(op, inpart):
"""retrieve the result of a pushkey request"""
- ret = int(inpart.params['return'])
- partid = int(inpart.params['in-reply-to'])
- op.records.add('pushkey', {'return': ret}, partid)
-
-
-@parthandler('obsmarkers')
+ ret = int(inpart.params[b'return'])
+ partid = int(inpart.params[b'in-reply-to'])
+ op.records.add(b'pushkey', {b'return': ret}, partid)
+
+
+@parthandler(b'obsmarkers')
def handleobsmarker(op, inpart):
"""add a stream of obsmarkers to the repo"""
tr = op.gettransaction()
markerdata = inpart.read()
- if op.ui.config('experimental', 'obsmarkers-exchange-debug'):
- op.ui.write('obsmarker-exchange: %i bytes received\n' % len(markerdata))
+ if op.ui.config(b'experimental', b'obsmarkers-exchange-debug'):
+ op.ui.write(
+ b'obsmarker-exchange: %i bytes received\n' % len(markerdata)
+ )
# The mergemarkers call will crash if marker creation is not enabled.
# we want to avoid this if the part is advisory.
if not inpart.mandatory and op.repo.obsstore.readonly:
- op.repo.ui.debug('ignoring obsolescence markers, feature not enabled\n')
+ op.repo.ui.debug(
+ b'ignoring obsolescence markers, feature not enabled\n'
+ )
return
new = op.repo.obsstore.mergemarkers(tr, markerdata)
op.repo.invalidatevolatilesets()
- op.records.add('obsmarkers', {'new': new})
+ op.records.add(b'obsmarkers', {b'new': new})
if op.reply is not None:
- rpart = op.reply.newpart('reply:obsmarkers')
+ rpart = op.reply.newpart(b'reply:obsmarkers')
rpart.addparam(
- 'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
+ b'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
)
- rpart.addparam('new', '%i' % new, mandatory=False)
-
-
-@parthandler('reply:obsmarkers', ('new', 'in-reply-to'))
+ rpart.addparam(b'new', b'%i' % new, mandatory=False)
+
+
+@parthandler(b'reply:obsmarkers', (b'new', b'in-reply-to'))
def handleobsmarkerreply(op, inpart):
"""retrieve the result of a pushkey request"""
- ret = int(inpart.params['new'])
- partid = int(inpart.params['in-reply-to'])
- op.records.add('obsmarkers', {'new': ret}, partid)
-
-
-@parthandler('hgtagsfnodes')
+ ret = int(inpart.params[b'new'])
+ partid = int(inpart.params[b'in-reply-to'])
+ op.records.add(b'obsmarkers', {b'new': ret}, partid)
+
+
+@parthandler(b'hgtagsfnodes')
def handlehgtagsfnodes(op, inpart):
"""Applies .hgtags fnodes cache entries to the local repo.
Payload is pairs of 20 byte changeset nodes and filenodes.
"""
# Grab the transaction so we ensure that we have the lock at this point.
- if op.ui.configbool('experimental', 'bundle2lazylocking'):
+ if op.ui.configbool(b'experimental', b'bundle2lazylocking'):
op.gettransaction()
cache = tags.hgtagsfnodescache(op.repo.unfiltered())
@@ -2415,19 +2433,19 @@
node = inpart.read(20)
fnode = inpart.read(20)
if len(node) < 20 or len(fnode) < 20:
- op.ui.debug('ignoring incomplete received .hgtags fnodes data\n')
+ op.ui.debug(b'ignoring incomplete received .hgtags fnodes data\n')
break
cache.setfnode(node, fnode)
count += 1
cache.write()
- op.ui.debug('applied %i hgtags fnodes cache entries\n' % count)
-
-
-rbcstruct = struct.Struct('>III')
-
-
-@parthandler('cache:rev-branch-cache')
+ op.ui.debug(b'applied %i hgtags fnodes cache entries\n' % count)
+
+
+rbcstruct = struct.Struct(b'>III')
+
+
+@parthandler(b'cache:rev-branch-cache')
def handlerbc(op, inpart):
"""receive a rev-branch-cache payload and update the local cache
@@ -2460,34 +2478,34 @@
cache.write()
-@parthandler('pushvars')
+@parthandler(b'pushvars')
def bundle2getvars(op, part):
'''unbundle a bundle2 containing shellvars on the server'''
# An option to disable unbundling on server-side for security reasons
- if op.ui.configbool('push', 'pushvars.server'):
+ if op.ui.configbool(b'push', b'pushvars.server'):
hookargs = {}
for key, value in part.advisoryparams:
key = key.upper()
# We want pushed variables to have USERVAR_ prepended so we know
# they came from the --pushvar flag.
- key = "USERVAR_" + key
+ key = b"USERVAR_" + key
hookargs[key] = value
op.addhookargs(hookargs)
-@parthandler('stream2', ('requirements', 'filecount', 'bytecount'))
+@parthandler(b'stream2', (b'requirements', b'filecount', b'bytecount'))
def handlestreamv2bundle(op, part):
- requirements = urlreq.unquote(part.params['requirements']).split(',')
- filecount = int(part.params['filecount'])
- bytecount = int(part.params['bytecount'])
+ requirements = urlreq.unquote(part.params[b'requirements']).split(b',')
+ filecount = int(part.params[b'filecount'])
+ bytecount = int(part.params[b'bytecount'])
repo = op.repo
if len(repo):
- msg = _('cannot apply stream clone to non empty repository')
+ msg = _(b'cannot apply stream clone to non empty repository')
raise error.Abort(msg)
- repo.ui.debug('applying stream bundle\n')
+ repo.ui.debug(b'applying stream bundle\n')
streamclone.applybundlev2(repo, part, filecount, bytecount, requirements)
@@ -2509,7 +2527,7 @@
"""
commonnodes = set()
cl = repo.changelog
- for r in repo.revs("::%ln", common):
+ for r in repo.revs(b"::%ln", common):
commonnodes.add(cl.node(r))
if commonnodes:
# XXX: we should only send the filelogs (and treemanifest). user
@@ -2525,13 +2543,13 @@
{nodemod.nullid},
list(commonnodes),
False,
- 'narrow_widen',
+ b'narrow_widen',
changelog=False,
)
- part = bundler.newpart('changegroup', data=cgdata)
- part.addparam('version', cgversion)
- if 'treemanifest' in repo.requirements:
- part.addparam('treemanifest', '1')
+ part = bundler.newpart(b'changegroup', data=cgdata)
+ part.addparam(b'version', cgversion)
+ if b'treemanifest' in repo.requirements:
+ part.addparam(b'treemanifest', b'1')
return bundler