eventlet/eventlet/hubs/pyevent.py

   1 import sys
   2 import traceback
   3 import event
   4 import types
   5
   6 from eventlet.support import greenlets as greenlet, six
   7 from eventlet.hubs.hub import BaseHub, READ, WRITE
   8
   9
  10 class event_wrapper(object):
  11
  12     def __init__(self, impl=None, seconds=None):
  13         self.impl = impl
  14         self.seconds = seconds
  15
  16     def __repr__(self):
  17         if self.impl is not None:
  18             return repr(self.impl)
  19         else:
  20             return object.__repr__(self)
  21
  22     def __str__(self):
  23         if self.impl is not None:
  24             return str(self.impl)
  25         else:
  26             return object.__str__(self)
  27
  28     def cancel(self):
  29         if self.impl is not None:
  30             self.impl.delete()
  31             self.impl = None
  32
  33     @property
  34     def pending(self):
  35         return bool(self.impl and self.impl.pending())
  36
  37
  38 class Hub(BaseHub):
  39
  40     SYSTEM_EXCEPTIONS = (KeyboardInterrupt, SystemExit)
  41
  42     def __init__(self):
  43         super(Hub, self).__init__()
  44         event.init()
  45
  46         self.signal_exc_info = None
  47         self.signal(
  48             2,
  49             lambda signalnum, frame: self.greenlet.parent.throw(KeyboardInterrupt))
  50         self.events_to_add = []
  51
  52     def dispatch(self):
  53         loop = event.loop
  54         while True:
  55             for e in self.events_to_add:
  56                 if e is not None and e.impl is not None and e.seconds is not None:
  57                     e.impl.add(e.seconds)
  58                     e.seconds = None
  59             self.events_to_add = []
  60             result = loop()
  61
  62             if getattr(event, '__event_exc', None) is not None:
  63                 # only have to do this because of bug in event.loop
  64                 t = getattr(event, '__event_exc')
  65                 setattr(event, '__event_exc', None)
  66                 assert getattr(event, '__event_exc') is None
  67                 six.reraise(t[0], t[1], t[2])
  68
  69             if result != 0:
  70                 return result
  71
  72     def run(self):
  73         while True:
  74             try:
  75                 self.dispatch()
  76             except greenlet.GreenletExit:
  77                 break
  78             except self.SYSTEM_EXCEPTIONS:
  79                 raise
  80             except:
  81                 if self.signal_exc_info is not None:
  82                     self.schedule_call_global(
  83                         0, greenlet.getcurrent().parent.throw, *self.signal_exc_info)
  84                     self.signal_exc_info = None
  85                 else:
  86                     self.squelch_timer_exception(None, sys.exc_info())
  87
  88     def abort(self, wait=True):
  89         self.schedule_call_global(0, self.greenlet.throw, greenlet.GreenletExit)
  90         if wait:
  91             assert self.greenlet is not greenlet.getcurrent(
  92             ), "Can't abort with wait from inside the hub's greenlet."
  93             self.switch()
  94
  95     def _getrunning(self):
  96         return bool(self.greenlet)
  97
  98     def _setrunning(self, value):
  99         pass  # exists for compatibility with BaseHub
 100     running = property(_getrunning, _setrunning)
 101
 102     def add(self, evtype, fileno, real_cb, real_tb, mac):
 103         # this is stupid: pyevent won't call a callback unless it's a function,
 104         # so we have to force it to be one here
 105         if isinstance(real_cb, types.BuiltinMethodType):
 106             def cb(_d):
 107                 real_cb(_d)
 108         else:
 109             cb = real_cb
 110
 111         if evtype is READ:
 112             evt = event.read(fileno, cb, fileno)
 113         elif evtype is WRITE:
 114             evt = event.write(fileno, cb, fileno)
 115
 116         return super(Hub, self).add(evtype, fileno, evt, real_tb, mac)
 117
 118     def signal(self, signalnum, handler):
 119         def wrapper():
 120             try:
 121                 handler(signalnum, None)
 122             except:
 123                 self.signal_exc_info = sys.exc_info()
 124                 event.abort()
 125         return event_wrapper(event.signal(signalnum, wrapper))
 126
 127     def remove(self, listener):
 128         super(Hub, self).remove(listener)
 129         listener.cb.delete()
 130
 131     def remove_descriptor(self, fileno):
 132         for lcontainer in six.itervalues(self.listeners):
 133             listener = lcontainer.pop(fileno, None)
 134             if listener:
 135                 try:
 136                     listener.cb.delete()
 137                 except self.SYSTEM_EXCEPTIONS:
 138                     raise
 139                 except:
 140                     traceback.print_exc()
 141
 142     def schedule_call_local(self, seconds, cb, *args, **kwargs):
 143         current = greenlet.getcurrent()
 144         if current is self.greenlet:
 145             return self.schedule_call_global(seconds, cb, *args, **kwargs)
 146         event_impl = event.event(_scheduled_call_local, (cb, args, kwargs, current))
 147         wrapper = event_wrapper(event_impl, seconds=seconds)
 148         self.events_to_add.append(wrapper)
 149         return wrapper
 150
 151     schedule_call = schedule_call_local
 152
 153     def schedule_call_global(self, seconds, cb, *args, **kwargs):
 154         event_impl = event.event(_scheduled_call, (cb, args, kwargs))
 155         wrapper = event_wrapper(event_impl, seconds=seconds)
 156         self.events_to_add.append(wrapper)
 157         return wrapper
 158
 159     def _version_info(self):
 160         baseversion = event.__version__
 161         return baseversion
 162
 163
 164 def _scheduled_call(event_impl, handle, evtype, arg):
 165     cb, args, kwargs = arg
 166     try:
 167         cb(*args, **kwargs)
 168     finally:
 169         event_impl.delete()
 170
 171
 172 def _scheduled_call_local(event_impl, handle, evtype, arg):
 173     cb, args, kwargs, caller_greenlet = arg
 174     try:
 175         if not caller_greenlet.dead:
 176             cb(*args, **kwargs)
 177     finally:
 178         event_impl.delete()