thirdparty: move selectors2 module to where it should be

mercurial/__init__.py

@@ -1,299 +1,296 b''
 # __init__.py - Startup and module loading logic for Mercurial.
 #
 # Copyright 2015 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import sys
 
 # Allow 'from mercurial import demandimport' to keep working.
 import hgdemandimport
 demandimport = hgdemandimport
 
 __all__ = []
 
 # Python 3 uses a custom module loader that transforms source code between
 # source file reading and compilation. This is done by registering a custom
 # finder that changes the spec for Mercurial modules to use a custom loader.
 if sys.version_info[0] >= 3:
     import importlib
     import importlib.abc
     import io
     import token
     import tokenize
 
     class hgpathentryfinder(importlib.abc.MetaPathFinder):
         """A sys.meta_path finder that uses a custom module loader."""
         def find_spec(self, fullname, path, target=None):
             # Only handle Mercurial-related modules.
             if not fullname.startswith(('mercurial.', 'hgext.', 'hgext3rd.')):
                 return None
-            # selectors2 is already dual-version clean, don't try and mangle it
-            if fullname.startswith('mercurial.selectors2'):
-                return None
             # third-party packages are expected to be dual-version clean
             if fullname.startswith('mercurial.thirdparty'):
                 return None
             # zstd is already dual-version clean, don't try and mangle it
             if fullname.startswith('mercurial.zstd'):
                 return None
             # pywatchman is already dual-version clean, don't try and mangle it
             if fullname.startswith('hgext.fsmonitor.pywatchman'):
                 return None
 
             # Try to find the module using other registered finders.
             spec = None
             for finder in sys.meta_path:
                 if finder == self:
                     continue
 
                 spec = finder.find_spec(fullname, path, target=target)
                 if spec:
                     break
 
             # This is a Mercurial-related module but we couldn't find it
             # using the previously-registered finders. This likely means
             # the module doesn't exist.
             if not spec:
                 return None
 
             # TODO need to support loaders from alternate specs, like zip
             # loaders.
             loader = hgloader(spec.name, spec.origin)
             # Can't use util.safehasattr here because that would require
             # importing util, and we're in import code.
             if hasattr(spec.loader, 'loader'): # hasattr-py3-only
                 # This is a nested loader (maybe a lazy loader?)
                 spec.loader.loader = loader
             else:
                 spec.loader = loader
             return spec
 
     def replacetokens(tokens, fullname):
         """Transform a stream of tokens from raw to Python 3.
 
         It is called by the custom module loading machinery to rewrite
         source/tokens between source decoding and compilation.
 
         Returns a generator of possibly rewritten tokens.
 
         The input token list may be mutated as part of processing. However,
         its changes do not necessarily match the output token stream.
 
         REMEMBER TO CHANGE ``BYTECODEHEADER`` WHEN CHANGING THIS FUNCTION
         OR CACHED FILES WON'T GET INVALIDATED PROPERLY.
         """
         futureimpline = False
 
         # The following utility functions access the tokens list and i index of
         # the for i, t enumerate(tokens) loop below
         def _isop(j, *o):
             """Assert that tokens[j] is an OP with one of the given values"""
             try:
                 return tokens[j].type == token.OP and tokens[j].string in o
             except IndexError:
                 return False
 
         def _findargnofcall(n):
             """Find arg n of a call expression (start at 0)
 
             Returns index of the first token of that argument, or None if
             there is not that many arguments.
 
             Assumes that token[i + 1] is '('.
 
             """
             nested = 0
             for j in range(i + 2, len(tokens)):
                 if _isop(j, ')', ']', '}'):
                     # end of call, tuple, subscription or dict / set
                     nested -= 1
                     if nested < 0:
                         return None
                 elif n == 0:
                     # this is the starting position of arg
                     return j
                 elif _isop(j, '(', '[', '{'):
                     nested += 1
                 elif _isop(j, ',') and nested == 0:
                     n -= 1
 
             return None
 
         def _ensureunicode(j):
             """Make sure the token at j is a unicode string
 
             This rewrites a string token to include the unicode literal prefix
             so the string transformer won't add the byte prefix.
 
             Ignores tokens that are not strings. Assumes bounds checking has
             already been done.
 
             """
             st = tokens[j]
             if st.type == token.STRING and st.string.startswith(("'", '"')):
                 tokens[j] = st._replace(string='u%s' % st.string)
 
         for i, t in enumerate(tokens):
             # Convert most string literals to byte literals. String literals
             # in Python 2 are bytes. String literals in Python 3 are unicode.
             # Most strings in Mercurial are bytes and unicode strings are rare.
             # Rather than rewrite all string literals to use ``b''`` to indicate
             # byte strings, we apply this token transformer to insert the ``b``
             # prefix nearly everywhere.
             if t.type == token.STRING:
                 s = t.string
 
                 # Preserve docstrings as string literals. This is inconsistent
                 # with regular unprefixed strings. However, the
                 # "from __future__" parsing (which allows a module docstring to
                 # exist before it) doesn't properly handle the docstring if it
                 # is b''' prefixed, leading to a SyntaxError. We leave all
                 # docstrings as unprefixed to avoid this. This means Mercurial
                 # components touching docstrings need to handle unicode,
                 # unfortunately.
                 if s[0:3] in ("'''", '"""'):
                     yield t
                     continue
 
                 # If the first character isn't a quote, it is likely a string
                 # prefixing character (such as 'b', 'u', or 'r'. Ignore.
                 if s[0] not in ("'", '"'):
                     yield t
                     continue
 
                 # String literal. Prefix to make a b'' string.
                 yield t._replace(string='b%s' % t.string)
                 continue
 
             # Insert compatibility imports at "from __future__ import" line.
             # No '\n' should be added to preserve line numbers.
             if (t.type == token.NAME and t.string == 'import' and
                 all(u.type == token.NAME for u in tokens[i - 2:i]) and
                 [u.string for u in tokens[i - 2:i]] == ['from', '__future__']):
                 futureimpline = True
             if t.type == token.NEWLINE and futureimpline:
                 futureimpline = False
                 if fullname == 'mercurial.pycompat':
                     yield t
                     continue
                 r, c = t.start
                 l = (b'; from mercurial.pycompat import '
                      b'delattr, getattr, hasattr, setattr, xrange, '
                      b'open, unicode\n')
                 for u in tokenize.tokenize(io.BytesIO(l).readline):
                     if u.type in (tokenize.ENCODING, token.ENDMARKER):
                         continue
                     yield u._replace(
                         start=(r, c + u.start[1]), end=(r, c + u.end[1]))
                 continue
 
             # This looks like a function call.
             if t.type == token.NAME and _isop(i + 1, '('):
                 fn = t.string
 
                 # *attr() builtins don't accept byte strings to 2nd argument.
                 if (fn in ('getattr', 'setattr', 'hasattr', 'safehasattr') and
                         not _isop(i - 1, '.')):
                     arg1idx = _findargnofcall(1)
                     if arg1idx is not None:
                         _ensureunicode(arg1idx)
 
                 # .encode() and .decode() on str/bytes/unicode don't accept
                 # byte strings on Python 3.
                 elif fn in ('encode', 'decode') and _isop(i - 1, '.'):
                     for argn in range(2):
                         argidx = _findargnofcall(argn)
                         if argidx is not None:
                             _ensureunicode(argidx)
 
                 # It changes iteritems/values to items/values as they are not
                 # present in Python 3 world.
                 elif fn in ('iteritems', 'itervalues'):
                     yield t._replace(string=fn[4:])
                     continue
 
             # Emit unmodified token.
             yield t
 
     # Header to add to bytecode files. This MUST be changed when
     # ``replacetoken`` or any mechanism that changes semantics of module
     # loading is changed. Otherwise cached bytecode may get loaded without
     # the new transformation mechanisms applied.
     BYTECODEHEADER = b'HG\x00\x0a'
 
     class hgloader(importlib.machinery.SourceFileLoader):
         """Custom module loader that transforms source code.
 
         When the source code is converted to a code object, we transform
         certain patterns to be Python 3 compatible. This allows us to write code
         that is natively Python 2 and compatible with Python 3 without
         making the code excessively ugly.
 
         We do this by transforming the token stream between parse and compile.
 
         Implementing transformations invalidates caching assumptions made
         by the built-in importer. The built-in importer stores a header on
         saved bytecode files indicating the Python/bytecode version. If the
         version changes, the cached bytecode is ignored. The Mercurial
         transformations could change at any time. This means we need to check
         that cached bytecode was generated with the current transformation
         code or there could be a mismatch between cached bytecode and what
         would be generated from this class.
 
         We supplement the bytecode caching layer by wrapping ``get_data``
         and ``set_data``. These functions are called when the
         ``SourceFileLoader`` retrieves and saves bytecode cache files,
         respectively. We simply add an additional header on the file. As
         long as the version in this file is changed when semantics change,
         cached bytecode should be invalidated when transformations change.
 
         The added header has the form ``HG<VERSION>``. That is a literal
         ``HG`` with 2 binary bytes indicating the transformation version.
         """
         def get_data(self, path):
             data = super(hgloader, self).get_data(path)
 
             if not path.endswith(tuple(importlib.machinery.BYTECODE_SUFFIXES)):
                 return data
 
             # There should be a header indicating the Mercurial transformation
             # version. If it doesn't exist or doesn't match the current version,
             # we raise an OSError because that is what
             # ``SourceFileLoader.get_code()`` expects when loading bytecode
             # paths to indicate the cached file is "bad."
             if data[0:2] != b'HG':
                 raise OSError('no hg header')
             if data[0:4] != BYTECODEHEADER:
                 raise OSError('hg header version mismatch')
 
             return data[4:]
 
         def set_data(self, path, data, *args, **kwargs):
             if path.endswith(tuple(importlib.machinery.BYTECODE_SUFFIXES)):
                 data = BYTECODEHEADER + data
 
             return super(hgloader, self).set_data(path, data, *args, **kwargs)
 
         def source_to_code(self, data, path):
             """Perform token transformation before compilation."""
             buf = io.BytesIO(data)
             tokens = tokenize.tokenize(buf.readline)
             data = tokenize.untokenize(replacetokens(list(tokens), self.name))
             # Python's built-in importer strips frames from exceptions raised
             # for this code. Unfortunately, that mechanism isn't extensible
             # and our frame will be blamed for the import failure. There
             # are extremely hacky ways to do frame stripping. We haven't
             # implemented them because they are very ugly.
             return super(hgloader, self).source_to_code(data, path)
 
     # We automagically register our custom importer as a side-effect of
     # loading. This is necessary to ensure that any entry points are able
     # to import mercurial.* modules without having to perform this
     # registration themselves.
     if not any(isinstance(x, hgpathentryfinder) for x in sys.meta_path):
         # meta_path is used before any implicit finders and before sys.path.
         sys.meta_path.insert(0, hgpathentryfinder())

mercurial/commandserver.py

@@ -1,549 +1,549 b''
 # commandserver.py - communicate with Mercurial's API over a pipe
 #
 #  Copyright Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 import gc
 import os
 import random
 import signal
 import socket
 import struct
 import traceback
 
 from .i18n import _
+from .thirdparty import selectors2
 from . import (
     encoding,
     error,
     pycompat,
-    selectors2,
     util,
 )
 
 logfile = None
 
 def log(*args):
     if not logfile:
         return
 
     for a in args:
         logfile.write(str(a))
 
     logfile.flush()
 
 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 name(self):
         return '<%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.flush()
 
     def __getattr__(self, attr):
         if attr in ('isatty', 'fileno', 'tell', 'seek'):
             raise AttributeError(attr)
         return getattr(self.out, attr)
 
 class channeledinput(object):
     """
     Read data from in_.
 
     Requests for input are written to out in the following format:
     channel identifier - 'I' for plain input, 'L' line based (1 byte)
     how many bytes to send at most (unsigned int),
 
     The client replies with:
     data length (unsigned int), 0 meaning EOF
     data
     """
 
     maxchunksize = 4 * 1024
 
     def __init__(self, in_, out, channel):
         self.in_ = in_
         self.out = out
         self.channel = channel
 
     @property
     def name(self):
         return '<%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
             size = self.maxchunksize
             s = self._read(size, self.channel)
             buf = s
             while s:
                 s = self._read(size, self.channel)
                 buf += s
 
             return buf
         else:
             return self._read(size, self.channel)
 
     def _read(self, size, channel):
         if not size:
             return ''
         assert size > 0
 
         # tell the client we need at most size bytes
         self.out.write(struct.pack('>cI', channel, size))
         self.out.flush()
 
         length = self.in_.read(4)
         length = struct.unpack('>I', length)[0]
         if not length:
             return ''
         else:
             return self.in_.read(length)
 
     def readline(self, size=-1):
         if size < 0:
             size = self.maxchunksize
             s = self._read(size, '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':
                 s = self._read(size, 'L')
                 buf += s
 
             return buf
         else:
             return self._read(size, 'L')
 
     def __iter__(self):
         return self
 
     def next(self):
         l = self.readline()
         if not l:
             raise StopIteration
         return l
 
     def __getattr__(self, attr):
         if attr in ('isatty', 'fileno', 'tell', 'seek'):
             raise AttributeError(attr)
         return getattr(self.in_, attr)
 
 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):
         self.cwd = pycompat.getcwd()
 
         # developer config: cmdserver.log
         logpath = ui.config("cmdserver", "log")
         if logpath:
             global logfile
             if logpath == '-':
                 # write log on a special 'd' (debug) channel
                 logfile = channeledoutput(fout, 'd')
             else:
                 logfile = open(logpath, 'a')
 
         if repo:
             # the ui here is really the repo ui so take its baseui so we don't
             # end up with its local configuration
             self.ui = repo.baseui
             self.repo = repo
             self.repoui = repo.ui
         else:
             self.ui = ui
             self.repo = self.repoui = None
 
         self.cerr = channeledoutput(fout, 'e')
         self.cout = channeledoutput(fout, 'o')
         self.cin = channeledinput(fin, fout, 'I')
         self.cresult = channeledoutput(fout, 'r')
 
         self.client = fin
 
     def cleanup(self):
         """release and restore resources taken during server session"""
 
     def _read(self, size):
         if not size:
             return ''
 
         data = self.client.read(size)
 
         # is the other end closed?
         if not data:
             raise EOFError
 
         return data
 
     def _readstr(self):
         """read a string from the channel
 
         format:
         data length (uint32), data
         """
         length = struct.unpack('>I', self._read(4))[0]
         if not length:
             return ''
         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')
         else:
             return []
 
     def runcommand(self):
         """ reads a list of \0 terminated arguments, executes
         and writes the return code to the result channel """
         from . import dispatch  # avoid cycle
 
         args = self._readlist()
 
         # copy the uis so changes (e.g. --config or --verbose) don't
         # persist between requests
         copiedui = self.ui.copy()
         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
             uis.append(repoui)
             self.repo.ui = self.repo.dirstate._ui = repoui
             self.repo.invalidateall()
 
         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'):
                 ui.setconfig('ui', 'nontty', 'true', 'commandserver')
 
         req = dispatch.request(args[:], copiedui, self.repo, self.cin,
                                self.cout, self.cerr)
 
         ret = (dispatch.dispatch(req) or 0) & 255 # might return None
 
         # restore old cwd
         if '--cwd' in args:
             os.chdir(self.cwd)
 
         self.cresult.write(struct.pack('>i', int(ret)))
 
     def getencoding(self):
         """ writes the current encoding to the result channel """
         self.cresult.write(encoding.encoding)
 
     def serveone(self):
         cmd = self.client.readline()[:-1]
         if cmd:
             handler = self.capabilities.get(cmd)
             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)
 
         return cmd != ''
 
     capabilities = {'runcommand': runcommand,
                     'getencoding': getencoding}
 
     def serve(self):
         hellomsg = 'capabilities: ' + ' '.join(sorted(self.capabilities))
         hellomsg += '\n'
         hellomsg += 'encoding: ' + encoding.encoding
         hellomsg += '\n'
         hellomsg += 'pid: %d' % util.getpid()
         if util.safehasattr(os, 'getpgid'):
             hellomsg += '\n'
             hellomsg += 'pgid: %d' % os.getpgid(0)
 
         # write the hello msg in -one- chunk
         self.cout.write(hellomsg)
 
         try:
             while self.serveone():
                 pass
         except EOFError:
             # we'll get here if the client disconnected while we were reading
             # its request
             return 1
 
         return 0
 
 def _protectio(ui):
     """ duplicates streams and redirect original to null if ui uses stdio """
     ui.flush()
     newfiles = []
     nullfd = os.open(os.devnull, os.O_RDWR)
     for f, sysf, mode in [(ui.fin, util.stdin, pycompat.sysstr('rb')),
                           (ui.fout, util.stdout, pycompat.sysstr('wb'))]:
         if f is sysf:
             newfd = os.dup(f.fileno())
             os.dup2(nullfd, f.fileno())
             f = os.fdopen(newfd, mode)
         newfiles.append(f)
     os.close(nullfd)
     return tuple(newfiles)
 
 def _restoreio(ui, fin, fout):
     """ restores streams from duplicated ones """
     ui.flush()
     for f, uif in [(fin, ui.fin), (fout, ui.fout)]:
         if f is not uif:
             os.dup2(f.fileno(), uif.fileno())
             f.close()
 
 class pipeservice(object):
     def __init__(self, ui, repo, opts):
         self.ui = ui
         self.repo = repo
 
     def init(self):
         pass
 
     def run(self):
         ui = self.ui
         # redirect stdio to null device so that broken extensions or in-process
         # hooks will never cause corruption of channel protocol.
         fin, fout = _protectio(ui)
         try:
             sv = server(ui, self.repo, fin, fout)
             return sv.serve()
         finally:
             sv.cleanup()
             _restoreio(ui, fin, fout)
 
 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
     #    remains in a same session)
     #    according to POSIX 2.2.2.52, orphaned process group will ignore
     #    terminal-generated stop signals like SIGTSTP (Ctrl+Z), which will
     #    cause trouble for things like ncurses.
     # 2. the client can use kill(-pgid, sig) to simulate terminal-generated
     #    SIGINT (Ctrl+C) and process-exit-generated SIGHUP. our child
     #    processes like ssh will be killed properly, without affecting
     #    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):
     fin = conn.makefile('rb')
     fout = conn.makefile('wb')
     sv = None
     try:
         sv = createcmdserver(repo, conn, fin, fout)
         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.warn(_('abort: %s\n') % inst)
         except IOError as inst:
             if inst.errno != errno.EPIPE:
                 raise
         except KeyboardInterrupt:
             pass
         finally:
             sv.cleanup()
     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:
             cerr = channeledoutput(fout, 'e')
         traceback.print_exc(file=cerr)
         raise
     finally:
         fin.close()
         try:
             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().
     """
 
     pollinterval = None
 
     def __init__(self, ui):
         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.flush()  # avoid buffering of status message
 
     def unlinksocket(self, address):
         os.unlink(address)
 
     def shouldexit(self):
         """True if server should shut down; checked per pollinterval"""
         return False
 
     def newconnection(self):
         """Called when main process notices new connection"""
 
     def createcmdserver(self, repo, conn, fin, fout):
         """Create new command server instance; called in the process that
         serves for the current connection"""
         return server(self.ui, repo, fin, fout)
 
 class unixforkingservice(object):
     """
     Listens on unix domain socket and forks server per connection
     """
 
     def __init__(self, ui, repo, opts, handler=None):
         self.ui = ui
         self.repo = repo
         self.address = opts['address']
         if not util.safehasattr(socket, 'AF_UNIX'):
             raise error.Abort(_('unsupported platform'))
         if not self.address:
             raise error.Abort(_('no socket path specified with --address'))
         self._servicehandler = handler or unixservicehandler(ui)
         self._sock = None
         self._oldsigchldhandler = None
         self._workerpids = set()  # updated by signal handler; do not iterate
         self._socketunlinked = None
 
     def init(self):
         self._sock = socket.socket(socket.AF_UNIX)
         self._servicehandler.bindsocket(self._sock, self.address)
         o = signal.signal(signal.SIGCHLD, self._sigchldhandler)
         self._oldsigchldhandler = o
         self._socketunlinked = False
 
     def _unlinksocket(self):
         if not self._socketunlinked:
             self._servicehandler.unlinksocket(self.address)
             self._socketunlinked = True
 
     def _cleanup(self):
         signal.signal(signal.SIGCHLD, self._oldsigchldhandler)
         self._sock.close()
         self._unlinksocket()
         # don't kill child processes as they have active clients, just wait
         self._reapworkers(0)
 
     def run(self):
         try:
             self._mainloop()
         finally:
             self._cleanup()
 
     def _mainloop(self):
         exiting = False
         h = self._servicehandler
         selector = selectors2.DefaultSelector()
         selector.register(self._sock, selectors2.EVENT_READ)
         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
                 # accept()-ed), handle them before exit. otherwise, clients
                 # waiting for recv() will receive ECONNRESET.
                 self._unlinksocket()
                 exiting = True
             ready = selector.select(timeout=h.pollinterval)
             if not ready:
                 # only exit if we completed all queued requests
                 if exiting:
                     break
                 continue
             try:
                 conn, _addr = self._sock.accept()
             except socket.error as inst:
                 if inst.args[0] == errno.EINTR:
                     continue
                 raise
 
             pid = os.fork()
             if pid:
                 try:
                     self.ui.debug('forked worker process (pid=%d)\n' % pid)
                     self._workerpids.add(pid)
                     h.newconnection()
                 finally:
                     conn.close()  # release handle in parent process
             else:
                 try:
                     self._runworker(conn)
                     conn.close()
                     os._exit(0)
                 except:  # never return, hence no re-raises
                     try:
                         self.ui.traceback(force=True)
                     finally:
                         os._exit(255)
         selector.close()
 
     def _sigchldhandler(self, signal, frame):
         self._reapworkers(os.WNOHANG)
 
     def _reapworkers(self, options):
         while self._workerpids:
             try:
                 pid, _status = os.waitpid(-1, options)
             except OSError as inst:
                 if inst.errno == errno.EINTR:
                     continue
                 if inst.errno != errno.ECHILD:
                     raise
                 # no child processes at all (reaped by other waitpid()?)
                 self._workerpids.clear()
                 return
             if pid == 0:
                 # no waitable child processes
                 return
             self.ui.debug('worker process exited (pid=%d)\n' % pid)
             self._workerpids.discard(pid)
 
     def _runworker(self, conn):
         signal.signal(signal.SIGCHLD, self._oldsigchldhandler)
         _initworkerprocess()
         h = self._servicehandler
         try:
             _serverequest(self.ui, self.repo, conn, h.createcmdserver)
         finally:
             gc.collect()  # trigger __del__ since worker process uses os._exit

mercurial/thirdparty/selectors2.py

@@ -1,745 +1,743 b''
 """ Back-ported, durable, and portable selectors """
 
 # MIT License
 #
 # Copyright (c) 2017 Seth Michael Larson
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-# no-check-code
-
 from __future__ import absolute_import
 
 import collections
 import errno
 import math
 import select
 import socket
 import sys
 import time
 
-from . import pycompat
+from .. import pycompat
 
 namedtuple = collections.namedtuple
 Mapping = collections.Mapping
 
 try:
     monotonic = time.monotonic
 except AttributeError:
     monotonic = time.time
 
 __author__ = 'Seth Michael Larson'
 __email__ = '[e-mail]'
 __version__ = '2.0.0'
 __license__ = 'MIT'
 __url__ = 'https://www.github.com/SethMichaelLarson/selectors2'
 
 __all__ = ['EVENT_READ',
            'EVENT_WRITE',
            'SelectorKey',
            'DefaultSelector',
            'BaseSelector']
 
 EVENT_READ = (1 << 0)
 EVENT_WRITE = (1 << 1)
 _DEFAULT_SELECTOR = None
 _SYSCALL_SENTINEL = object()  # Sentinel in case a system call returns None.
 _ERROR_TYPES = (OSError, IOError, socket.error)
 
 
 SelectorKey = namedtuple('SelectorKey', ['fileobj', 'fd', 'events', 'data'])
 
 
 class _SelectorMapping(Mapping):
     """ Mapping of file objects to selector keys """
 
     def __init__(self, selector):
         self._selector = selector
 
     def __len__(self):
         return len(self._selector._fd_to_key)
 
     def __getitem__(self, fileobj):
         try:
             fd = self._selector._fileobj_lookup(fileobj)
             return self._selector._fd_to_key[fd]
         except KeyError:
             raise KeyError("{0!r} is not registered.".format(fileobj))
 
     def __iter__(self):
         return iter(self._selector._fd_to_key)
 
 
 def _fileobj_to_fd(fileobj):
     """ Return a file descriptor from a file object. If
     given an integer will simply return that integer back. """
     if isinstance(fileobj, int):
         fd = fileobj
     else:
         try:
             fd = int(fileobj.fileno())
         except (AttributeError, TypeError, ValueError):
             raise ValueError("Invalid file object: {0!r}".format(fileobj))
     if fd < 0:
         raise ValueError("Invalid file descriptor: {0}".format(fd))
     return fd
 
 
 class BaseSelector(object):
     """ Abstract Selector class
 
     A selector supports registering file objects to be monitored
     for specific I/O events.
 
     A file object is a file descriptor or any object with a
     `fileno()` method. An arbitrary object can be attached to the
     file object which can be used for example to store context info,
     a callback, etc.
 
     A selector can use various implementations (select(), poll(), epoll(),
     and kqueue()) depending on the platform. The 'DefaultSelector' class uses
     the most efficient implementation for the current platform.
     """
     def __init__(self):
         # Maps file descriptors to keys.
         self._fd_to_key = {}
 
         # Read-only mapping returned by get_map()
         self._map = _SelectorMapping(self)
 
     def _fileobj_lookup(self, fileobj):
         """ Return a file descriptor from a file object.
         This wraps _fileobj_to_fd() to do an exhaustive
         search in case the object is invalid but we still
         have it in our map. Used by unregister() so we can
         unregister an object that was previously registered
         even if it is closed. It is also used by _SelectorMapping
         """
         try:
             return _fileobj_to_fd(fileobj)
         except ValueError:
 
             # Search through all our mapped keys.
             for key in self._fd_to_key.values():
                 if key.fileobj is fileobj:
                     return key.fd
 
             # Raise ValueError after all.
             raise
 
     def register(self, fileobj, events, data=None):
         """ Register a file object for a set of events to monitor. """
         if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)):
             raise ValueError("Invalid events: {0!r}".format(events))
 
         key = SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)
 
         if key.fd in self._fd_to_key:
             raise KeyError("{0!r} (FD {1}) is already registered"
                            .format(fileobj, key.fd))
 
         self._fd_to_key[key.fd] = key
         return key
 
     def unregister(self, fileobj):
         """ Unregister a file object from being monitored. """
         try:
             key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
         except KeyError:
             raise KeyError("{0!r} is not registered".format(fileobj))
 
         # Getting the fileno of a closed socket on Windows errors with EBADF.
         except socket.error as err:
             if err.errno != errno.EBADF:
                 raise
             else:
                 for key in self._fd_to_key.values():
                     if key.fileobj is fileobj:
                         self._fd_to_key.pop(key.fd)
                         break
                 else:
                     raise KeyError("{0!r} is not registered".format(fileobj))
         return key
 
     def modify(self, fileobj, events, data=None):
         """ Change a registered file object monitored events and data. """
         # NOTE: Some subclasses optimize this operation even further.
         try:
             key = self._fd_to_key[self._fileobj_lookup(fileobj)]
         except KeyError:
             raise KeyError("{0!r} is not registered".format(fileobj))
 
         if events != key.events:
             self.unregister(fileobj)
             key = self.register(fileobj, events, data)
 
         elif data != key.data:
             # Use a shortcut to update the data.
             key = key._replace(data=data)
             self._fd_to_key[key.fd] = key
 
         return key
 
     def select(self, timeout=None):
         """ Perform the actual selection until some monitored file objects
         are ready or the timeout expires. """
         raise NotImplementedError()
 
     def close(self):
         """ Close the selector. This must be called to ensure that all
         underlying resources are freed. """
         self._fd_to_key.clear()
         self._map = None
 
     def get_key(self, fileobj):
         """ Return the key associated with a registered file object. """
         mapping = self.get_map()
         if mapping is None:
             raise RuntimeError("Selector is closed")
         try:
             return mapping[fileobj]
         except KeyError:
             raise KeyError("{0!r} is not registered".format(fileobj))
 
     def get_map(self):
         """ Return a mapping of file objects to selector keys """
         return self._map
 
     def _key_from_fd(self, fd):
         """ Return the key associated to a given file descriptor
          Return None if it is not found. """
         try:
             return self._fd_to_key[fd]
         except KeyError:
             return None
 
     def __enter__(self):
         return self
 
     def __exit__(self, *_):
         self.close()
 
 
 # Almost all platforms have select.select()
 if hasattr(select, "select"):
     class SelectSelector(BaseSelector):
         """ Select-based selector. """
         def __init__(self):
             super(SelectSelector, self).__init__()
             self._readers = set()
             self._writers = set()
 
         def register(self, fileobj, events, data=None):
             key = super(SelectSelector, self).register(fileobj, events, data)
             if events & EVENT_READ:
                 self._readers.add(key.fd)
             if events & EVENT_WRITE:
                 self._writers.add(key.fd)
             return key
 
         def unregister(self, fileobj):
             key = super(SelectSelector, self).unregister(fileobj)
             self._readers.discard(key.fd)
             self._writers.discard(key.fd)
             return key
 
         def select(self, timeout=None):
             # Selecting on empty lists on Windows errors out.
             if not len(self._readers) and not len(self._writers):
                 return []
 
             timeout = None if timeout is None else max(timeout, 0.0)
             ready = []
             r, w, _ = _syscall_wrapper(self._wrap_select, True, self._readers,
                                        self._writers, timeout)
             r = set(r)
             w = set(w)
             for fd in r | w:
                 events = 0
                 if fd in r:
                     events |= EVENT_READ
                 if fd in w:
                     events |= EVENT_WRITE
 
                 key = self._key_from_fd(fd)
                 if key:
                     ready.append((key, events & key.events))
             return ready
 
         def _wrap_select(self, r, w, timeout=None):
             """ Wrapper for select.select because timeout is a positional arg """
             return select.select(r, w, [], timeout)
 
     __all__.append('SelectSelector')
 
     # Jython has a different implementation of .fileno() for socket objects.
     if pycompat.isjython:
         class _JythonSelectorMapping(object):
             """ This is an implementation of _SelectorMapping that is built
             for use specifically with Jython, which does not provide a hashable
             value from socket.socket.fileno(). """
 
             def __init__(self, selector):
                 assert isinstance(selector, JythonSelectSelector)
                 self._selector = selector
 
             def __len__(self):
                 return len(self._selector._sockets)
 
             def __getitem__(self, fileobj):
                 for sock, key in self._selector._sockets:
                     if sock is fileobj:
                         return key
                 else:
                     raise KeyError("{0!r} is not registered.".format(fileobj))
 
         class JythonSelectSelector(SelectSelector):
             """ This is an implementation of SelectSelector that is for Jython
             which works around that Jython's socket.socket.fileno() does not
             return an integer fd value. All SelectorKey.fd will be equal to -1
             and should not be used. This instead uses object id to compare fileobj
             and will only use select.select as it's the only selector that allows
             directly passing in socket objects rather than registering fds.
             See: http://bugs.jython.org/issue1678
                  https://wiki.python.org/jython/NewSocketModule#socket.fileno.28.29_does_not_return_an_integer
             """
 
             def __init__(self):
                 super(JythonSelectSelector, self).__init__()
 
                 self._sockets = []  # Uses a list of tuples instead of dictionary.
                 self._map = _JythonSelectorMapping(self)
                 self._readers = []
                 self._writers = []
 
                 # Jython has a select.cpython_compatible_select function in older versions.
                 self._select_func = getattr(select, 'cpython_compatible_select', select.select)
 
             def register(self, fileobj, events, data=None):
                 for sock, _ in self._sockets:
                     if sock is fileobj:
                         raise KeyError("{0!r} is already registered"
                                        .format(fileobj, sock))
 
                 key = SelectorKey(fileobj, -1, events, data)
                 self._sockets.append((fileobj, key))
 
                 if events & EVENT_READ:
                     self._readers.append(fileobj)
                 if events & EVENT_WRITE:
                     self._writers.append(fileobj)
                 return key
 
             def unregister(self, fileobj):
                 for i, (sock, key) in enumerate(self._sockets):
                     if sock is fileobj:
                         break
                 else:
                     raise KeyError("{0!r} is not registered.".format(fileobj))
 
                 if key.events & EVENT_READ:
                     self._readers.remove(fileobj)
                 if key.events & EVENT_WRITE:
                     self._writers.remove(fileobj)
 
                 del self._sockets[i]
                 return key
 
             def _wrap_select(self, r, w, timeout=None):
                 """ Wrapper for select.select because timeout is a positional arg """
                 return self._select_func(r, w, [], timeout)
 
         __all__.append('JythonSelectSelector')
         SelectSelector = JythonSelectSelector  # Override so the wrong selector isn't used.
 
 
 if hasattr(select, "poll"):
     class PollSelector(BaseSelector):
         """ Poll-based selector """
         def __init__(self):
             super(PollSelector, self).__init__()
             self._poll = select.poll()
 
         def register(self, fileobj, events, data=None):
             key = super(PollSelector, self).register(fileobj, events, data)
             event_mask = 0
             if events & EVENT_READ:
                 event_mask |= select.POLLIN
             if events & EVENT_WRITE:
                 event_mask |= select.POLLOUT
             self._poll.register(key.fd, event_mask)
             return key
 
         def unregister(self, fileobj):
             key = super(PollSelector, self).unregister(fileobj)
             self._poll.unregister(key.fd)
             return key
 
         def _wrap_poll(self, timeout=None):
             """ Wrapper function for select.poll.poll() so that
             _syscall_wrapper can work with only seconds. """
             if timeout is not None:
                 if timeout <= 0:
                     timeout = 0
                 else:
                     # select.poll.poll() has a resolution of 1 millisecond,
                     # round away from zero to wait *at least* timeout seconds.
                     timeout = math.ceil(timeout * 1000)
 
             result = self._poll.poll(timeout)
             return result
 
         def select(self, timeout=None):
             ready = []
             fd_events = _syscall_wrapper(self._wrap_poll, True, timeout=timeout)
             for fd, event_mask in fd_events:
                 events = 0
                 if event_mask & ~select.POLLIN:
                     events |= EVENT_WRITE
                 if event_mask & ~select.POLLOUT:
                     events |= EVENT_READ
 
                 key = self._key_from_fd(fd)
                 if key:
                     ready.append((key, events & key.events))
 
             return ready
 
     __all__.append('PollSelector')
 
 if hasattr(select, "epoll"):
     class EpollSelector(BaseSelector):
         """ Epoll-based selector """
         def __init__(self):
             super(EpollSelector, self).__init__()
             self._epoll = select.epoll()
 
         def fileno(self):
             return self._epoll.fileno()
 
         def register(self, fileobj, events, data=None):
             key = super(EpollSelector, self).register(fileobj, events, data)
             events_mask = 0
             if events & EVENT_READ:
                 events_mask |= select.EPOLLIN
             if events & EVENT_WRITE:
                 events_mask |= select.EPOLLOUT
             _syscall_wrapper(self._epoll.register, False, key.fd, events_mask)
             return key
 
         def unregister(self, fileobj):
             key = super(EpollSelector, self).unregister(fileobj)
             try:
                 _syscall_wrapper(self._epoll.unregister, False, key.fd)
             except _ERROR_TYPES:
                 # This can occur when the fd was closed since registry.
                 pass
             return key
 
         def select(self, timeout=None):
             if timeout is not None:
                 if timeout <= 0:
                     timeout = 0.0
                 else:
                     # select.epoll.poll() has a resolution of 1 millisecond
                     # but luckily takes seconds so we don't need a wrapper
                     # like PollSelector. Just for better rounding.
                     timeout = math.ceil(timeout * 1000) * 0.001
                 timeout = float(timeout)
             else:
                 timeout = -1.0  # epoll.poll() must have a float.
 
             # We always want at least 1 to ensure that select can be called
             # with no file descriptors registered. Otherwise will fail.
             max_events = max(len(self._fd_to_key), 1)
 
             ready = []
             fd_events = _syscall_wrapper(self._epoll.poll, True,
                                          timeout=timeout,
                                          maxevents=max_events)
             for fd, event_mask in fd_events:
                 events = 0
                 if event_mask & ~select.EPOLLIN:
                     events |= EVENT_WRITE
                 if event_mask & ~select.EPOLLOUT:
                     events |= EVENT_READ
 
                 key = self._key_from_fd(fd)
                 if key:
                     ready.append((key, events & key.events))
             return ready
 
         def close(self):
             self._epoll.close()
             super(EpollSelector, self).close()
 
     __all__.append('EpollSelector')
 
 
 if hasattr(select, "devpoll"):
     class DevpollSelector(BaseSelector):
         """Solaris /dev/poll selector."""
 
         def __init__(self):
             super(DevpollSelector, self).__init__()
             self._devpoll = select.devpoll()
 
         def fileno(self):
             return self._devpoll.fileno()
 
         def register(self, fileobj, events, data=None):
             key = super(DevpollSelector, self).register(fileobj, events, data)
             poll_events = 0
             if events & EVENT_READ:
                 poll_events |= select.POLLIN
             if events & EVENT_WRITE:
                 poll_events |= select.POLLOUT
             self._devpoll.register(key.fd, poll_events)
             return key
 
         def unregister(self, fileobj):
             key = super(DevpollSelector, self).unregister(fileobj)
             self._devpoll.unregister(key.fd)
             return key
 
         def _wrap_poll(self, timeout=None):
             """ Wrapper function for select.poll.poll() so that
             _syscall_wrapper can work with only seconds. """
             if timeout is not None:
                 if timeout <= 0:
                     timeout = 0
                 else:
                     # select.devpoll.poll() has a resolution of 1 millisecond,
                     # round away from zero to wait *at least* timeout seconds.
                     timeout = math.ceil(timeout * 1000)
 
             result = self._devpoll.poll(timeout)
             return result
 
         def select(self, timeout=None):
             ready = []
             fd_events = _syscall_wrapper(self._wrap_poll, True, timeout=timeout)
             for fd, event_mask in fd_events:
                 events = 0
                 if event_mask & ~select.POLLIN:
                     events |= EVENT_WRITE
                 if event_mask & ~select.POLLOUT:
                     events |= EVENT_READ
 
                 key = self._key_from_fd(fd)
                 if key:
                     ready.append((key, events & key.events))
 
             return ready
 
         def close(self):
             self._devpoll.close()
             super(DevpollSelector, self).close()
 
     __all__.append('DevpollSelector')
 
 
 if hasattr(select, "kqueue"):
     class KqueueSelector(BaseSelector):
         """ Kqueue / Kevent-based selector """
         def __init__(self):
             super(KqueueSelector, self).__init__()
             self._kqueue = select.kqueue()
 
         def fileno(self):
             return self._kqueue.fileno()
 
         def register(self, fileobj, events, data=None):
             key = super(KqueueSelector, self).register(fileobj, events, data)
             if events & EVENT_READ:
                 kevent = select.kevent(key.fd,
                                        select.KQ_FILTER_READ,
                                        select.KQ_EV_ADD)
 
                 _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
 
             if events & EVENT_WRITE:
                 kevent = select.kevent(key.fd,
                                        select.KQ_FILTER_WRITE,
                                        select.KQ_EV_ADD)
 
                 _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
 
             return key
 
         def unregister(self, fileobj):
             key = super(KqueueSelector, self).unregister(fileobj)
             if key.events & EVENT_READ:
                 kevent = select.kevent(key.fd,
                                        select.KQ_FILTER_READ,
                                        select.KQ_EV_DELETE)
                 try:
                     _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
                 except _ERROR_TYPES:
                     pass
             if key.events & EVENT_WRITE:
                 kevent = select.kevent(key.fd,
                                        select.KQ_FILTER_WRITE,
                                        select.KQ_EV_DELETE)
                 try:
                     _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
                 except _ERROR_TYPES:
                     pass
 
             return key
 
         def select(self, timeout=None):
             if timeout is not None:
                 timeout = max(timeout, 0)
 
             max_events = len(self._fd_to_key) * 2
             ready_fds = {}
 
             kevent_list = _syscall_wrapper(self._kqueue.control, True,
                                            None, max_events, timeout)
 
             for kevent in kevent_list:
                 fd = kevent.ident
                 event_mask = kevent.filter
                 events = 0
                 if event_mask == select.KQ_FILTER_READ:
                     events |= EVENT_READ
                 if event_mask == select.KQ_FILTER_WRITE:
                     events |= EVENT_WRITE
 
                 key = self._key_from_fd(fd)
                 if key:
                     if key.fd not in ready_fds:
                         ready_fds[key.fd] = (key, events & key.events)
                     else:
                         old_events = ready_fds[key.fd][1]
                         ready_fds[key.fd] = (key, (events | old_events) & key.events)
 
             return list(ready_fds.values())
 
         def close(self):
             self._kqueue.close()
             super(KqueueSelector, self).close()
 
     __all__.append('KqueueSelector')
 
 
 def _can_allocate(struct):
     """ Checks that select structs can be allocated by the underlying
     operating system, not just advertised by the select module. We don't
     check select() because we'll be hopeful that most platforms that
     don't have it available will not advertise it. (ie: GAE) """
     try:
         # select.poll() objects won't fail until used.
         if struct == 'poll':
             p = select.poll()
             p.poll(0)
 
         # All others will fail on allocation.
         else:
             getattr(select, struct)().close()
         return True
     except (OSError, AttributeError):
         return False
 
 
 # Python 3.5 uses a more direct route to wrap system calls to increase speed.
 if sys.version_info >= (3, 5):
     def _syscall_wrapper(func, _, *args, **kwargs):
         """ This is the short-circuit version of the below logic
         because in Python 3.5+ all selectors restart system calls. """
         return func(*args, **kwargs)
 else:
     def _syscall_wrapper(func, recalc_timeout, *args, **kwargs):
         """ Wrapper function for syscalls that could fail due to EINTR.
         All functions should be retried if there is time left in the timeout
         in accordance with PEP 475. """
         timeout = kwargs.get("timeout", None)
         if timeout is None:
             expires = None
             recalc_timeout = False
         else:
             timeout = float(timeout)
             if timeout < 0.0:  # Timeout less than 0 treated as no timeout.
                 expires = None
             else:
                 expires = monotonic() + timeout
 
         args = list(args)
         if recalc_timeout and "timeout" not in kwargs:
             raise ValueError(
                 "Timeout must be in args or kwargs to be recalculated")
 
         result = _SYSCALL_SENTINEL
         while result is _SYSCALL_SENTINEL:
             try:
                 result = func(*args, **kwargs)
             # OSError is thrown by select.select
             # IOError is thrown by select.epoll.poll
             # select.error is thrown by select.poll.poll
             # Aren't we thankful for Python 3.x rework for exceptions?
             except (OSError, IOError, select.error) as e:
                 # select.error wasn't a subclass of OSError in the past.
                 errcode = None
                 if hasattr(e, "errno"):
                     errcode = e.errno
                 elif hasattr(e, "args"):
                     errcode = e.args[0]
 
                 # Also test for the Windows equivalent of EINTR.
                 is_interrupt = (errcode == errno.EINTR or (hasattr(errno, "WSAEINTR") and
                                                            errcode == errno.WSAEINTR))
 
                 if is_interrupt:
                     if expires is not None:
                         current_time = monotonic()
                         if current_time > expires:
                             raise OSError(errno=errno.ETIMEDOUT)
                         if recalc_timeout:
                             if "timeout" in kwargs:
                                 kwargs["timeout"] = expires - current_time
                     continue
                 raise
         return result
 
 
 # Choose the best implementation, roughly:
 # kqueue == devpoll == epoll > poll > select
 # select() also can't accept a FD > FD_SETSIZE (usually around 1024)
 def DefaultSelector():
     """ This function serves as a first call for DefaultSelector to
     detect if the select module is being monkey-patched incorrectly
     by eventlet, greenlet, and preserve proper behavior. """
     global _DEFAULT_SELECTOR
     if _DEFAULT_SELECTOR is None:
         if pycompat.isjython:
             _DEFAULT_SELECTOR = JythonSelectSelector
         elif _can_allocate('kqueue'):
             _DEFAULT_SELECTOR = KqueueSelector
         elif _can_allocate('devpoll'):
             _DEFAULT_SELECTOR = DevpollSelector
         elif _can_allocate('epoll'):
             _DEFAULT_SELECTOR = EpollSelector
         elif _can_allocate('poll'):
             _DEFAULT_SELECTOR = PollSelector
         elif hasattr(select, 'select'):
             _DEFAULT_SELECTOR = SelectSelector
         else:  # Platform-specific: AppEngine
             raise RuntimeError('Platform does not have a selector.')
     return _DEFAULT_SELECTOR()

tests/test-check-code.t

@@ -1,56 +1,55 b''
 #require test-repo
 
   $ . "$TESTDIR/helpers-testrepo.sh"
   $ check_code="$TESTDIR"/../contrib/check-code.py
   $ cd "$TESTDIR"/..
 
 New errors are not allowed. Warnings are strongly discouraged.
 (The writing "no-che?k-code" is for not skipping this file when checking.)
 
   $ testrepohg locate \
   > -X contrib/python-zstandard \
   > -X hgext/fsmonitor/pywatchman \
   > -X mercurial/thirdparty \
   > | sed 's-\\-/-g' | "$check_code" --warnings --per-file=0 - || false
   Skipping i18n/polib.py it has no-che?k-code (glob)
   Skipping mercurial/httpclient/__init__.py it has no-che?k-code (glob)
   Skipping mercurial/httpclient/_readers.py it has no-che?k-code (glob)
-  Skipping mercurial/selectors2.py it has no-che?k-code (glob)
   Skipping mercurial/statprof.py it has no-che?k-code (glob)
   Skipping tests/badserverext.py it has no-che?k-code (glob)
 
 @commands in debugcommands.py should be in alphabetical order.
 
   >>> import re
   >>> commands = []
   >>> with open('mercurial/debugcommands.py', 'rb') as fh:
   ...     for line in fh:
   ...         m = re.match("^@command\('([a-z]+)", line)
   ...         if m:
   ...             commands.append(m.group(1))
   >>> scommands = list(sorted(commands))
   >>> for i, command in enumerate(scommands):
   ...     if command != commands[i]:
   ...         print('commands in debugcommands.py not sorted; first differing '
   ...               'command is %s; expected %s' % (commands[i], command))
   ...         break
 
 Prevent adding new files in the root directory accidentally.
 
   $ testrepohg files 'glob:*'
   .arcconfig
   .clang-format
   .editorconfig
   .hgignore
   .hgsigs
   .hgtags
   .jshintrc
   CONTRIBUTING
   CONTRIBUTORS
   COPYING
   Makefile
   README.rst
   hg
   hgeditor
   hgweb.cgi
   setup.py