1135 lines
38 KiB
Plaintext
1135 lines
38 KiB
Plaintext
# 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
|