selectors2: do not use platform.system()

`platform.system()` may have a side effect spawning a shell executing
`uname -p`, which may print a warning when the current directory is removed:

  shell-init: error retrieving current directory: getcwd: cannot access parent directories: No such file or directory

This patch changes selectors2 to test the `sys.platform` string, which is a
much safer way to detect Jython.

Jython's `sys.platform` looks like this:

  Jython 2.7.1 (default:0df7adb1b397, Jun 30 2017, 19:02:43)
  [OpenJDK 64-Bit Server VM (Oracle Corporation)] on java1.8.0_144
  Type "help", "copyright", "credits" or "license" for more information.
  >>> import sys
  >>> sys.platform
  'java1.8.0_144 ( ==linux2 for targets )'

Differential Revision: https://phab.mercurial-scm.org/D1018

mercurial/pycompat.py

@@ -1,316 +1,318 b''
 # pycompat.py - portability shim for python 3
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """Mercurial portability shim for python 3.
 
 This contains aliases to hide python version-specific details from the core.
 """
 
 from __future__ import absolute_import
 
 import getopt
 import os
 import shlex
 import sys
 
 ispy3 = (sys.version_info[0] >= 3)
 ispypy = (r'__pypy__' in sys.builtin_module_names)
 
 if not ispy3:
     import cookielib
     import cPickle as pickle
     import httplib
     import Queue as _queue
     import SocketServer as socketserver
     import xmlrpclib
 else:
     import http.cookiejar as cookielib
     import http.client as httplib
     import pickle
     import queue as _queue
     import socketserver
     import xmlrpc.client as xmlrpclib
 
 empty = _queue.Empty
 queue = _queue.Queue
 
 def identity(a):
     return a
 
 if ispy3:
     import builtins
     import functools
     import io
     import struct
 
     fsencode = os.fsencode
     fsdecode = os.fsdecode
     oslinesep = os.linesep.encode('ascii')
     osname = os.name.encode('ascii')
     ospathsep = os.pathsep.encode('ascii')
     ossep = os.sep.encode('ascii')
     osaltsep = os.altsep
     if osaltsep:
         osaltsep = osaltsep.encode('ascii')
     # os.getcwd() on Python 3 returns string, but it has os.getcwdb() which
     # returns bytes.
     getcwd = os.getcwdb
     sysplatform = sys.platform.encode('ascii')
     sysexecutable = sys.executable
     if sysexecutable:
         sysexecutable = os.fsencode(sysexecutable)
     stringio = io.BytesIO
     maplist = lambda *args: list(map(*args))
     rawinput = input
 
     # TODO: .buffer might not exist if std streams were replaced; we'll need
     # a silly wrapper to make a bytes stream backed by a unicode one.
     stdin = sys.stdin.buffer
     stdout = sys.stdout.buffer
     stderr = sys.stderr.buffer
 
     # Since Python 3 converts argv to wchar_t type by Py_DecodeLocale() on Unix,
     # we can use os.fsencode() to get back bytes argv.
     #
     # https://hg.python.org/cpython/file/v3.5.1/Programs/python.c#l55
     #
     # TODO: On Windows, the native argv is wchar_t, so we'll need a different
     # workaround to simulate the Python 2 (i.e. ANSI Win32 API) behavior.
     if getattr(sys, 'argv', None) is not None:
         sysargv = list(map(os.fsencode, sys.argv))
 
     bytechr = struct.Struct('>B').pack
 
     class bytestr(bytes):
         """A bytes which mostly acts as a Python 2 str
 
         >>> bytestr(), bytestr(bytearray(b'foo')), bytestr(u'ascii'), bytestr(1)
         (b'', b'foo', b'ascii', b'1')
         >>> s = bytestr(b'foo')
         >>> assert s is bytestr(s)
 
         __bytes__() should be called if provided:
 
         >>> class bytesable(object):
         ...     def __bytes__(self):
         ...         return b'bytes'
         >>> bytestr(bytesable())
         b'bytes'
 
         There's no implicit conversion from non-ascii str as its encoding is
         unknown:
 
         >>> bytestr(chr(0x80)) # doctest: +ELLIPSIS
         Traceback (most recent call last):
           ...
         UnicodeEncodeError: ...
 
         Comparison between bytestr and bytes should work:
 
         >>> assert bytestr(b'foo') == b'foo'
         >>> assert b'foo' == bytestr(b'foo')
         >>> assert b'f' in bytestr(b'foo')
         >>> assert bytestr(b'f') in b'foo'
 
         Sliced elements should be bytes, not integer:
 
         >>> s[1], s[:2]
         (b'o', b'fo')
         >>> list(s), list(reversed(s))
         ([b'f', b'o', b'o'], [b'o', b'o', b'f'])
 
         As bytestr type isn't propagated across operations, you need to cast
         bytes to bytestr explicitly:
 
         >>> s = bytestr(b'foo').upper()
         >>> t = bytestr(s)
         >>> s[0], t[0]
         (70, b'F')
 
         Be careful to not pass a bytestr object to a function which expects
         bytearray-like behavior.
 
         >>> t = bytes(t)  # cast to bytes
         >>> assert type(t) is bytes
         """
 
         def __new__(cls, s=b''):
             if isinstance(s, bytestr):
                 return s
             if (not isinstance(s, (bytes, bytearray))
                 and not hasattr(s, u'__bytes__')):  # hasattr-py3-only
                 s = str(s).encode(u'ascii')
             return bytes.__new__(cls, s)
 
         def __getitem__(self, key):
             s = bytes.__getitem__(self, key)
             if not isinstance(s, bytes):
                 s = bytechr(s)
             return s
 
         def __iter__(self):
             return iterbytestr(bytes.__iter__(self))
 
     def iterbytestr(s):
         """Iterate bytes as if it were a str object of Python 2"""
         return map(bytechr, s)
 
     def sysbytes(s):
         """Convert an internal str (e.g. keyword, __doc__) back to bytes
 
         This never raises UnicodeEncodeError, but only ASCII characters
         can be round-trip by sysstr(sysbytes(s)).
         """
         return s.encode(u'utf-8')
 
     def sysstr(s):
         """Return a keyword str to be passed to Python functions such as
         getattr() and str.encode()
 
         This never raises UnicodeDecodeError. Non-ascii characters are
         considered invalid and mapped to arbitrary but unique code points
         such that 'sysstr(a) != sysstr(b)' for all 'a != b'.
         """
         if isinstance(s, builtins.str):
             return s
         return s.decode(u'latin-1')
 
     def strurl(url):
         """Converts a bytes url back to str"""
         return url.decode(u'ascii')
 
     def bytesurl(url):
         """Converts a str url to bytes by encoding in ascii"""
         return url.encode(u'ascii')
 
     def raisewithtb(exc, tb):
         """Raise exception with the given traceback"""
         raise exc.with_traceback(tb)
 
     def getdoc(obj):
         """Get docstring as bytes; may be None so gettext() won't confuse it
         with _('')"""
         doc = getattr(obj, u'__doc__', None)
         if doc is None:
             return doc
         return sysbytes(doc)
 
     def _wrapattrfunc(f):
         @functools.wraps(f)
         def w(object, name, *args):
             return f(object, sysstr(name), *args)
         return w
 
     # these wrappers are automagically imported by hgloader
     delattr = _wrapattrfunc(builtins.delattr)
     getattr = _wrapattrfunc(builtins.getattr)
     hasattr = _wrapattrfunc(builtins.hasattr)
     setattr = _wrapattrfunc(builtins.setattr)
     xrange = builtins.range
     unicode = str
 
     def open(name, mode='r', buffering=-1):
         return builtins.open(name, sysstr(mode), buffering)
 
     def getoptb(args, shortlist, namelist):
         """
         Takes bytes arguments, converts them to unicode, pass them to
         getopt.getopt(), convert the returned values back to bytes and then
         return them for Python 3 compatibility as getopt.getopt() don't accepts
         bytes on Python 3.
         """
         args = [a.decode('latin-1') for a in args]
         shortlist = shortlist.decode('latin-1')
         namelist = [a.decode('latin-1') for a in namelist]
         opts, args = getopt.getopt(args, shortlist, namelist)
         opts = [(a[0].encode('latin-1'), a[1].encode('latin-1'))
                 for a in opts]
         args = [a.encode('latin-1') for a in args]
         return opts, args
 
     def strkwargs(dic):
         """
         Converts the keys of a python dictonary to str i.e. unicodes so that
         they can be passed as keyword arguments as dictonaries with bytes keys
         can't be passed as keyword arguments to functions on Python 3.
         """
         dic = dict((k.decode('latin-1'), v) for k, v in dic.iteritems())
         return dic
 
     def byteskwargs(dic):
         """
         Converts keys of python dictonaries to bytes as they were converted to
         str to pass that dictonary as a keyword argument on Python 3.
         """
         dic = dict((k.encode('latin-1'), v) for k, v in dic.iteritems())
         return dic
 
     # TODO: handle shlex.shlex().
     def shlexsplit(s):
         """
         Takes bytes argument, convert it to str i.e. unicodes, pass that into
         shlex.split(), convert the returned value to bytes and return that for
         Python 3 compatibility as shelx.split() don't accept bytes on Python 3.
         """
         ret = shlex.split(s.decode('latin-1'))
         return [a.encode('latin-1') for a in ret]
 
 else:
     import cStringIO
 
     bytechr = chr
     bytestr = str
     iterbytestr = iter
     sysbytes = identity
     sysstr = identity
     strurl = identity
     bytesurl = identity
 
     # this can't be parsed on Python 3
     exec('def raisewithtb(exc, tb):\n'
          '    raise exc, None, tb\n')
 
     def fsencode(filename):
         """
         Partial backport from os.py in Python 3, which only accepts bytes.
         In Python 2, our paths should only ever be bytes, a unicode path
         indicates a bug.
         """
         if isinstance(filename, str):
             return filename
         else:
             raise TypeError(
                 "expect str, not %s" % type(filename).__name__)
 
     # In Python 2, fsdecode() has a very chance to receive bytes. So it's
     # better not to touch Python 2 part as it's already working fine.
     fsdecode = identity
 
     def getdoc(obj):
         return getattr(obj, '__doc__', None)
 
     def getoptb(args, shortlist, namelist):
         return getopt.getopt(args, shortlist, namelist)
 
     strkwargs = identity
     byteskwargs = identity
 
     oslinesep = os.linesep
     osname = os.name
     ospathsep = os.pathsep
     ossep = os.sep
     osaltsep = os.altsep
     stdin = sys.stdin
     stdout = sys.stdout
     stderr = sys.stderr
     if getattr(sys, 'argv', None) is not None:
         sysargv = sys.argv
     sysplatform = sys.platform
     getcwd = os.getcwd
     sysexecutable = sys.executable
     shlexsplit = shlex.split
     stringio = cStringIO.StringIO
     maplist = map
     rawinput = raw_input
+
+isjython = sysplatform.startswith('java')

mercurial/selectors2.py

@@ -1,744 +1,745 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 platform
 import select
 import socket
 import sys
 import time
 
+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 platform.system() == 'Java':
+    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 platform.system() == 'Java':  # Platform-specific: Jython
+        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()