diff options
Diffstat (limited to 'python/gevent/libev/corecext.ppyx')
| -rw-r--r-- | python/gevent/libev/corecext.ppyx | 1134 |
1 files changed, 0 insertions, 1134 deletions
diff --git a/python/gevent/libev/corecext.ppyx b/python/gevent/libev/corecext.ppyx deleted file mode 100644 index a474d7e..0000000 --- a/python/gevent/libev/corecext.ppyx +++ /dev/null @@ -1,1134 +0,0 @@ -# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details. -# This directive, supported in Cython 0.24+, causes sources files to be -# much smaller and thus cythonpp.py to be slightly faster. But it does make -# debugging more difficult. -# cython: emit_code_comments=False -cimport cython -cimport libev -# Note this is not the standard cython 'cpython' (which has a backwards compat alias of 'python') -# it's our custom def. If it's not on the include path, we get warned. -from python cimport * - -# Work around lack of absolute_import in Cython -# Note for PY3: not doing so will leave reference to locals() on import -# (reproducible under Python 3.3, not under Python 3.4; see test__refcount_core.py) -sys = __import__('sys', level=0) -os = __import__('os', level=0) -traceback = __import__('traceback', level=0) -signalmodule = __import__('signal', level=0) - - -__all__ = ['get_version', - 'get_header_version', - 'supported_backends', - 'recommended_backends', - 'embeddable_backends', - 'time', - 'loop'] - -cdef tuple integer_types - -if sys.version_info[0] >= 3: - integer_types = int, -else: - integer_types = (int, long) - - -cdef extern from "callbacks.h": - void gevent_callback_io(libev.ev_loop, void*, int) - void gevent_callback_timer(libev.ev_loop, void*, int) - void gevent_callback_signal(libev.ev_loop, void*, int) - void gevent_callback_idle(libev.ev_loop, void*, int) - void gevent_callback_prepare(libev.ev_loop, void*, int) - void gevent_callback_check(libev.ev_loop, void*, int) - void gevent_callback_fork(libev.ev_loop, void*, int) - void gevent_callback_async(libev.ev_loop, void*, int) - void gevent_callback_child(libev.ev_loop, void*, int) - void gevent_callback_stat(libev.ev_loop, void*, int) - void gevent_run_callbacks(libev.ev_loop, void*, int) - void gevent_periodic_signal_check(libev.ev_loop, void*, int) - void gevent_call(loop, callback) - void gevent_noop(libev.ev_loop, void*, int) - -cdef extern from *: - int errno - -cdef extern from "stathelper.c": - object _pystat_fromstructstat(void*) - - -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 - - -@cython.internal -cdef class _EVENTSType: - - def __repr__(self): - return 'gevent.core.EVENTS' - - -cdef public object GEVENT_CORE_EVENTS = _EVENTSType() -EVENTS = GEVENT_CORE_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) - - -# This list backends in the order they are actually tried by libev -_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_NOINOTIFY, 'noinotify'), - (libev.EVFLAG_SIGNALFD, 'signalfd'), - (libev.EVFLAG_NOSIGMASK, 'nosigmask')] - - -_flags_str2int = dict((string, flag) for (flag, string) in _flags) - - -_events = [(libev.EV_READ, 'READ'), - (libev.EV_WRITE, 'WRITE'), - (libev.EV__IOFDSET, '_IOFDSET'), - (libev.EV_PERIODIC, 'PERIODIC'), - (libev.EV_SIGNAL, 'SIGNAL'), - (libev.EV_CHILD, 'CHILD'), - (libev.EV_STAT, 'STAT'), - (libev.EV_IDLE, 'IDLE'), - (libev.EV_PREPARE, 'PREPARE'), - (libev.EV_CHECK, 'CHECK'), - (libev.EV_EMBED, 'EMBED'), - (libev.EV_FORK, 'FORK'), - (libev.EV_CLEANUP, 'CLEANUP'), - (libev.EV_ASYNC, 'ASYNC'), - (libev.EV_CUSTOM, 'CUSTOM'), - (libev.EV_ERROR, 'ERROR')] - - -cpdef _flags_to_list(unsigned int flags): - cdef list 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) -else: - basestring = __builtins__.basestring - - -cpdef unsigned int _flags_to_int(object flags) except? -1: - # Note, that order does not matter, libev has its own predefined order - if not flags: - return 0 - if isinstance(flags, integer_types): - return flags - cdef unsigned int 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 - - -cdef str _str_hex(object flag): - if isinstance(flag, integer_types): - return hex(flag) - return str(flag) - - -cpdef _check_flags(unsigned int flags): - cdef list 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)) - - -cpdef _events_to_str(int events): - cdef list result = [] - cdef int c_flag - for (flag, string) in _events: - c_flag = flag - if events & c_flag: - result.append(string) - events = events & (~c_flag) - if not events: - break - if events: - result.append(hex(events)) - return '|'.join(result) - - -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() - - -#define LOOP_PROPERTY(NAME) property NAME: \ - \ - def __get__(self): \ - CHECK_LOOP3(self) \ - return self._ptr.NAME - - -cdef bint _default_loop_destroyed = False - - -#define CHECK_LOOP2(LOOP) \ - if not LOOP._ptr: \ - raise ValueError('operation on destroyed loop') - - -#define CHECK_LOOP3(LOOP) \ - if not LOOP._ptr: \ - raise ValueError('operation on destroyed loop') - - - -cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]: - cdef libev.ev_loop* _ptr - cdef public object error_handler - cdef libev.ev_prepare _prepare - cdef public list _callbacks - cdef libev.ev_timer _timer0 -#ifdef _WIN32 - cdef libev.ev_timer _periodic_signal_checker -#endif - - def __init__(self, object flags=None, object default=None, size_t ptr=0): - cdef unsigned int c_flags - cdef object old_handler = None - libev.ev_prepare_init(&self._prepare, <void*>gevent_run_callbacks) -#ifdef _WIN32 - libev.ev_timer_init(&self._periodic_signal_checker, <void*>gevent_periodic_signal_check, 0.3, 0.3) -#endif - libev.ev_timer_init(&self._timer0, <void*>gevent_noop, 0.0, 0.0) - if ptr: - self._ptr = <libev.ev_loop*>ptr - else: - 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_loop_destroyed: - default = False - if default: - self._ptr = libev.gevent_ev_default_loop(c_flags) - if not self._ptr: - raise SystemError("ev_default_loop(%s) failed" % (c_flags, )) -#ifdef _WIN32 - libev.ev_timer_start(self._ptr, &self._periodic_signal_checker) - libev.ev_unref(self._ptr) -#endif - else: - self._ptr = libev.ev_loop_new(c_flags) - if not self._ptr: - raise SystemError("ev_loop_new(%s) failed" % (c_flags, )) - if default or __SYSERR_CALLBACK is None: - set_syserr_cb(self._handle_syserr) - libev.ev_prepare_start(self._ptr, &self._prepare) - libev.ev_unref(self._ptr) - self._callbacks = [] - - cdef _run_callbacks(self): - cdef callback cb - cdef object callbacks - cdef int count = 1000 - libev.ev_timer_stop(self._ptr, &self._timer0) - while self._callbacks and count > 0: - callbacks = self._callbacks - self._callbacks = [] - for cb in callbacks: - libev.ev_unref(self._ptr) - gevent_call(self, cb) - count -= 1 - if self._callbacks: - libev.ev_timer_start(self._ptr, &self._timer0) - - def _stop_watchers(self): - if libev.ev_is_active(&self._prepare): - libev.ev_ref(self._ptr) - libev.ev_prepare_stop(self._ptr, &self._prepare) -#ifdef _WIN32 - if libev.ev_is_active(&self._periodic_signal_checker): - libev.ev_ref(self._ptr) - libev.ev_timer_stop(self._ptr, &self._periodic_signal_checker) -#endif - - def destroy(self): - global _default_loop_destroyed - if self._ptr: - self._stop_watchers() - if __SYSERR_CALLBACK == self._handle_syserr: - set_syserr_cb(None) - if libev.ev_is_default_loop(self._ptr): - _default_loop_destroyed = True - libev.ev_loop_destroy(self._ptr) - self._ptr = NULL - - def __dealloc__(self): - if self._ptr: - self._stop_watchers() - if not libev.ev_is_default_loop(self._ptr): - libev.ev_loop_destroy(self._ptr) - self._ptr = NULL - - property ptr: - - def __get__(self): - return <size_t>self._ptr - - property WatcherType: - - def __get__(self): - return watcher - - property MAXPRI: - - def __get__(self): - return libev.EV_MAXPRI - - property MINPRI: - - def __get__(self): - return libev.EV_MINPRI - - def _handle_syserr(self, message, errno): - if sys.version_info[0] >= 3: - message = message.decode() - self.handle_error(None, SystemError, SystemError(message + ': ' + os.strerror(errno)), None) - - cpdef handle_error(self, context, type, value, tb): - cdef object handle_error - cdef object error_handler = self.error_handler - if error_handler is not None: - # we do want to do getattr every time so that setting Hub.handle_error property just works - handle_error = getattr(error_handler, 'handle_error', error_handler) - handle_error(context, type, value, tb) - else: - self._default_handle_error(context, type, value, tb) - - cpdef _default_handle_error(self, context, type, value, tb): - # note: Hub sets its own error handler so this is not used by gevent - # this is here to make core.loop usable without the rest of gevent - traceback.print_exception(type, value, tb) - if self._ptr: - libev.ev_break(self._ptr, libev.EVBREAK_ONE) - - def run(self, nowait=False, once=False): - CHECK_LOOP2(self) - cdef unsigned int flags = 0 - if nowait: - flags |= libev.EVRUN_NOWAIT - if once: - flags |= libev.EVRUN_ONCE - with nogil: - libev.ev_run(self._ptr, flags) - - def reinit(self): - if self._ptr: - libev.ev_loop_fork(self._ptr) - - def ref(self): - CHECK_LOOP2(self) - libev.ev_ref(self._ptr) - - def unref(self): - CHECK_LOOP2(self) - libev.ev_unref(self._ptr) - - def break_(self, int how=libev.EVBREAK_ONE): - CHECK_LOOP2(self) - libev.ev_break(self._ptr, how) - - def verify(self): - CHECK_LOOP2(self) - libev.ev_verify(self._ptr) - - def now(self): - CHECK_LOOP2(self) - return libev.ev_now(self._ptr) - - def update(self): - CHECK_LOOP2(self) - libev.ev_now_update(self._ptr) - - def __repr__(self): - return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), self._format()) - - property default: - - def __get__(self): - CHECK_LOOP3(self) - return True if libev.ev_is_default_loop(self._ptr) else False - - property iteration: - - def __get__(self): - CHECK_LOOP3(self) - return libev.ev_iteration(self._ptr) - - property depth: - - def __get__(self): - CHECK_LOOP3(self) - return libev.ev_depth(self._ptr) - - property backend_int: - - def __get__(self): - CHECK_LOOP3(self) - return libev.ev_backend(self._ptr) - - property backend: - - def __get__(self): - CHECK_LOOP3(self) - cdef unsigned int backend = libev.ev_backend(self._ptr) - for key, value in _flags: - if key == backend: - return value - return backend - - property pendingcnt: - - def __get__(self): - CHECK_LOOP3(self) - return libev.ev_pending_count(self._ptr) - -#ifdef _WIN32 - def io(self, libev.vfd_socket_t fd, int events, ref=True, priority=None): - return io(self, fd, events, ref, priority) -#else - def io(self, int fd, int events, ref=True, priority=None): - return io(self, fd, events, ref, priority) -#endif - - def timer(self, double after, double repeat=0.0, ref=True, priority=None): - return timer(self, after, repeat, ref, priority) - - def signal(self, int signum, ref=True, priority=None): - return signal(self, signum, ref, priority) - - def idle(self, ref=True, priority=None): - return idle(self, ref, priority) - - def prepare(self, ref=True, priority=None): - return prepare(self, ref, priority) - - def check(self, ref=True, priority=None): - return check(self, ref, priority) - - def fork(self, ref=True, priority=None): - return fork(self, ref, priority) - - def async(self, ref=True, priority=None): - return async(self, ref, priority) - -#ifdef _WIN32 -#else - - def child(self, int pid, bint trace=0, ref=True): - return child(self, pid, trace, ref) - - def install_sigchld(self): - libev.gevent_install_sigchld_handler() - - def reset_sigchld(self): - libev.gevent_reset_sigchld_handler() - -#endif - - def stat(self, str path, float interval=0.0, ref=True, priority=None): - return stat(self, path, interval, ref, priority) - - def run_callback(self, func, *args): - CHECK_LOOP2(self) - cdef callback cb = callback(func, args) - self._callbacks.append(cb) - libev.ev_ref(self._ptr) - return cb - - def _format(self): - if not self._ptr: - return 'destroyed' - cdef object msg = self.backend - if self.default: - msg += ' default' - msg += ' pending=%s' % self.pendingcnt -#ifdef LIBEV_EMBED - msg += self._format_details() -#endif - return msg - -#ifdef LIBEV_EMBED - - def _format_details(self): - cdef str msg = '' - cdef object fileno = self.fileno() - cdef object sigfd = None - cdef object activecnt = None - try: - sigfd = self.sigfd - except AttributeError: - sigfd = None - try: - activecnt = self.activecnt - except AttributeError: - pass - if activecnt is not None: - msg += ' ref=' + repr(activecnt) - if fileno is not None: - msg += ' fileno=' + repr(fileno) - if sigfd is not None and sigfd != -1: - msg += ' sigfd=' + repr(sigfd) - return msg - - def fileno(self): - cdef int fd - if self._ptr: - fd = self._ptr.backend_fd - if fd >= 0: - return fd - - LOOP_PROPERTY(activecnt) - - LOOP_PROPERTY(sig_pending) - -#if EV_USE_SIGNALFD - LOOP_PROPERTY(sigfd) -#endif - - property origflags: - - def __get__(self): - CHECK_LOOP3(self) - return _flags_to_list(self._ptr.origflags) - - property origflags_int: - - def __get__(self): - CHECK_LOOP3(self) - return self._ptr.origflags - -#endif - - -cdef public class callback [object PyGeventCallbackObject, type PyGeventCallback_Type]: - cdef public object callback - cdef public tuple args - - def __init__(self, callback, args): - self.callback = callback - self.args = args - - def stop(self): - self.callback = None - self.args = None - - # Note, that __nonzero__ and pending are different - # nonzero is used in contexts where we need to know whether to schedule another callback, - # so it's true if it's pending or currently running - # 'pending' has the same meaning as libev watchers: it is cleared before entering callback - - def __nonzero__(self): - # it's nonzero if it's pending or currently executing - return self.args is not None - - property pending: - - def __get__(self): - return self.callback is not None - - def __repr__(self): - if Py_ReprEnter(<PyObjectPtr>self) != 0: - return "<...>" - try: - format = self._format() - result = "<%s at 0x%x%s" % (self.__class__.__name__, id(self), format) - if self.pending: - result += " pending" - if self.callback is not None: - result += " callback=%r" % (self.callback, ) - if self.args is not None: - result += " args=%r" % (self.args, ) - if self.callback is None and self.args is None: - result += " stopped" - return result + ">" - finally: - Py_ReprLeave(<PyObjectPtr>self) - - def _format(self): - return '' - - -#define PYTHON_INCREF if not self._flags & 1: \ - Py_INCREF(<PyObjectPtr>self) \ - self._flags |= 1 - -#define LIBEV_UNREF if self._flags & 6 == 4: \ - libev.ev_unref(self.loop._ptr) \ - self._flags |= 2 - -# about readonly _flags attribute: -# bit #1 set if object owns Python reference to itself (Py_INCREF was called and we must call Py_DECREF later) -# bit #2 set if ev_unref() was called and we must call ev_ref() later -# bit #3 set if user wants to call ev_unref() before start() - -#define WATCHER_BASE(TYPE) \ - cdef public loop loop \ - cdef object _callback \ - cdef public tuple args \ - cdef readonly int _flags \ - cdef libev.ev_##TYPE _watcher \ - \ - property ref: \ - \ - def __get__(self): \ - return False if self._flags & 4 else True \ - \ - def __set__(self, object value): \ - CHECK_LOOP3(self.loop) \ - if value: \ - if not self._flags & 4: \ - return # ref is already True \ - if self._flags & 2: # ev_unref was called, undo \ - libev.ev_ref(self.loop._ptr) \ - self._flags &= ~6 # do not want unref, no outstanding unref \ - else: \ - if self._flags & 4: \ - return # ref is already False \ - self._flags |= 4 \ - if not self._flags & 2 and libev.ev_is_active(&self._watcher): \ - libev.ev_unref(self.loop._ptr) \ - self._flags |= 2 \ - \ - property callback: \ - \ - def __get__(self): \ - return self._callback \ - \ - def __set__(self, object callback): \ - if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None: \ - raise TypeError("Expected callable, not %r" % (callback, )) \ - self._callback = callback \ - \ - def stop(self): \ - CHECK_LOOP2(self.loop) \ - if self._flags & 2: \ - libev.ev_ref(self.loop._ptr) \ - self._flags &= ~2 \ - libev.ev_##TYPE##_stop(self.loop._ptr, &self._watcher) \ - self._callback = None \ - self.args = None \ - if self._flags & 1: \ - Py_DECREF(<PyObjectPtr>self) \ - self._flags &= ~1 \ - \ - property priority: \ - \ - def __get__(self): \ - return libev.ev_priority(&self._watcher) \ - \ - def __set__(self, int priority): \ - if libev.ev_is_active(&self._watcher): \ - raise AttributeError("Cannot set priority of an active watcher") \ - libev.ev_set_priority(&self._watcher, priority) \ - \ - def feed(self, int revents, object callback, *args): \ - CHECK_LOOP2(self.loop) \ - self.callback = callback \ - self.args = args \ - LIBEV_UNREF \ - libev.ev_feed_event(self.loop._ptr, &self._watcher, revents) \ - PYTHON_INCREF - -#define ACTIVE property active: \ - \ - def __get__(self): \ - return True if libev.ev_is_active(&self._watcher) else False - -#define START(TYPE) def start(self, object callback, *args): \ - CHECK_LOOP2(self.loop) \ - if callback is None: \ - raise TypeError('callback must be callable, not None') \ - self.callback = callback \ - self.args = args \ - LIBEV_UNREF \ - libev.ev_##TYPE##_start(self.loop._ptr, &self._watcher) \ - PYTHON_INCREF - - -#define PENDING \ - property pending: \ - \ - def __get__(self): \ - return True if libev.ev_is_pending(&self._watcher) else False - - - -#define WATCHER(TYPE) WATCHER_BASE(TYPE) \ - \ - START(TYPE) \ - \ - ACTIVE \ - \ - PENDING - - -#define COMMA , - - -#define INIT(TYPE, ARGS_INITIALIZERS, ARGS) \ - def __init__(self, loop loop ARGS_INITIALIZERS, ref=True, priority=None): \ - libev.ev_##TYPE##_init(&self._watcher, <void *>gevent_callback_##TYPE ARGS) \ - self.loop = loop \ - if ref: \ - self._flags = 0 \ - else: \ - self._flags = 4 \ - if priority is not None: \ - libev.ev_set_priority(&self._watcher, priority) - - -cdef public class watcher [object PyGeventWatcherObject, type PyGeventWatcher_Type]: - """Abstract base class for all the watchers""" - - def __repr__(self): - if Py_ReprEnter(<PyObjectPtr>self) != 0: - return "<...>" - try: - format = self._format() - result = "<%s at 0x%x%s" % (self.__class__.__name__, id(self), format) - if self.active: - result += " active" - if self.pending: - result += " pending" - if self.callback is not None: - result += " callback=%r" % (self.callback, ) - if self.args is not None: - result += " args=%r" % (self.args, ) - return result + ">" - finally: - Py_ReprLeave(<PyObjectPtr>self) - - def _format(self): - return '' - - -cdef public class io(watcher) [object PyGeventIOObject, type PyGeventIO_Type]: - - WATCHER_BASE(io) - - def start(self, object callback, *args, pass_events=False): - CHECK_LOOP2(self.loop) - if callback is None: - raise TypeError('callback must be callable, not None') - self.callback = callback - if pass_events: - self.args = (GEVENT_CORE_EVENTS, ) + args - else: - self.args = args - LIBEV_UNREF - libev.ev_io_start(self.loop._ptr, &self._watcher) - PYTHON_INCREF - - ACTIVE - - PENDING - -#ifdef _WIN32 - - def __init__(self, loop loop, libev.vfd_socket_t fd, int events, ref=True, priority=None): - if events & ~(libev.EV__IOFDSET | libev.EV_READ | libev.EV_WRITE): - raise ValueError('illegal event mask: %r' % events) - cdef int vfd = libev.vfd_open(fd) - libev.vfd_free(self._watcher.fd) - libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, vfd, events) - self.loop = loop - if ref: - self._flags = 0 - else: - self._flags = 4 - if priority is not None: - libev.ev_set_priority(&self._watcher, priority) - -#else - - def __init__(self, loop loop, int fd, int events, ref=True, priority=None): - if fd < 0: - raise ValueError('fd must be non-negative: %r' % fd) - if events & ~(libev.EV__IOFDSET | libev.EV_READ | libev.EV_WRITE): - raise ValueError('illegal event mask: %r' % events) - libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, fd, events) - self.loop = loop - if ref: - self._flags = 0 - else: - self._flags = 4 - if priority is not None: - libev.ev_set_priority(&self._watcher, priority) - -#endif - - property fd: - - def __get__(self): - return libev.vfd_get(self._watcher.fd) - - def __set__(self, long fd): - if libev.ev_is_active(&self._watcher): - raise AttributeError("'io' watcher attribute 'fd' is read-only while watcher is active") - cdef int vfd = libev.vfd_open(fd) - libev.vfd_free(self._watcher.fd) - libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, vfd, self._watcher.events) - - property events: - - def __get__(self): - return self._watcher.events - - def __set__(self, int events): - if libev.ev_is_active(&self._watcher): - raise AttributeError("'io' watcher attribute 'events' is read-only while watcher is active") - libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, self._watcher.fd, events) - - property events_str: - - def __get__(self): - return _events_to_str(self._watcher.events) - - def _format(self): - return ' fd=%s events=%s' % (self.fd, self.events_str) - -#ifdef _WIN32 - - def __cinit__(self): - self._watcher.fd = -1; - - def __dealloc__(self): - libev.vfd_free(self._watcher.fd) - -#endif - - -cdef public class timer(watcher) [object PyGeventTimerObject, type PyGeventTimer_Type]: - - WATCHER_BASE(timer) - - def start(self, object callback, *args, update=True): - CHECK_LOOP2(self.loop) - if callback is None: - raise TypeError('callback must be callable, not None') - self.callback = callback - self.args = args - LIBEV_UNREF - if update: - libev.ev_now_update(self.loop._ptr) - libev.ev_timer_start(self.loop._ptr, &self._watcher) - PYTHON_INCREF - - ACTIVE - - PENDING - - def __init__(self, loop loop, double after=0.0, double repeat=0.0, ref=True, priority=None): - if repeat < 0.0: - raise ValueError("repeat must be positive or zero: %r" % repeat) - libev.ev_timer_init(&self._watcher, <void *>gevent_callback_timer, after, repeat) - self.loop = loop - if ref: - self._flags = 0 - else: - self._flags = 4 - if priority is not None: - libev.ev_set_priority(&self._watcher, priority) - - property at: - - def __get__(self): - return self._watcher.at - - # QQQ: add 'after' and 'repeat' properties? - - def again(self, object callback, *args, update=True): - CHECK_LOOP2(self.loop) - self.callback = callback - self.args = args - LIBEV_UNREF - if update: - libev.ev_now_update(self.loop._ptr) - libev.ev_timer_again(self.loop._ptr, &self._watcher) - PYTHON_INCREF - - -cdef public class signal(watcher) [object PyGeventSignalObject, type PyGeventSignal_Type]: - - WATCHER(signal) - - def __init__(self, loop loop, int signalnum, ref=True, priority=None): - if signalnum < 1 or signalnum >= signalmodule.NSIG: - raise ValueError('illegal signal number: %r' % signalnum) - # still possible to crash on one of libev's asserts: - # 1) "libev: ev_signal_start called with illegal signal number" - # EV_NSIG might be different from signal.NSIG on some platforms - # 2) "libev: a signal must not be attached to two different loops" - # we probably could check that in LIBEV_EMBED mode, but not in general - libev.ev_signal_init(&self._watcher, <void *>gevent_callback_signal, signalnum) - self.loop = loop - if ref: - self._flags = 0 - else: - self._flags = 4 - if priority is not None: - libev.ev_set_priority(&self._watcher, priority) - - -cdef public class idle(watcher) [object PyGeventIdleObject, type PyGeventIdle_Type]: - - WATCHER(idle) - - INIT(idle,,) - - -cdef public class prepare(watcher) [object PyGeventPrepareObject, type PyGeventPrepare_Type]: - - WATCHER(prepare) - - INIT(prepare,,) - - -cdef public class check(watcher) [object PyGeventCheckObject, type PyGeventCheck_Type]: - - WATCHER(check) - - INIT(check,,) - - -cdef public class fork(watcher) [object PyGeventForkObject, type PyGeventFork_Type]: - - WATCHER(fork) - - INIT(fork,,) - - -cdef public class async(watcher) [object PyGeventAsyncObject, type PyGeventAsync_Type]: - - WATCHER_BASE(async) - - START(async) - - ACTIVE - - property pending: - - def __get__(self): - return True if libev.ev_async_pending(&self._watcher) else False - - INIT(async,,) - - def send(self): - CHECK_LOOP2(self.loop) - libev.ev_async_send(self.loop._ptr, &self._watcher) - -#ifdef _WIN32 -#else - -cdef public class child(watcher) [object PyGeventChildObject, type PyGeventChild_Type]: - - WATCHER(child) - - def __init__(self, loop loop, int pid, bint trace=0, ref=True): - if not loop.default: - raise TypeError('child watchers are only available on the default loop') - libev.gevent_install_sigchld_handler() - libev.ev_child_init(&self._watcher, <void *>gevent_callback_child, pid, trace) - self.loop = loop - if ref: - self._flags = 0 - else: - self._flags = 4 - - def _format(self): - return ' pid=%r rstatus=%r' % (self.pid, self.rstatus) - - property pid: - - def __get__(self): - return self._watcher.pid - - property rpid: - - def __get__(self): - return self._watcher.rpid - - def __set__(self, int value): - self._watcher.rpid = value - - property rstatus: - - def __get__(self): - return self._watcher.rstatus - - def __set__(self, int value): - self._watcher.rstatus = value - -#endif - - -cdef public class stat(watcher) [object PyGeventStatObject, type PyGeventStat_Type]: - - WATCHER(stat) - cdef readonly str path - cdef readonly bytes _paths - - def __init__(self, loop loop, str path, float interval=0.0, ref=True, priority=None): - self.path = path - cdef bytes paths - if isinstance(path, unicode): - # the famous Python3 filesystem encoding debacle hits us here. Can we do better? - # We must keep a reference to the encoded string so that its bytes don't get freed - # and overwritten, leading to strange errors from libev ("no such file or directory") - paths = (<unicode>path).encode(sys.getfilesystemencoding()) - self._paths = paths - else: - paths = <bytes>path - self._paths = paths - libev.ev_stat_init(&self._watcher, <void *>gevent_callback_stat, <char*>paths, interval) - self.loop = loop - if ref: - self._flags = 0 - else: - self._flags = 4 - if priority is not None: - libev.ev_set_priority(&self._watcher, priority) - - property attr: - - def __get__(self): - if not self._watcher.attr.st_nlink: - return - return _pystat_fromstructstat(&self._watcher.attr) - - property prev: - - def __get__(self): - if not self._watcher.prev.st_nlink: - return - return _pystat_fromstructstat(&self._watcher.prev) - - property interval: - - def __get__(self): - return self._watcher.interval - - -__SYSERR_CALLBACK = None - - -cdef void _syserr_cb(char* msg) with gil: - try: - __SYSERR_CALLBACK(msg, errno) - except: - set_syserr_cb(None) - print_exc = getattr(traceback, 'print_exc', None) - if print_exc is not None: - print_exc() - - -cpdef set_syserr_cb(callback): - global __SYSERR_CALLBACK - if callback is None: - libev.ev_set_syserr_cb(NULL) - __SYSERR_CALLBACK = None - elif callable(callback): - libev.ev_set_syserr_cb(<void *>_syserr_cb) - __SYSERR_CALLBACK = callback - else: - raise TypeError('Expected callable or None, got %r' % (callback, )) - - -#ifdef LIBEV_EMBED -LIBEV_EMBED = True -EV_USE_FLOOR = libev.EV_USE_FLOOR -EV_USE_CLOCK_SYSCALL = libev.EV_USE_CLOCK_SYSCALL -EV_USE_REALTIME = libev.EV_USE_REALTIME -EV_USE_MONOTONIC = libev.EV_USE_MONOTONIC -EV_USE_NANOSLEEP = libev.EV_USE_NANOSLEEP -EV_USE_INOTIFY = libev.EV_USE_INOTIFY -EV_USE_SIGNALFD = libev.EV_USE_SIGNALFD -EV_USE_EVENTFD = libev.EV_USE_EVENTFD -EV_USE_4HEAP = libev.EV_USE_4HEAP -#else -LIBEV_EMBED = False -#endif |