Raise when a user attempts to run a loop within another loop

Author: 1st1

asyncio/base_events.py

@@ -394,13 +394,15 @@ def run_forever(self):
         self._check_closed()
         if self.is_running():
             raise RuntimeError('Event loop is running.')
+        if events._get_running_loop() is not None:
+            raise RuntimeError(
+                'Cannot run the event loop while another loop is running')
         self._set_coroutine_wrapper(self._debug)
         self._thread_id = threading.get_ident()
         if self._asyncgens is not None:
             old_agen_hooks = sys.get_asyncgen_hooks()
             sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
                                    finalizer=self._asyncgen_finalizer_hook)
-        old_loop = events._get_running_loop()
         try:
             events._set_running_loop(self)
             while True:
@@ -410,7 +412,7 @@ def run_forever(self):
         finally:
             self._stopping = False
             self._thread_id = None
-            events._set_running_loop(old_loop)
+            events._set_running_loop(None)
             self._set_coroutine_wrapper(False)
             if self._asyncgens is not None:
                 sys.set_asyncgen_hooks(*old_agen_hooks)

asyncio/events.py

@@ -658,8 +658,8 @@ def set_event_loop_policy(policy):
 def get_event_loop():
     """Return an asyncio event loop.
 
-    When called from coroutines, this function will always return the
-    running event loop.
+    When called from a coroutine or a callback (e.g. scheduled with call_soon
+    or similar API), this function will always return the running event loop.
 
     If there is no running event loop set, the function will return
     the result of `get_event_loop_policy().get_event_loop()` call.

tests/test_base_events.py

@@ -1694,5 +1694,23 @@ def stop_loop_coro(loop):
                          "took .* seconds$")
 
 
+class RunningLoopTests(unittest.TestCase):
+
+    def test_running_loop_within_a_loop(self):
+        @asyncio.coroutine
+        def runner(loop):
+            loop.run_forever()
+
+        loop = asyncio.new_event_loop()
+        outer_loop = asyncio.new_event_loop()
+        try:
+            with self.assertRaisesRegex(RuntimeError,
+                                        'while another loop is running'):
+                outer_loop.run_until_complete(runner(loop))
+        finally:
+            loop.close()
+            outer_loop.close()
+
+
 if __name__ == '__main__':
     unittest.main()