diff options
Diffstat (limited to 'python/gevent/libev/corecffi.py')
| -rw-r--r-- | python/gevent/libev/corecffi.py | 418 |
1 files changed, 0 insertions, 418 deletions
diff --git a/python/gevent/libev/corecffi.py b/python/gevent/libev/corecffi.py deleted file mode 100644 index d57993c..0000000 --- a/python/gevent/libev/corecffi.py +++ /dev/null @@ -1,418 +0,0 @@ -# pylint: disable=too-many-lines, protected-access, redefined-outer-name, not-callable -# pylint: disable=no-member -from __future__ import absolute_import, print_function -import sys - -# pylint: disable=undefined-all-variable -__all__ = [ - 'get_version', - 'get_header_version', - 'supported_backends', - 'recommended_backends', - 'embeddable_backends', - 'time', - 'loop', -] - -from gevent._util import implementer -from gevent._interfaces import ILoop - -from gevent.libev import _corecffi # pylint:disable=no-name-in-module,import-error - -ffi = _corecffi.ffi # pylint:disable=no-member -libev = _corecffi.lib # pylint:disable=no-member - -if hasattr(libev, 'vfd_open'): - # Must be on windows - assert sys.platform.startswith("win"), "vfd functions only needed on windows" - vfd_open = libev.vfd_open - vfd_free = libev.vfd_free - vfd_get = libev.vfd_get -else: - vfd_open = vfd_free = vfd_get = lambda fd: fd - -##### -## NOTE on Windows: -# The C implementation does several things specially for Windows; -# a possibly incomplete list is: -# -# - the loop runs a periodic signal checker; -# - the io watcher constructor is different and it has a destructor; -# - the child watcher is not defined -# -# The CFFI implementation does none of these things, and so -# is possibly NOT FUNCTIONALLY CORRECT on Win32 -##### - - -from gevent._ffi.loop import AbstractCallbacks -from gevent._ffi.loop import assign_standard_callbacks - -class _Callbacks(AbstractCallbacks): - # pylint:disable=arguments-differ - - def python_check_callback(self, _loop, watcher_ptr, _events): - pass - - def python_prepare_callback(self, _loop_ptr, watcher_ptr, _events): - AbstractCallbacks.python_prepare_callback(self, watcher_ptr) - - def _find_loop_from_c_watcher(self, watcher_ptr): - loop_handle = ffi.cast('struct ev_watcher*', watcher_ptr).data - return self.from_handle(loop_handle) - -_callbacks = assign_standard_callbacks(ffi, libev, _Callbacks) - - -UNDEF = libev.EV_UNDEF -NONE = libev.EV_NONE -READ = libev.EV_READ -WRITE = libev.EV_WRITE -TIMER = libev.EV_TIMER -PERIODIC = libev.EV_PERIODIC -SIGNAL = libev.EV_SIGNAL -CHILD = libev.EV_CHILD -STAT = libev.EV_STAT -IDLE = libev.EV_IDLE -PREPARE = libev.EV_PREPARE -CHECK = libev.EV_CHECK -EMBED = libev.EV_EMBED -FORK = libev.EV_FORK -CLEANUP = libev.EV_CLEANUP -ASYNC = libev.EV_ASYNC -CUSTOM = libev.EV_CUSTOM -ERROR = libev.EV_ERROR - -READWRITE = libev.EV_READ | libev.EV_WRITE - -MINPRI = libev.EV_MINPRI -MAXPRI = libev.EV_MAXPRI - -BACKEND_PORT = libev.EVBACKEND_PORT -BACKEND_KQUEUE = libev.EVBACKEND_KQUEUE -BACKEND_EPOLL = libev.EVBACKEND_EPOLL -BACKEND_POLL = libev.EVBACKEND_POLL -BACKEND_SELECT = libev.EVBACKEND_SELECT -FORKCHECK = libev.EVFLAG_FORKCHECK -NOINOTIFY = libev.EVFLAG_NOINOTIFY -SIGNALFD = libev.EVFLAG_SIGNALFD -NOSIGMASK = libev.EVFLAG_NOSIGMASK - - -from gevent._ffi.loop import EVENTS -GEVENT_CORE_EVENTS = EVENTS - - -def get_version(): - return 'libev-%d.%02d' % (libev.ev_version_major(), libev.ev_version_minor()) - - -def get_header_version(): - return 'libev-%d.%02d' % (libev.EV_VERSION_MAJOR, libev.EV_VERSION_MINOR) - -_flags = [(libev.EVBACKEND_PORT, 'port'), - (libev.EVBACKEND_KQUEUE, 'kqueue'), - (libev.EVBACKEND_EPOLL, 'epoll'), - (libev.EVBACKEND_POLL, 'poll'), - (libev.EVBACKEND_SELECT, 'select'), - (libev.EVFLAG_NOENV, 'noenv'), - (libev.EVFLAG_FORKCHECK, 'forkcheck'), - (libev.EVFLAG_SIGNALFD, 'signalfd'), - (libev.EVFLAG_NOSIGMASK, 'nosigmask')] - -_flags_str2int = dict((string, flag) for (flag, string) in _flags) - - - -def _flags_to_list(flags): - result = [] - for code, value in _flags: - if flags & code: - result.append(value) - flags &= ~code - if not flags: - break - if flags: - result.append(flags) - return result - -if sys.version_info[0] >= 3: - basestring = (bytes, str) - integer_types = (int,) -else: - import __builtin__ # pylint:disable=import-error - basestring = (__builtin__.basestring,) - integer_types = (int, __builtin__.long) - - -def _flags_to_int(flags): - # Note, that order does not matter, libev has its own predefined order - if not flags: - return 0 - if isinstance(flags, integer_types): - return flags - result = 0 - try: - if isinstance(flags, basestring): - flags = flags.split(',') - for value in flags: - value = value.strip().lower() - if value: - result |= _flags_str2int[value] - except KeyError as ex: - raise ValueError('Invalid backend or flag: %s\nPossible values: %s' % (ex, ', '.join(sorted(_flags_str2int.keys())))) - return result - - -def _str_hex(flag): - if isinstance(flag, integer_types): - return hex(flag) - return str(flag) - - -def _check_flags(flags): - as_list = [] - flags &= libev.EVBACKEND_MASK - if not flags: - return - if not flags & libev.EVBACKEND_ALL: - raise ValueError('Invalid value for backend: 0x%x' % flags) - if not flags & libev.ev_supported_backends(): - as_list = [_str_hex(x) for x in _flags_to_list(flags)] - raise ValueError('Unsupported backend: %s' % '|'.join(as_list)) - - -def supported_backends(): - return _flags_to_list(libev.ev_supported_backends()) - - -def recommended_backends(): - return _flags_to_list(libev.ev_recommended_backends()) - - -def embeddable_backends(): - return _flags_to_list(libev.ev_embeddable_backends()) - - -def time(): - return libev.ev_time() - -from gevent._ffi.loop import AbstractLoop - - -from gevent.libev import watcher as _watchers -_events_to_str = _watchers._events_to_str # exported - - -@implementer(ILoop) -class loop(AbstractLoop): - # pylint:disable=too-many-public-methods - - error_handler = None - - _CHECK_POINTER = 'struct ev_check *' - - _PREPARE_POINTER = 'struct ev_prepare *' - - _TIMER_POINTER = 'struct ev_timer *' - - def __init__(self, flags=None, default=None): - AbstractLoop.__init__(self, ffi, libev, _watchers, flags, default) - self._default = True if libev.ev_is_default_loop(self._ptr) else False - - - def _init_loop(self, flags, default): - c_flags = _flags_to_int(flags) - _check_flags(c_flags) - c_flags |= libev.EVFLAG_NOENV - c_flags |= libev.EVFLAG_FORKCHECK - if default is None: - default = True - if default: - ptr = libev.gevent_ev_default_loop(c_flags) - if not ptr: - raise SystemError("ev_default_loop(%s) failed" % (c_flags, )) - else: - ptr = libev.ev_loop_new(c_flags) - if not ptr: - raise SystemError("ev_loop_new(%s) failed" % (c_flags, )) - if default or globals()["__SYSERR_CALLBACK"] is None: - set_syserr_cb(self._handle_syserr) - - # Mark this loop as being used. - libev.ev_set_userdata(ptr, ptr) - return ptr - - def _init_and_start_check(self): - libev.ev_check_init(self._check, libev.python_check_callback) - self._check.data = self._handle_to_self - libev.ev_check_start(self._ptr, self._check) - self.unref() - - def _init_and_start_prepare(self): - libev.ev_prepare_init(self._prepare, libev.python_prepare_callback) - libev.ev_prepare_start(self._ptr, self._prepare) - self.unref() - - def _init_callback_timer(self): - libev.ev_timer_init(self._timer0, libev.gevent_noop, 0.0, 0.0) - - def _stop_callback_timer(self): - libev.ev_timer_stop(self._ptr, self._timer0) - - def _start_callback_timer(self): - libev.ev_timer_start(self._ptr, self._timer0) - - def _stop_aux_watchers(self): - if libev.ev_is_active(self._prepare): - self.ref() - libev.ev_prepare_stop(self._ptr, self._prepare) - if libev.ev_is_active(self._check): - self.ref() - libev.ev_check_stop(self._ptr, self._check) - if libev.ev_is_active(self._timer0): - libev.ev_timer_stop(self._timer0) - - def _setup_for_run_callback(self): - self.ref() # we should go through the loop now - - def destroy(self): - if self._ptr: - super(loop, self).destroy() - # pylint:disable=comparison-with-callable - if globals()["__SYSERR_CALLBACK"] == self._handle_syserr: - set_syserr_cb(None) - - - def _can_destroy_loop(self, ptr): - # Is it marked as destroyed? - return libev.ev_userdata(ptr) - - def _destroy_loop(self, ptr): - # Mark as destroyed. - libev.ev_set_userdata(ptr, ffi.NULL) - libev.ev_loop_destroy(ptr) - - libev.gevent_zero_prepare(self._prepare) - libev.gevent_zero_check(self._check) - libev.gevent_zero_timer(self._timer0) - - del self._prepare - del self._check - del self._timer0 - - - @property - def MAXPRI(self): - return libev.EV_MAXPRI - - @property - def MINPRI(self): - return libev.EV_MINPRI - - def _default_handle_error(self, context, type, value, tb): # pylint:disable=unused-argument - super(loop, self)._default_handle_error(context, type, value, tb) - libev.ev_break(self._ptr, libev.EVBREAK_ONE) - - def run(self, nowait=False, once=False): - flags = 0 - if nowait: - flags |= libev.EVRUN_NOWAIT - if once: - flags |= libev.EVRUN_ONCE - - libev.ev_run(self._ptr, flags) - - def reinit(self): - libev.ev_loop_fork(self._ptr) - - def ref(self): - libev.ev_ref(self._ptr) - - def unref(self): - libev.ev_unref(self._ptr) - - def break_(self, how=libev.EVBREAK_ONE): - libev.ev_break(self._ptr, how) - - def verify(self): - libev.ev_verify(self._ptr) - - def now(self): - return libev.ev_now(self._ptr) - - def update_now(self): - libev.ev_now_update(self._ptr) - - def __repr__(self): - return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), self._format()) - - @property - def iteration(self): - return libev.ev_iteration(self._ptr) - - @property - def depth(self): - return libev.ev_depth(self._ptr) - - @property - def backend_int(self): - return libev.ev_backend(self._ptr) - - @property - def backend(self): - backend = libev.ev_backend(self._ptr) - for key, value in _flags: - if key == backend: - return value - return backend - - @property - def pendingcnt(self): - return libev.ev_pending_count(self._ptr) - - if sys.platform != "win32": - - def install_sigchld(self): - libev.gevent_install_sigchld_handler() - - def reset_sigchld(self): - libev.gevent_reset_sigchld_handler() - - def fileno(self): - if self._ptr: - fd = self._ptr.backend_fd - if fd >= 0: - return fd - - @property - def activecnt(self): - if not self._ptr: - raise ValueError('operation on destroyed loop') - return self._ptr.activecnt - - -@ffi.def_extern() -def _syserr_cb(msg): - try: - msg = ffi.string(msg) - __SYSERR_CALLBACK(msg, ffi.errno) - except: - set_syserr_cb(None) - raise # let cffi print the traceback - - -def set_syserr_cb(callback): - global __SYSERR_CALLBACK - if callback is None: - libev.ev_set_syserr_cb(ffi.NULL) - __SYSERR_CALLBACK = None - elif callable(callback): - libev.ev_set_syserr_cb(libev._syserr_cb) - __SYSERR_CALLBACK = callback - else: - raise TypeError('Expected callable or None, got %r' % (callback, )) - -__SYSERR_CALLBACK = None - -LIBEV_EMBED = True |