diff options
| author | Victor Stinner <victor.stinner@gmail.com> | 2014-11-19 02:35:57 +0100 |
|---|---|---|
| committer | Victor Stinner <victor.stinner@gmail.com> | 2014-11-19 02:35:57 +0100 |
| commit | 9a21a7c342ad64f87fbdeba2008001249f75e197 (patch) | |
| tree | 0502f2df8d4e7a5ed54c01f3772e8d66079e7e98 | |
| parent | 6d4367e018173557ec11de6805b4800c240ad1ba (diff) | |
| download | aioeventlet-9a21a7c342ad64f87fbdeba2008001249f75e197.tar.gz | |
update FIXMEs
| -rw-r--r-- | README | 4 | ||||
| -rw-r--r-- | aiogreen/__init__.py | 21 |
2 files changed, 14 insertions, 11 deletions
@@ -25,3 +25,7 @@ Todo: * Test with Python 2 and 3 * Test with Trollius and asyncio * Glue to ease debug: keep traceback between Handle, coroutine and greenthread +* run_in_executor(): use eventlet.tpool as the default executor? + It avoids the dependency to concurrent.futures. aiogreen is written as a + temporary solution to switch from eventlet to asyncio. So it may be better to + use directly concurrent.futures to reduce the usage of eventlet? diff --git a/aiogreen/__init__.py b/aiogreen/__init__.py index 5eff72f..7409805 100644 --- a/aiogreen/__init__.py +++ b/aiogreen/__init__.py @@ -121,7 +121,7 @@ class _Scheduler(object): return # the greenthread will be called before the next timer, - # cancel the timer + # cancel the timer if any self._unschedule_timer_unlocked() # it's safe to call spawn_n() with the lock: @@ -132,7 +132,8 @@ class _Scheduler(object): if (self._greenthread is not None # If the greenthread is running, there is not need to cancel it. # Only cancel the greenthread if it didn't start or if it already - # finished (which should not occur, but it doesn't hurt to cancel it). + # finished (which should not occur, but it doesn't hurt to cancel it + # in this case). and not self._greenthread): # cancel the greenthread: replace its run method self._greenthread.run = noop @@ -141,6 +142,7 @@ class _Scheduler(object): def schedule_timer(self, when): with self._lock: if self._greenthread is not None: + # already scheduled return delay = when - self._loop.time() @@ -160,7 +162,9 @@ class _Scheduler(object): hub = self._loop._hub greenthread = eventlet.greenthread.GreenThread(hub.greenlet) - # schedule_call_global() doesn't call the function immediatly + # it is safe to call schedule_call_global() with the lock: + # it does not switch to _run_once() immediatly (it creates a timer + # and adds it a the "next timers"). greentimer = hub.schedule_call_global(delay, greenthread.switch, self._loop._run_once, (), {}) @@ -243,8 +247,6 @@ class EventLoop(BaseEventLoop): handle = self._ready.popleft() if handle._cancelled: continue - # FIXME: what happens if this method is interrupted, - # and _schedule() is called? handle._run() self._scheduler.stop() @@ -279,11 +281,8 @@ class EventLoop(BaseEventLoop): def _timer_handle_cancelled(self, handle): super(EventLoop, self)._timer_handle_cancelled(handle) - # FIXME: reschedule the _run_once() timer - - # FIXME: run_in_executor(): use eventlet.tpool as the default executor? - # It avoids the dependency to concurrent.futures, but later it would be - # better to use concurrent.futures. So... What is the best? + # FIXME: optimization, reschedule _run_once() if the cancelled timer + # was the next timer def stop(self): if self._stop_event is None: @@ -340,7 +339,7 @@ class EventLoop(BaseEventLoop): return future.result() def _throwback(self): - # FIXME: do something? + # FIXME: do something with the FD in this case? pass def _add_fd(self, event_type, fd, callback, args): |