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(), "Can't abort with wait from inside the hub's greenlet."
  92             self.switch()
  93
  94     def _getrunning(self):
  95         return bool(self.greenlet)
  96
  97     def _setrunning(self, value):
  98         pass  # exists for compatibility with BaseHub
  99     running = property(_getrunning, _setrunning)
 100
 101     def add(self, evtype, fileno, real_cb, real_tb, mac):
 102         # this is stupid: pyevent won't call a callback unless it's a function,
 103         # so we have to force it to be one here
 104         if isinstance(real_cb, types.BuiltinMethodType):
 105             def cb(_d):
 106                 real_cb(_d)
 107         else:
 108             cb = real_cb
 109
 110         if evtype is READ:
 111             evt = event.read(fileno, cb, fileno)
 112         elif evtype is WRITE:
 113             evt = event.write(fileno, cb, fileno)
 114
 115         return super(Hub, self).add(evtype, fileno, evt, real_tb, mac)
 116
 117     def signal(self, signalnum, handler):
 118         def wrapper():
 119             try:
 120                 handler(signalnum, None)
 121             except:
 122                 self.signal_exc_info = sys.exc_info()
 123                 event.abort()
 124         return event_wrapper(event.signal(signalnum, wrapper))
 125
 126     def remove(self, listener):
 127         super(Hub, self).remove(listener)
 128         listener.cb.delete()
 129
 130     def remove_descriptor(self, fileno):
 131         for lcontainer in six.itervalues(self.listeners):
 132             listener = lcontainer.pop(fileno, None)
 133             if listener:
 134                 try:
 135                     listener.cb.delete()
 136                 except self.SYSTEM_EXCEPTIONS:
 137                     raise
 138                 except:
 139                     traceback.print_exc()
 140
 141     def schedule_call_local(self, seconds, cb, *args, **kwargs):
 142         current = greenlet.getcurrent()
 143         if current is self.greenlet:
 144             return self.schedule_call_global(seconds, cb, *args, **kwargs)
 145         event_impl = event.event(_scheduled_call_local, (cb, args, kwargs, current))
 146         wrapper = event_wrapper(event_impl, seconds=seconds)
 147         self.events_to_add.append(wrapper)
 148         return wrapper
 149
 150     schedule_call = schedule_call_local
 151
 152     def schedule_call_global(self, seconds, cb, *args, **kwargs):
 153         event_impl = event.event(_scheduled_call, (cb, args, kwargs))
 154         wrapper = event_wrapper(event_impl, seconds=seconds)
 155         self.events_to_add.append(wrapper)
 156         return wrapper
 157
 158     def _version_info(self):
 159         baseversion = event.__version__
 160         return baseversion
 161
 162
 163 def _scheduled_call(event_impl, handle, evtype, arg):
 164     cb, args, kwargs = arg
 165     try:
 166         cb(*args, **kwargs)
 167     finally:
 168         event_impl.delete()
 169
 170
 171 def _scheduled_call_local(event_impl, handle, evtype, arg):
 172     cb, args, kwargs, caller_greenlet = arg
 173     try:
 174         if not caller_greenlet.dead:
 175             cb(*args, **kwargs)
 176     finally:
 177         event_impl.delete()