mercurial: comparison mercurial/commandserver.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 self.out = out
 self.channel = channel
 @property
 def name(self):
-return '<%c-channel>' % self.channel
+return b'<%c-channel>' % self.channel
 def write(self, data):
 if not data:
 return
 # single write() to guarantee the same atomicity as the underlying file
-self.out.write(struct.pack('>cI', self.channel, len(data)) + data)
+self.out.write(struct.pack(b'>cI', self.channel, len(data)) + data)
 self.out.flush()
 def __getattr__(self, attr):
 if attr in (r'isatty', r'fileno', r'tell', r'seek'):
 raise AttributeError(attr)
 self.out = out
 self.channel = channel
 @property
 def name(self):
-return '<%c-channel>' % self.channel
+return b'<%c-channel>' % self.channel
 def read(self, size=-1):
 if size < 0:
 # if we need to consume all the clients input, ask for 4k chunks
 # so the pipe doesn't fill up risking a deadlock
 else:
 return self._read(size, self.channel)
 def _read(self, size, channel):
 if not size:
-return ''
+return b''
 assert size > 0
 # tell the client we need at most size bytes
-self.out.write(struct.pack('>cI', channel, size))
+self.out.write(struct.pack(b'>cI', channel, size))
 self.out.flush()
 length = self.in_.read(4)
-length = struct.unpack('>I', length)[0]
+length = struct.unpack(b'>I', length)[0]
 if not length:
-return ''
+return b''
 else:
 return self.in_.read(length)
 def readline(self, size=-1):
 if size < 0:
 size = self.maxchunksize
-s = self._read(size, 'L')
+s = self._read(size, b'L')
 buf = s
 # keep asking for more until there's either no more or
 # we got a full line
-while s and s[-1] != '\n':
+while s and s[-1] != b'\n':
-s = self._read(size, 'L')
+s = self._read(size, b'L')
 buf += s
 return buf
 else:
-return self._read(size, 'L')
+return self._read(size, b'L')
 def __iter__(self):
 return self
 def next(self):
 else:
 self.ui = ui
 self.repo = self.repoui = None
 self._prereposetups = prereposetups
-self.cdebug = channeledoutput(fout, 'd')
+self.cdebug = channeledoutput(fout, b'd')
-self.cerr = channeledoutput(fout, 'e')
+self.cerr = channeledoutput(fout, b'e')
-self.cout = channeledoutput(fout, 'o')
+self.cout = channeledoutput(fout, b'o')
-self.cin = channeledinput(fin, fout, 'I')
+self.cin = channeledinput(fin, fout, b'I')
-self.cresult = channeledoutput(fout, 'r')
+self.cresult = channeledoutput(fout, b'r')
 if self.ui.config(b'cmdserver', b'log') == b'-':
 # switch log stream of server's ui to the 'd' (debug) channel
 # (don't touch repo.ui as its lifetime is longer than the server)
 self.ui = self.ui.copy()
 def cleanup(self):
 """release and restore resources taken during server session"""
 def _read(self, size):
 if not size:
-return ''
+return b''
 data = self.client.read(size)
 # is the other end closed?
 if not data:
 """read a string from the channel
 format:
 data length (uint32), data
 """
-length = struct.unpack('>I', self._read(4))[0]
+length = struct.unpack(b'>I', self._read(4))[0]
 if not length:
-return ''
+return b''
 return self._read(length)
 def _readlist(self):
 """read a list of NULL separated strings from the channel"""
 s = self._readstr()
 if s:
-return s.split('\0')
+return s.split(b'\0')
 else:
 return []
 def runcommand(self):
 """ reads a list of \0 terminated arguments, executes
 for ui in uis:
 ui.resetstate()
 # any kind of interaction must use server channels, but chg may
 # replace channels by fully functional tty files. so nontty is
 # enforced only if cin is a channel.
-if not util.safehasattr(self.cin, 'fileno'):
+if not util.safehasattr(self.cin, b'fileno'):
-ui.setconfig('ui', 'nontty', 'true', 'commandserver')
+ui.setconfig(b'ui', b'nontty', b'true', b'commandserver')
 req = dispatch.request(
 args[:],
 copiedui,
 self.repo,
 prereposetups=self._prereposetups,
 )
 try:
 ret = dispatch.dispatch(req) & 255
-self.cresult.write(struct.pack('>i', int(ret)))
+self.cresult.write(struct.pack(b'>i', int(ret)))
 finally:
 # restore old cwd
-if '--cwd' in args:
+if b'--cwd' in args:
 os.chdir(self.cwd)
 def getencoding(self):
 """ writes the current encoding to the result channel """
 self.cresult.write(encoding.encoding)
 if handler:
 handler(self)
 else:
 # clients are expected to check what commands are supported by
 # looking at the servers capabilities
-raise error.Abort(_('unknown command %s') % cmd)
+raise error.Abort(_(b'unknown command %s') % cmd)
-return cmd != ''
+return cmd != b''
-capabilities = {'runcommand': runcommand, 'getencoding': getencoding}
+capabilities = {b'runcommand': runcommand, b'getencoding': getencoding}
 def serve(self):
-hellomsg = 'capabilities: ' + ' '.join(sorted(self.capabilities))
+hellomsg = b'capabilities: ' + b' '.join(sorted(self.capabilities))
-hellomsg += '\n'
+hellomsg += b'\n'
-hellomsg += 'encoding: ' + encoding.encoding
+hellomsg += b'encoding: ' + encoding.encoding
-hellomsg += '\n'
+hellomsg += b'\n'
 if self.cmsg:
-hellomsg += 'message-encoding: %s\n' % self.cmsg.encoding
+hellomsg += b'message-encoding: %s\n' % self.cmsg.encoding
-hellomsg += 'pid: %d' % procutil.getpid()
+hellomsg += b'pid: %d' % procutil.getpid()
-if util.safehasattr(os, 'getpgid'):
+if util.safehasattr(os, b'getpgid'):
-hellomsg += '\n'
+hellomsg += b'\n'
-hellomsg += 'pgid: %d' % os.getpgid(0)
+hellomsg += b'pgid: %d' % os.getpgid(0)
 # write the hello msg in -one- chunk
 self.cout.write(hellomsg)
 try:
 try:
 sv.serve()
 # handle exceptions that may be raised by command server. most of
 # known exceptions are caught by dispatch.
 except error.Abort as inst:
-ui.error(_('abort: %s\n') % inst)
+ui.error(_(b'abort: %s\n') % inst)
 except IOError as inst:
 if inst.errno != errno.EPIPE:
 raise
 except KeyboardInterrupt:
 pass
 # also write traceback to error channel. otherwise client cannot
 # see it because it is written to server's stderr by default.
 if sv:
 cerr = sv.cerr
 else:
-cerr = channeledoutput(fout, 'e')
+cerr = channeledoutput(fout, b'e')
 cerr.write(encoding.strtolocal(traceback.format_exc()))
 raise
 finally:
 fin.close()
 try:
 self.ui = ui
 def bindsocket(self, sock, address):
 util.bindunixsocket(sock, address)
 sock.listen(socket.SOMAXCONN)
-self.ui.status(_('listening at %s\n') % address)
+self.ui.status(_(b'listening at %s\n') % address)
 self.ui.flush()  # avoid buffering of status message
 def unlinksocket(self, address):
 os.unlink(address)
 """
 def __init__(self, ui, repo, opts, handler=None):
 self.ui = ui
 self.repo = repo
-self.address = opts['address']
+self.address = opts[b'address']
-if not util.safehasattr(socket, 'AF_UNIX'):
+if not util.safehasattr(socket, b'AF_UNIX'):
-raise error.Abort(_('unsupported platform'))
+raise error.Abort(_(b'unsupported platform'))
 if not self.address:
-raise error.Abort(_('no socket path specified with --address'))
+raise error.Abort(_(b'no socket path specified with --address'))
 self._servicehandler = handler or unixservicehandler(ui)
 self._sock = None
 self._mainipc = None
 self._workeripc = None
 self._oldsigchldhandler = None
 self._workerpids = set()  # updated by signal handler; do not iterate
 self._socketunlinked = None
 # experimental config: cmdserver.max-repo-cache
 maxlen = ui.configint(b'cmdserver', b'max-repo-cache')
 if maxlen < 0:
-raise error.Abort(_('negative max-repo-cache size not allowed'))
+raise error.Abort(_(b'negative max-repo-cache size not allowed'))
 self._repoloader = repocache.repoloader(ui, maxlen)
 def init(self):
 self._sock = socket.socket(socket.AF_UNIX)
 # IPC channel from many workers to one main process; this is actually
 # a uni-directional pipe, but is backed by a DGRAM socket so each
 # message can be easily separated.
 o = socket.socketpair(socket.AF_UNIX, socket.SOCK_DGRAM)
 self._mainipc, self._workeripc = o
 self._servicehandler.bindsocket(self._sock, self.address)
-if util.safehasattr(procutil, 'unblocksignal'):
+if util.safehasattr(procutil, b'unblocksignal'):
 procutil.unblocksignal(signal.SIGCHLD)
 o = signal.signal(signal.SIGCHLD, self._sigchldhandler)
 self._oldsigchldhandler = o
 self._socketunlinked = False
 self._repoloader.start()

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43089	c59eb1560c44