Merge heads

serhiy-storchaka · serhiy-storchaka · commit 80d84c89ee8f · 2015-03-31T13:18:35.000+03:00
diff --git a/Doc/library/select.rst b/Doc/library/select.rst
@@ -249,6 +249,12 @@ object.
    returning. If *timeout* is omitted, -1, or :const:`None`, the call will
    block until there is an event for this poll object.
 
+   .. versionchanged:: 3.5
+      The function is now retried with a recomputed timeout when interrupted by
+      a signal, except if the signal handler raises an exception (see
+      :pep:`475` for the rationale), instead of raising
+      :exc:`InterruptedError`.
+
 
 .. _epoll-objects:
 
@@ -454,6 +460,12 @@ Kqueue Objects
    - max_events must be 0 or a positive integer
    - timeout in seconds (floats possible)
 
+   .. versionchanged:: 3.5
+      The function is now retried with a recomputed timeout when interrupted by
+      a signal, except if the signal handler raises an exception (see
+      :pep:`475` for the rationale), instead of raising
+      :exc:`InterruptedError`.
+
 
 .. _kevent-objects:
 
diff --git a/Doc/library/selectors.rst b/Doc/library/selectors.rst
@@ -159,6 +159,12 @@ below:
           timeout has elapsed if the current process receives a signal: in this
           case, an empty list will be returned.
 
+      .. versionchanged:: 3.5
+         The selector is now retried with a recomputed timeout when interrupted
+         by a signal if the signal handler did not raise an exception (see
+         :pep:`475` for the rationale), instead of returning an empty list
+         of events before the timeout.
+
    .. method:: close()
 
       Close the selector.
diff --git a/Doc/whatsnew/3.5.rst b/Doc/whatsnew/3.5.rst
@@ -619,9 +619,10 @@ Changes in the Python API
   instead of raising :exc:`InterruptedError` if the signal handler does not
   raise an exception:
 
-  - :func:`os.open`, :func:`open`
+  - :func:`open`, :func:`os.open`, :func:`io.open`
   - :func:`os.read`, :func:`os.write`
-  - :func:`select.select`, :func:`select.poll.poll`, :func:`select.epoll.poll`
+  - :func:`select.select`, :func:`select.poll.poll`, :func:`select.epoll.poll`,
+    :func:`select.kqueue.control`, :func:`select.devpoll.poll`
   - :func:`time.sleep`
 
 * Before Python 3.5, a :class:`datetime.time` object was considered to be false
diff --git a/Lib/selectors.py b/Lib/selectors.py
@@ -479,11 +479,10 @@ def select(self, timeout=None):
                 # devpoll() has a resolution of 1 millisecond, round away from
                 # zero to wait *at least* timeout seconds.
                 timeout = math.ceil(timeout * 1e3)
+
+            fd_event_list = self._devpoll.poll(timeout)
+
             ready = []
-            try:
-                fd_event_list = self._devpoll.poll(timeout)
-            except InterruptedError:
-                return ready
             for fd, event in fd_event_list:
                 events = 0
                 if event & ~select.POLLIN:
@@ -549,11 +548,9 @@ def unregister(self, fileobj):
         def select(self, timeout=None):
             timeout = None if timeout is None else max(timeout, 0)
             max_ev = len(self._fd_to_key)
+            kev_list = self._kqueue.control(None, max_ev, timeout)
+
             ready = []
-            try:
-                kev_list = self._kqueue.control(None, max_ev, timeout)
-            except InterruptedError:
-                return ready
             for kev in kev_list:
                 fd = kev.ident
                 flag = kev.filter
diff --git a/Lib/test/eintrdata/eintr_tester.py b/Lib/test/eintrdata/eintr_tester.py
@@ -315,8 +315,8 @@ class SelectEINTRTest(EINTRBaseTest):
     def test_select(self):
         t0 = time.monotonic()
         select.select([], [], [], self.sleep_time)
-        self.stop_alarm()
         dt = time.monotonic() - t0
+        self.stop_alarm()
         self.assertGreaterEqual(dt, self.sleep_time)
 
     @unittest.skipUnless(hasattr(select, 'poll'), 'need select.poll')
@@ -325,8 +325,8 @@ def test_poll(self):
 
         t0 = time.monotonic()
         poller.poll(self.sleep_time * 1e3)
-        self.stop_alarm()
         dt = time.monotonic() - t0
+        self.stop_alarm()
         self.assertGreaterEqual(dt, self.sleep_time)
 
     @unittest.skipUnless(hasattr(select, 'epoll'), 'need select.epoll')
@@ -336,8 +336,30 @@ def test_epoll(self):
 
         t0 = time.monotonic()
         poller.poll(self.sleep_time)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.assertGreaterEqual(dt, self.sleep_time)
+
+    @unittest.skipUnless(hasattr(select, 'kqueue'), 'need select.kqueue')
+    def test_kqueue(self):
+        kqueue = select.kqueue()
+        self.addCleanup(kqueue.close)
+
+        t0 = time.monotonic()
+        kqueue.control(None, 1, self.sleep_time)
+        dt = time.monotonic() - t0
         self.stop_alarm()
+        self.assertGreaterEqual(dt, self.sleep_time)
+
+    @unittest.skipUnless(hasattr(select, 'devpoll'), 'need select.devpoll')
+    def test_devpoll(self):
+        poller = select.devpoll()
+        self.addCleanup(poller.close)
+
+        t0 = time.monotonic()
+        poller.poll(self.sleep_time * 1e3)
         dt = time.monotonic() - t0
+        self.stop_alarm()
         self.assertGreaterEqual(dt, self.sleep_time)
 
 
diff --git a/Lib/test/test_selectors.py b/Lib/test/test_selectors.py
@@ -357,7 +357,35 @@ def test_timeout(self):
 
     @unittest.skipUnless(hasattr(signal, "alarm"),
                          "signal.alarm() required for this test")
-    def test_select_interrupt(self):
+    def test_select_interrupt_exc(self):
+        s = self.SELECTOR()
+        self.addCleanup(s.close)
+
+        rd, wr = self.make_socketpair()
+
+        class InterruptSelect(Exception):
+            pass
+
+        def handler(*args):
+            raise InterruptSelect
+
+        orig_alrm_handler = signal.signal(signal.SIGALRM, handler)
+        self.addCleanup(signal.signal, signal.SIGALRM, orig_alrm_handler)
+        self.addCleanup(signal.alarm, 0)
+
+        signal.alarm(1)
+
+        s.register(rd, selectors.EVENT_READ)
+        t = time()
+        # select() is interrupted by a signal which raises an exception
+        with self.assertRaises(InterruptSelect):
+            s.select(30)
+        # select() was interrupted before the timeout of 30 seconds
+        self.assertLess(time() - t, 5.0)
+
+    @unittest.skipUnless(hasattr(signal, "alarm"),
+                         "signal.alarm() required for this test")
+    def test_select_interrupt_noraise(self):
         s = self.SELECTOR()
         self.addCleanup(s.close)
 
@@ -371,8 +399,11 @@ def test_select_interrupt(self):
 
         s.register(rd, selectors.EVENT_READ)
         t = time()
-        self.assertFalse(s.select(2))
-        self.assertLess(time() - t, 2.5)
+        # select() is interrupted by a signal, but the signal handler doesn't
+        # raise an exception, so select() should by retries with a recomputed
+        # timeout
+        self.assertFalse(s.select(1.5))
+        self.assertGreaterEqual(time() - t, 1.0)
 
 
 class ScalableSelectorMixIn:
diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c
