def _clean(self): """Clean up any junk in the reactor. Will always iterate the reactor a number of times equal to ``Spinner._OBLIGATORY_REACTOR_ITERATIONS``. This is to work around bugs in various Twisted APIs where a Deferred fires but still leaves work (e.g. cancelling a call, actually closing a connection) for the reactor to do. """ for i in range(self._OBLIGATORY_REACTOR_ITERATIONS): self._reactor.iterate(0) junk = [] for delayed_call in self._reactor.getDelayedCalls(): delayed_call.cancel() junk.append(delayed_call) for selectable in self._reactor.removeAll(): # Twisted sends a 'KILL' signal to selectables that provide # IProcessTransport. Since only _dumbwin32proc processes do this, # we aren't going to bother. junk.append(selectable) if IReactorThreads.providedBy(self._reactor): if self._reactor.threadpool is not None: self._reactor._stopThreadPool() self._junk.extend(junk) return junk
def test_distantDelayedCall(self): """ Scheduling a delayed call at a point in the extreme future does not prevent normal reactor operation. """ reactor = self.buildReactor() if IReactorThreads.providedBy(reactor): def eventSource(reactor, event): msg( format="Thread-based event-source scheduling %(event)r", event=event ) reactor.callFromThread(event) else: raise SkipTest( "Do not know how to synthesize non-time event to " "stop the test" ) # Pick a pretty big delay. delayedCall = reactor.callLater(2 ** 128 + 1, lambda: None) def stop(): msg("Stopping the reactor") reactor.stop() # Use repeated invocation of the event source to set up the call to stop # the reactor. This makes it more likely at least one normal iteration # will take place with the delayed call in place before the slightly # different reactor shutdown logic alters things. eventSource(reactor, lambda: eventSource(reactor, stop)) # Run the reactor directly, without a timeout. A timeout would # interfere with the purpose of this test, which is to have the timeout # passed to the reactor's doIterate implementation (potentially) be # very, very large. Hopefully the event source defined above will work # and cause the reactor to stop. reactor.run() # The reactor almost surely stopped before the delayed call # fired... right? self.assertTrue(delayedCall.active()) self.assertIn(delayedCall, reactor.getDelayedCalls())
def test_distantDelayedCall(self): """ Scheduling a delayed call at a point in the extreme future does not prevent normal reactor operation. """ reactor = self.buildReactor() if IReactorThreads.providedBy(reactor): def eventSource(reactor, event): msg(format="Thread-based event-source scheduling %(event)r", event=event) reactor.callFromThread(event) else: raise SkipTest("Do not know how to synthesize non-time event to " "stop the test") # Pick a pretty big delay. delayedCall = reactor.callLater(2 ** 128 + 1, lambda: None) def stop(): msg("Stopping the reactor") reactor.stop() # Use repeated invocation of the event source to set up the call to stop # the reactor. This makes it more likely at least one normal iteration # will take place with the delayed call in place before the slightly # different reactor shutdown logic alters things. eventSource(reactor, lambda: eventSource(reactor, stop)) # Run the reactor directly, without a timeout. A timeout would # interfere with the purpose of this test, which is to have the timeout # passed to the reactor's doIterate implementation (potentially) be # very, very large. Hopefully the event source defined above will work # and cause the reactor to stop. reactor.run() # The reactor almost surely stopped before the delayed call # fired... right? self.assertTrue(delayedCall.active()) self.assertIn(delayedCall, reactor.getDelayedCalls())