mercurial: comparison mercurial/wireprototypes.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 )
 from .interfaces import util as interfaceutil
 from .utils import compression
 # Names of the SSH protocol implementations.
-SSHV1 = 'ssh-v1'
+SSHV1 = b'ssh-v1'
 # These are advertised over the wire. Increment the counters at the end
 # to reflect BC breakages.
-SSHV2 = 'exp-ssh-v2-0003'
+SSHV2 = b'exp-ssh-v2-0003'
-HTTP_WIREPROTO_V2 = 'exp-http-v2-0003'
+HTTP_WIREPROTO_V2 = b'exp-http-v2-0003'
-NARROWCAP = 'exp-narrow-1'
+NARROWCAP = b'exp-narrow-1'
-ELLIPSESCAP1 = 'exp-ellipses-1'
+ELLIPSESCAP1 = b'exp-ellipses-1'
-ELLIPSESCAP = 'exp-ellipses-2'
+ELLIPSESCAP = b'exp-ellipses-2'
 SUPPORTED_ELLIPSESCAP = (ELLIPSESCAP1, ELLIPSESCAP)
 # All available wire protocol transports.
 TRANSPORTS = {
-SSHV1: {'transport': 'ssh', 'version': 1,},
+SSHV1: {b'transport': b'ssh', b'version': 1,},
 SSHV2: {
-'transport': 'ssh',
+b'transport': b'ssh',
 # TODO mark as version 2 once all commands are implemented.
-'version': 1,
+b'version': 1,
 },
-'http-v1': {'transport': 'http', 'version': 1,},
+b'http-v1': {b'transport': b'http', b'version': 1,},
-HTTP_WIREPROTO_V2: {'transport': 'http', 'version': 2,},
+HTTP_WIREPROTO_V2: {b'transport': b'http', b'version': 2,},
 }
 class bytesresponse(object):
 """A wire protocol response consisting of raw bytes."""
 def __init__(self, gen=None):
 self.gen = gen
 # list of nodes encoding / decoding
-def decodelist(l, sep=' '):
+def decodelist(l, sep=b' '):
 if l:
 return [bin(v) for v in l.split(sep)]
 return []
-def encodelist(l, sep=' '):
+def encodelist(l, sep=b' '):
 try:
 return sep.join(map(hex, l))
 except TypeError:
 raise
 # batched call argument encoding
 def escapebatcharg(plain):
 return (
-plain.replace(':', ':c')
+plain.replace(b':', b':c')
-.replace(',', ':o')
+.replace(b',', b':o')
-.replace(';', ':s')
+.replace(b';', b':s')
-.replace('=', ':e')
+.replace(b'=', b':e')
 )
 def unescapebatcharg(escaped):
 return (
-escaped.replace(':e', '=')
+escaped.replace(b':e', b'=')
-.replace(':s', ';')
+.replace(b':s', b';')
-.replace(':o', ',')
+.replace(b':o', b',')
-.replace(':c', ':')
+.replace(b':c', b':')
 )
 # mapping of options accepted by getbundle and their types
 #
 # :nodes: list of binary nodes, transmitted as space-separated hex nodes
 # :csv:   list of values, transmitted as comma-separated values
 # :scsv:  set of values, transmitted as comma-separated values
 # :plain: string with no transformation needed.
 GETBUNDLE_ARGUMENTS = {
-'heads': 'nodes',
+b'heads': b'nodes',
-'bookmarks': 'boolean',
+b'bookmarks': b'boolean',
-'common': 'nodes',
+b'common': b'nodes',
-'obsmarkers': 'boolean',
+b'obsmarkers': b'boolean',
-'phases': 'boolean',
+b'phases': b'boolean',
-'bundlecaps': 'scsv',
+b'bundlecaps': b'scsv',
-'listkeys': 'csv',
+b'listkeys': b'csv',
-'cg': 'boolean',
+b'cg': b'boolean',
-'cbattempted': 'boolean',
+b'cbattempted': b'boolean',
-'stream': 'boolean',
+b'stream': b'boolean',
-'includepats': 'csv',
+b'includepats': b'csv',
-'excludepats': 'csv',
+b'excludepats': b'csv',
 }
 class baseprotocolhandler(interfaceutil.Interface):
 """Abstract base class for wire protocol handlers.
 """Represents a declared wire protocol command."""
 def __init__(
 self,
 func,
-args='',
+args=b'',
 transports=None,
-permission='push',
+permission=b'push',
 cachekeyfn=None,
 extracapabilitiesfn=None,
 ):
 self.func = func
 self.args = args
 if i == 0:
 return self.func
 elif i == 1:
 return self.args
 else:
-raise IndexError('can only access elements 0 and 1')
+raise IndexError(b'can only access elements 0 and 1')
 class commanddict(dict):
 """Container for registered wire protocol commands.
 if isinstance(v, commandentry):
 pass
 # Cast 2-tuples to commandentry instances.
 elif isinstance(v, tuple):
 if len(v) != 2:
-raise ValueError('command tuples must have exactly 2 elements')
+raise ValueError(b'command tuples must have exactly 2 elements')
 # It is common for extensions to wrap wire protocol commands via
 # e.g. ``wireproto.commands[x] = (newfn, args)``. Because callers
 # doing this aren't aware of the new API that uses objects to store
 # command entries, we automatically merge old state with new.
 # Use default values from @wireprotocommand.
 v = commandentry(
 v[0],
 args=v[1],
 transports=set(TRANSPORTS),
-permission='push',
+permission=b'push',
 )
 else:
 raise ValueError(
-'command entries must be commandentry instances ' 'or 2-tuples'
+b'command entries must be commandentry instances '
+b'or 2-tuples'
 )
 return super(commanddict, self).__setitem__(k, v)
 def commandavailable(self, command, proto):
 compengines = compression.compengines.supportedwireengines(role)
 # Allow config to override default list and ordering.
 if role == compression.SERVERROLE:
-configengines = ui.configlist('server', 'compressionengines')
+configengines = ui.configlist(b'server', b'compressionengines')
-config = 'server.compressionengines'
+config = b'server.compressionengines'
 else:
 # This is currently implemented mainly to facilitate testing. In most
 # cases, the server should be in charge of choosing a compression engine
 # because a server has the most to lose from a sub-optimal choice. (e.g.
 # CPU DoS due to an expensive engine or a network DoS due to poor
 # compression ratio).
 configengines = ui.configlist(
-'experimental', 'clientcompressionengines'
+b'experimental', b'clientcompressionengines'
 )
-config = 'experimental.clientcompressionengines'
+config = b'experimental.clientcompressionengines'
 # No explicit config. Filter out the ones that aren't supposed to be
 # advertised and return default ordering.
 if not configengines:
-attr = 'serverpriority' if role == util.SERVERROLE else 'clientpriority'
+attr = (
+b'serverpriority' if role == util.SERVERROLE else b'clientpriority'
+)
 return [
 e for e in compengines if getattr(e.wireprotosupport(), attr) > 0
 ]
 # If compression engines are listed in the config, assume there is a good
 # unusable compression engines.
 validnames = set(e.name() for e in compengines)
 invalidnames = set(e for e in configengines if e not in validnames)
 if invalidnames:
 raise error.Abort(
-_('invalid compression engine defined in %s: %s')
+_(b'invalid compression engine defined in %s: %s')
-% (config, ', '.join(sorted(invalidnames)))
+% (config, b', '.join(sorted(invalidnames)))
 )
 compengines = [e for e in compengines if e.name() in configengines]
 compengines = sorted(
 compengines, key=lambda e: configengines.index(e.name())
 )
 if not compengines:
 raise error.Abort(
 _(
-'%s config option does not specify any known '
+b'%s config option does not specify any known '
-'compression engines'
+b'compression engines'
 )
 % config,
-hint=_('usable compression engines: %s') % ', '.sorted(validnames),
+hint=_(b'usable compression engines: %s')
+% b', '.sorted(validnames),
 )
 return compengines

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43089	c59eb1560c44