mercurial: comparison mercurial/commandserver.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 import struct
 import traceback
 try:
 import selectors
 selectors.BaseSelector
 except ImportError:
 from .thirdparty import selectors2 as selectors
 from .i18n import _
 from .utils import (
 cborutil,
 procutil,
 )
 class channeledoutput(object):
 """
 Write data to out in the following format:
 data length (unsigned int),
 data
 """
 def __init__(self, out, channel):
 self.out = out
 self.channel = channel
 @property
 def __getattr__(self, attr):
 if attr in (r'isatty', r'fileno', r'tell', r'seek'):
 raise AttributeError(attr)
 return getattr(self.out, attr)
 class channeledmessage(object):
 """
 Write encoded message and metadata to out in the following format:
 data length (unsigned int),
 opts[b'data'] = data
 self._cout.write(self._encodefn(opts))
 def __getattr__(self, attr):
 return getattr(self._cout, attr)
 class channeledinput(object):
 """
 Read data from in_.
 def __getattr__(self, attr):
 if attr in (r'isatty', r'fileno', r'tell', r'seek'):
 raise AttributeError(attr)
 return getattr(self.in_, attr)
 _messageencoders = {
 b'cbor': lambda v: b''.join(cborutil.streamencode(v)),
 }
 def _selectmessageencoder(ui):
 # experimental config: cmdserver.message-encodings
 encnames = ui.configlist(b'cmdserver', b'message-encodings')
 for n in encnames:
 f = _messageencoders.get(n)
 if f:
 return n, f
-raise error.Abort(b'no supported message encodings: %s'
+raise error.Abort(
-% b' '.join(encnames))
+b'no supported message encodings: %s' % b' '.join(encnames)
+)
 class server(object):
 """
 Listens for commands on fin, runs them and writes the output on a channel
 based stream to fout.
 """
 def __init__(self, ui, repo, fin, fout, prereposetups=None):
 self.cwd = encoding.getcwd()
 if repo:
 # the ui here is really the repo ui so take its baseui so we don't
 uis = [copiedui]
 if self.repo:
 self.repo.baseui = copiedui
 # clone ui without using ui.copy because this is protected
 repoui = self.repoui.__class__(self.repoui)
-repoui.copy = copiedui.copy # redo copy protection
+repoui.copy = copiedui.copy  # redo copy protection
 uis.append(repoui)
 self.repo.ui = self.repo.dirstate._ui = repoui
 self.repo.invalidateall()
 for ui in uis:
 # replace channels by fully functional tty files. so nontty is
 # enforced only if cin is a channel.
 if not util.safehasattr(self.cin, 'fileno'):
 ui.setconfig('ui', 'nontty', 'true', 'commandserver')
-req = dispatch.request(args[:], copiedui, self.repo, self.cin,
+req = dispatch.request(
-self.cout, self.cerr, self.cmsg,
+args[:],
-prereposetups=self._prereposetups)
+copiedui,
+self.repo,
+self.cin,
+self.cout,
+self.cerr,
+self.cmsg,
+prereposetups=self._prereposetups,
+)
 try:
 ret = dispatch.dispatch(req) & 255
 self.cresult.write(struct.pack('>i', int(ret)))
 finally:
 # looking at the servers capabilities
 raise error.Abort(_('unknown command %s') % cmd)
 return cmd != ''
-capabilities = {'runcommand': runcommand,
+capabilities = {'runcommand': runcommand, 'getencoding': getencoding}
-'getencoding': getencoding}
 def serve(self):
 hellomsg = 'capabilities: ' + ' '.join(sorted(self.capabilities))
 hellomsg += '\n'
 hellomsg += 'encoding: ' + encoding.encoding
 # its request
 return 1
 return 0
 def setuplogging(ui, repo=None, fp=None):
 """Set up server logging facility
 If cmdserver.log is '-', log messages will be sent to the given fp.
 It should be the 'd' channel while a client is connected, and otherwise
 # developer config: cmdserver.max-log-files
 maxfiles = ui.configint(b'cmdserver', b'max-log-files')
 # developer config: cmdserver.max-log-size
 maxsize = ui.configbytes(b'cmdserver', b'max-log-size')
 vfs = vfsmod.vfs(os.path.dirname(logpath))
-logger = loggingutil.filelogger(vfs, os.path.basename(logpath), tracked,
+logger = loggingutil.filelogger(
-maxfiles=maxfiles, maxsize=maxsize)
+vfs,
+os.path.basename(logpath),
+tracked,
+maxfiles=maxfiles,
+maxsize=maxsize,
+)
 targetuis = {ui}
 if repo:
 targetuis.add(repo.baseui)
 targetuis.add(repo.ui)
 for u in targetuis:
 u.setlogger(b'cmdserver', logger)
 class pipeservice(object):
 def __init__(self, ui, repo, opts):
 self.ui = ui
 self.repo = repo
 sv = server(ui, self.repo, fin, fout)
 try:
 return sv.serve()
 finally:
 sv.cleanup()
 def _initworkerprocess():
 # use a different process group from the master process, in order to:
 # 1. make the current process group no longer "orphaned" (because the
 #    parent of this process is in a different process group while
 #    unrelated processes.
 os.setpgid(0, 0)
 # change random state otherwise forked request handlers would have a
 # same state inherited from parent.
 random.seed()
 def _serverequest(ui, repo, conn, createcmdserver, prereposetups):
 fin = conn.makefile(r'rb')
 fout = conn.makefile(r'wb')
 sv = None
 raise
 except KeyboardInterrupt:
 pass
 finally:
 sv.cleanup()
-except: # re-raises
+except:  # re-raises
 # 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:
 fout.close()  # implicit flush() may cause another EPIPE
 except IOError as inst:
 if inst.errno != errno.EPIPE:
 raise
 class unixservicehandler(object):
 """Set of pluggable operations for unix-mode services
 Almost all methods except for createcmdserver() are called in the main
 process. You can't pass mutable resource back from createcmdserver().
 def createcmdserver(self, repo, conn, fin, fout, prereposetups):
 """Create new command server instance; called in the process that
 serves for the current connection"""
 return server(self.ui, repo, fin, fout, prereposetups)
 class unixforkingservice(object):
 """
 Listens on unix domain socket and forks server per connection
 """
 def _mainloop(self):
 exiting = False
 h = self._servicehandler
 selector = selectors.DefaultSelector()
-selector.register(self._sock, selectors.EVENT_READ,
+selector.register(
-self._acceptnewconnection)
+self._sock, selectors.EVENT_READ, self._acceptnewconnection
-selector.register(self._mainipc, selectors.EVENT_READ,
+)
-self._handlemainipc)
+selector.register(
+self._mainipc, selectors.EVENT_READ, self._handlemainipc
+)
 while True:
 if not exiting and h.shouldexit():
 # clients can no longer connect() to the domain socket, so
 # we stop queuing new requests.
 # for requests that are queued (connect()-ed, but haven't been
 # https://instagram-engineering.com/
 #   copy-on-write-friendly-python-garbage-collection-ad6ed5233ddf
 pid = os.fork()
 if pid:
 try:
-self.ui.log(b'cmdserver', b'forked worker process (pid=%d)\n',
+self.ui.log(
-pid)
+b'cmdserver', b'forked worker process (pid=%d)\n', pid
+)
 self._workerpids.add(pid)
 h.newconnection()
 finally:
 conn.close()  # release handle in parent process
 else:
 def _runworker(self, conn):
 signal.signal(signal.SIGCHLD, self._oldsigchldhandler)
 _initworkerprocess()
 h = self._servicehandler
 try:
-_serverequest(self.ui, self.repo, conn, h.createcmdserver,
+_serverequest(
-prereposetups=[self._reposetup])
+self.ui,
+self.repo,
+conn,
+h.createcmdserver,
+prereposetups=[self._reposetup],
+)
 finally:
 gc.collect()  # trigger __del__ since worker process uses os._exit
 def _reposetup(self, ui, repo):
 if not repo.local():
 def close(self):
 super(unixcmdserverrepo, self).close()
 try:
 self._cmdserveripc.send(self.root)
 except socket.error:
-self.ui.log(b'cmdserver',
+self.ui.log(
-b'failed to send repo root to master\n')
+b'cmdserver', b'failed to send repo root to master\n'
+)
 repo.__class__ = unixcmdserverrepo
 repo._cmdserveripc = self._workeripc
 cachedrepo = self._repoloader.get(repo.root)

changeset 43076	2372284d9457
parent 41284	b0e3f2d7c143
child 43077	687b865b95ad