mercurial: comparison mercurial/chgserver.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 return node.hex(hashlib.sha1(stringutil.pprint(items)).digest())
 # sensitive config sections affecting confighash
 _configsections = [
-'alias',  # affects global state commands.table
+b'alias',  # affects global state commands.table
-'eol',  # uses setconfig('eol', ...)
+b'eol',  # uses setconfig('eol', ...)
-'extdiff',  # uisetup will register new commands
+b'extdiff',  # uisetup will register new commands
-'extensions',
+b'extensions',
 ]
 _configsectionitems = [
-('commands', 'show.aliasprefix'),  # show.py reads it in extsetup
+(b'commands', b'show.aliasprefix'),  # show.py reads it in extsetup
 ]
 # sensitive environment variables affecting confighash
 _envre = re.compile(
 br'''\A(?:
 sectionitems.append(ui.configitems(section))
 for section, item in _configsectionitems:
 sectionitems.append(ui.config(section, item))
 sectionhash = _hashlist(sectionitems)
 # If $CHGHG is set, the change to $HG should not trigger a new chg server
-if 'CHGHG' in encoding.environ:
+if b'CHGHG' in encoding.environ:
-ignored = {'HG'}
+ignored = {b'HG'}
 else:
 ignored = set()
 envitems = [
 (k, v)
 for k, v in encoding.environ.iteritems()
 if mtimepaths is None:
 mtimepaths = _getmtimepaths(ui)
 confighash = _confighash(ui)
 mtimehash = _mtimehash(mtimepaths)
 ui.log(
-'cmdserver',
+b'cmdserver',
-'confighash = %s mtimehash = %s\n',
+b'confighash = %s mtimehash = %s\n',
 confighash,
 mtimehash,
 )
 return hashstate(confighash, mtimehash, mtimepaths)
 #  b. or stdout is redirected by protectfinout(),
 # because the chg client is not aware of these situations and
 # will behave differently (i.e. write to stdout).
 if (
 out is not self.fout
-or not util.safehasattr(self.fout, 'fileno')
+or not util.safehasattr(self.fout, b'fileno')
 or self.fout.fileno() != procutil.stdout.fileno()
 or self._finoutredirected
 ):
 return procutil.system(cmd, environ=environ, cwd=cwd, out=out)
 self.flush()
 def _runpager(self, cmd, env=None):
 self._csystem(
 cmd,
 procutil.shellenviron(env),
-type='pager',
+type=b'pager',
-cmdtable={'attachio': attachio},
+cmdtable={b'attachio': attachio},
 )
 return True
 return chgui(srcui)
 def _loadnewui(srcui, args, cdebug):
 from . import dispatch  # avoid cycle
 newui = srcui.__class__.load()
-for a in ['fin', 'fout', 'ferr', 'environ']:
+for a in [b'fin', b'fout', b'ferr', b'environ']:
 setattr(newui, a, getattr(srcui, a))
-if util.safehasattr(srcui, '_csystem'):
+if util.safehasattr(srcui, b'_csystem'):
 newui._csystem = srcui._csystem
 # command line args
 options = dispatch._earlyparseopts(newui, args)
-dispatch._parseconfig(newui, options['config'])
+dispatch._parseconfig(newui, options[b'config'])
 # stolen from tortoisehg.util.copydynamicconfig()
 for section, name, value in srcui.walkconfig():
 source = srcui.configsource(section, name)
-if ':' in source or source == '--config' or source.startswith('$'):
+if b':' in source or source == b'--config' or source.startswith(b'$'):
 # path:line or command line, or environ
 continue
 newui.setconfig(section, name, value, source)
 # load wd and repo config, copied from dispatch.py
-cwd = options['cwd']
+cwd = options[b'cwd']
 cwd = cwd and os.path.realpath(cwd) or None
-rpath = options['repository']
+rpath = options[b'repository']
 path, newlui = dispatch._getlocal(newui, rpath, wd=cwd)
 extensions.populateui(newui)
 commandserver.setuplogging(newui, fp=cdebug)
 if newui is not newlui:
 def __init__(self, in_, out, channel):
 self.in_ = in_
 self.out = out
 self.channel = channel
-def __call__(self, cmd, environ, cwd=None, type='system', cmdtable=None):
+def __call__(self, cmd, environ, cwd=None, type=b'system', cmdtable=None):
-args = [type, procutil.quotecommand(cmd), os.path.abspath(cwd or '.')]
+args = [type, procutil.quotecommand(cmd), os.path.abspath(cwd or b'.')]
-args.extend('%s=%s' % (k, v) for k, v in environ.iteritems())
+args.extend(b'%s=%s' % (k, v) for k, v in environ.iteritems())
-data = '\0'.join(args)
+data = b'\0'.join(args)
-self.out.write(struct.pack('>cI', self.channel, len(data)))
+self.out.write(struct.pack(b'>cI', self.channel, len(data)))
 self.out.write(data)
 self.out.flush()
-if type == 'system':
+if type == b'system':
 length = self.in_.read(4)
-(length,) = struct.unpack('>I', length)
+(length,) = struct.unpack(b'>I', length)
 if length != 4:
-raise error.Abort(_('invalid response'))
+raise error.Abort(_(b'invalid response'))
-(rc,) = struct.unpack('>i', self.in_.read(4))
+(rc,) = struct.unpack(b'>i', self.in_.read(4))
 return rc
-elif type == 'pager':
+elif type == b'pager':
 while True:
 cmd = self.in_.readline()[:-1]
 if not cmd:
 break
 if cmdtable and cmd in cmdtable:
 cmdtable[cmd]()
 else:
-raise error.Abort(_('unexpected command: %s') % cmd)
+raise error.Abort(_(b'unexpected command: %s') % cmd)
 else:
-raise error.ProgrammingError('invalid S channel type: %s' % type)
+raise error.ProgrammingError(b'invalid S channel type: %s' % type)
 _iochannels = [
 # server.ch, ui.fp, mode
-('cin', 'fin', r'rb'),
+(b'cin', b'fin', r'rb'),
-('cout', 'fout', r'wb'),
+(b'cout', b'fout', r'wb'),
-('cerr', 'ferr', r'wb'),
+(b'cerr', b'ferr', r'wb'),
 ]
 class chgcmdserver(commandserver.server):
 def __init__(
 self, ui, repo, fin, fout, sock, prereposetups, hashstate, baseaddress
 ):
 super(chgcmdserver, self).__init__(
-_newchgui(ui, channeledsystem(fin, fout, 'S'), self.attachio),
+_newchgui(ui, channeledsystem(fin, fout, b'S'), self.attachio),
 repo,
 fin,
 fout,
 prereposetups,
 )
 self._oldios = []  # original (self.ch, ui.fp, fd) before "attachio"
 self.hashstate = hashstate
 self.baseaddress = baseaddress
 if hashstate is not None:
 self.capabilities = self.capabilities.copy()
-self.capabilities['validate'] = chgcmdserver.validate
+self.capabilities[b'validate'] = chgcmdserver.validate
 def cleanup(self):
 super(chgcmdserver, self).cleanup()
 # dispatch._runcatch() does not flush outputs if exception is not
 # handled by dispatch._dispatch()
 """Attach to client's stdio passed via unix domain socket; all
 channels except cresult will no longer be used
 """
 # tell client to sendmsg() with 1-byte payload, which makes it
 # distinctive from "attachio\n" command consumed by client.read()
-self.clientsock.sendall(struct.pack('>cI', 'I', 1))
+self.clientsock.sendall(struct.pack(b'>cI', b'I', 1))
 clientfds = util.recvfds(self.clientsock.fileno())
-self.ui.log('chgserver', 'received fds: %r\n', clientfds)
+self.ui.log(b'chgserver', b'received fds: %r\n', clientfds)
 ui = self.ui
 ui.flush()
 self._saveio()
 for fd, (cn, fn, mode) in zip(clientfds, _iochannels):
 continue
 # reset buffering mode when client is first attached. as we want
 # to see output immediately on pager, the mode stays unchanged
 # when client re-attached. ferr is unchanged because it should
 # be unbuffered no matter if it is a tty or not.
-if fn == 'ferr':
+if fn == b'ferr':
 newfp = fp
 else:
 # make it line buffered explicitly because the default is
 # decided on first write(), where fout could be a pager.
 if fp.isatty():
 newfp = os.fdopen(fp.fileno(), mode, bufsize)
 setattr(ui, fn, newfp)
 setattr(self, cn, newfp)
 self._ioattached = True
-self.cresult.write(struct.pack('>i', len(clientfds)))
+self.cresult.write(struct.pack(b'>i', len(clientfds)))
 def _saveio(self):
 if self._oldios:
 return
 ui = self.ui
 try:
 self.ui, lui = _loadnewui(self.ui, args, self.cdebug)
 except error.ParseError as inst:
 dispatch._formatparse(self.ui.warn, inst)
 self.ui.flush()
-self.cresult.write('exit 255')
+self.cresult.write(b'exit 255')
 return
 except error.Abort as inst:
-self.ui.error(_("abort: %s\n") % inst)
+self.ui.error(_(b"abort: %s\n") % inst)
 if inst.hint:
-self.ui.error(_("(%s)\n") % inst.hint)
+self.ui.error(_(b"(%s)\n") % inst.hint)
 self.ui.flush()
-self.cresult.write('exit 255')
+self.cresult.write(b'exit 255')
 return
 newhash = hashstate.fromui(lui, self.hashstate.mtimepaths)
 insts = []
 if newhash.mtimehash != self.hashstate.mtimehash:
 addr = _hashaddress(self.baseaddress, self.hashstate.confighash)
-insts.append('unlink %s' % addr)
+insts.append(b'unlink %s' % addr)
 # mtimehash is empty if one or more extensions fail to load.
 # to be compatible with hg, still serve the client this time.
 if self.hashstate.mtimehash:
-insts.append('reconnect')
+insts.append(b'reconnect')
 if newhash.confighash != self.hashstate.confighash:
 addr = _hashaddress(self.baseaddress, newhash.confighash)
-insts.append('redirect %s' % addr)
+insts.append(b'redirect %s' % addr)
-self.ui.log('chgserver', 'validate: %s\n', stringutil.pprint(insts))
+self.ui.log(b'chgserver', b'validate: %s\n', stringutil.pprint(insts))
-self.cresult.write('\0'.join(insts) or '\0')
+self.cresult.write(b'\0'.join(insts) or b'\0')
 def chdir(self):
 """Change current directory
 Note that the behavior of --cwd option is bit different from this.
 It does not affect --config parameter.
 """
 path = self._readstr()
 if not path:
 return
-self.ui.log('chgserver', 'chdir to %r\n', path)
+self.ui.log(b'chgserver', b'chdir to %r\n', path)
 os.chdir(path)
 def setumask(self):
 """Change umask (DEPRECATED)"""
 # BUG: this does not follow the message frame structure, but kept for
 def setumask2(self):
 """Change umask"""
 data = self._readstr()
 if len(data) != 4:
-raise ValueError('invalid mask length in setumask2 request')
+raise ValueError(b'invalid mask length in setumask2 request')
 self._setumask(data)
 def _setumask(self, data):
-mask = struct.unpack('>I', data)[0]
+mask = struct.unpack(b'>I', data)[0]
-self.ui.log('chgserver', 'setumask %r\n', mask)
+self.ui.log(b'chgserver', b'setumask %r\n', mask)
 os.umask(mask)
 def runcommand(self):
 # pager may be attached within the runcommand session, which should
 # be detached at the end of the session. otherwise the pager wouldn't
 Note that not all variables can make an effect on the running process.
 """
 l = self._readlist()
 try:
-newenv = dict(s.split('=', 1) for s in l)
+newenv = dict(s.split(b'=', 1) for s in l)
 except ValueError:
-raise ValueError('unexpected value in setenv request')
+raise ValueError(b'unexpected value in setenv request')
-self.ui.log('chgserver', 'setenv: %r\n', sorted(newenv.keys()))
+self.ui.log(b'chgserver', b'setenv: %r\n', sorted(newenv.keys()))
 encoding.environ.clear()
 encoding.environ.update(newenv)
 capabilities = commandserver.server.capabilities.copy()
 capabilities.update(
 {
-'attachio': attachio,
+b'attachio': attachio,
-'chdir': chdir,
+b'chdir': chdir,
-'runcommand': runcommand,
+b'runcommand': runcommand,
-'setenv': setenv,
+b'setenv': setenv,
-'setumask': setumask,
+b'setumask': setumask,
-'setumask2': setumask2,
+b'setumask2': setumask2,
 }
 )
-if util.safehasattr(procutil, 'setprocname'):
+if util.safehasattr(procutil, b'setprocname'):
 def setprocname(self):
 """Change process title"""
 name = self._readstr()
-self.ui.log('chgserver', 'setprocname: %r\n', name)
+self.ui.log(b'chgserver', b'setprocname: %r\n', name)
 procutil.setprocname(name)
-capabilities['setprocname'] = setprocname
+capabilities[b'setprocname'] = setprocname
 def _tempaddress(address):
-return '%s.%d.tmp' % (address, os.getpid())
+return b'%s.%d.tmp' % (address, os.getpid())
 def _hashaddress(address, hashstr):
 # if the basename of address contains '.', use only the left part. this
 # makes it possible for the client to pass 'server.tmp$PID' and follow by
 # an atomic rename to avoid locking when spawning new servers.
 dirname, basename = os.path.split(address)
-basename = basename.split('.', 1)[0]
+basename = basename.split(b'.', 1)[0]
-return '%s-%s' % (os.path.join(dirname, basename), hashstr)
+return b'%s-%s' % (os.path.join(dirname, basename), hashstr)
 class chgunixservicehandler(object):
 """Set of operations for chg services"""
 pollinterval = 1  # [sec]
 def __init__(self, ui):
 self.ui = ui
-self._idletimeout = ui.configint('chgserver', 'idletimeout')
+self._idletimeout = ui.configint(b'chgserver', b'idletimeout')
 self._lastactive = time.time()
 def bindsocket(self, sock, address):
 self._inithashstate(address)
 self._checkextensions()
 self._createsymlink()
 # no "listening at" message should be printed to simulate hg behavior
 def _inithashstate(self, address):
 self._baseaddress = address
-if self.ui.configbool('chgserver', 'skiphash'):
+if self.ui.configbool(b'chgserver', b'skiphash'):
 self._hashstate = None
 self._realaddress = address
 return
 self._hashstate = hashstate.fromui(self.ui)
 self._realaddress = _hashaddress(address, self._hashstate.confighash)
 return
 if extensions.notloaded():
 # one or more extensions failed to load. mtimehash becomes
 # meaningless because we do not know the paths of those extensions.
 # set mtimehash to an illegal hash value to invalidate the server.
-self._hashstate.mtimehash = ''
+self._hashstate.mtimehash = b''
 def _bind(self, sock):
 # use a unique temp address so we can stat the file and do ownership
 # check later
 tempaddress = _tempaddress(self._realaddress)
 # CHGINTERNALMARK is set by chg client. It is an indication of things are
 # started by chg so other code can do things accordingly, like disabling
 # demandimport or detecting chg client started by chg client. When executed
 # here, CHGINTERNALMARK is no longer useful and hence dropped to make
 # environ cleaner.
-if 'CHGINTERNALMARK' in encoding.environ:
+if b'CHGINTERNALMARK' in encoding.environ:
-del encoding.environ['CHGINTERNALMARK']
+del encoding.environ[b'CHGINTERNALMARK']
 if repo:
 # one chgserver can serve multiple repos. drop repo information
-ui.setconfig('bundle', 'mainreporoot', '', 'repo')
+ui.setconfig(b'bundle', b'mainreporoot', b'', b'repo')
 h = chgunixservicehandler(ui)
 return commandserver.unixforkingservice(ui, repo=None, opts=opts, handler=h)

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43087	66f2cc210a29