Python reactor.fireSystemEvent函数代码示例

 def test_subsequentBeforeTriggerFiresPriorBeforeDeferred(self):
     """
     If a trigger added to the C{'before'} phase of an event calls back a
     L{Deferred} returned by an earlier trigger in the C{'before'} phase of
     the same event, the remaining C{'before'} triggers for that event
     should be run and any further L{Deferred}s waited on before proceeding
     to the C{'during'} events.
     """
     eventType = 'test'
     events = []
     firstDeferred = Deferred()
     secondDeferred = Deferred()
     def firstBeforeTrigger():
         return firstDeferred
     def secondBeforeTrigger():
         firstDeferred.callback(None)
     def thirdBeforeTrigger():
         events.append('before')
         return secondDeferred
     def duringTrigger():
         events.append('during')
     self.addTrigger('before', eventType, firstBeforeTrigger)
     self.addTrigger('before', eventType, secondBeforeTrigger)
     self.addTrigger('before', eventType, thirdBeforeTrigger)
     self.addTrigger('during', eventType, duringTrigger)
     self.assertEqual(events, [])
     reactor.fireSystemEvent(eventType)
     self.assertEqual(events, ['before'])
     secondDeferred.callback(None)
     self.assertEqual(events, ['before', 'during'])

 def test_multipleBeforeReturnDeferred(self):
     """
     If more than one trigger added to the C{'before'} phase of an event
     return L{Deferred}s, the C{'during'} phase should be delayed until they
     are all called back.
     """
     firstDeferred = Deferred()
     secondDeferred = Deferred()
     eventType = 'test'
     events = []
     def firstBeforeTrigger():
         return firstDeferred
     def secondBeforeTrigger():
         return secondDeferred
     def duringTrigger():
         events.append('during')
     self.addTrigger('before', eventType, firstBeforeTrigger)
     self.addTrigger('before', eventType, secondBeforeTrigger)
     self.addTrigger('during', eventType, duringTrigger)
     self.assertEqual(events, [])
     reactor.fireSystemEvent(eventType)
     self.assertEqual(events, [])
     firstDeferred.callback(None)
     self.assertEqual(events, [])
     secondDeferred.callback(None)
     self.assertEqual(events, ['during'])

def signal_handler(signal, frame):
        print 'You pressed Ctrl+C'
        # As per here:
        # http://www.tornadoweb.org/documentation/twisted.html
        reactor.fireSystemEvent('shutdown')
        reactor.disconnectAll()
        sys.exit(0)

def exit_reactor(res):
    if reactor.running:
        #Manually firing shutdown triggers
        logging.info('Shutting down twisted reactor')
        reactor.fireSystemEvent('shutdown')
        reactor.stop()
    sys.exit(res)

 def start():
     try:
         OscInterface("Test", 8000)
     except:
         import traceback
         traceback.print_exc()
         print >> sys.stderr, "Caught exception during startup."
         reactor.fireSystemEvent('shutdown')

 def start():
     print "roam_node2 starting..."
     try:
         RoamNode()
     except:
         import traceback
         traceback.print_exc()
         print >> sys.stderr, "\nCaught exception during startup. Shutting down."
         reactor.fireSystemEvent('shutdown')

 def _addSystemEventTriggerTest(self, phase):
     eventType = 'test'
     events = []
     def trigger():
         events.append(None)
     self.addTrigger(phase, eventType, trigger)
     self.assertEqual(events, [])
     reactor.fireSystemEvent(eventType)
     self.assertEqual(events, [None])

 def _bail(self):
     from twisted.internet import reactor
     d = defer.Deferred()
     reactor.addSystemEventTrigger('after', 'shutdown',
                                   lambda: d.callback(None))
     reactor.fireSystemEvent('shutdown') # radix's suggestion
     # As long as TestCase does crap stuff with the reactor we need to
     # manually shutdown the reactor here, and that requires util.wait
     # :(
     # so that the shutdown event completes
     unittest.TestCase('mktemp')._wait(d)

    def _bail(self):
        from twisted.internet import reactor
        d = defer.Deferred()
        reactor.addSystemEventTrigger('after', 'shutdown', lambda: d.callback(None))
        reactor.fireSystemEvent('shutdown') # radix's suggestion

        treactor = interfaces.IReactorThreads(reactor, None)
        if treactor is not None:
            treactor.suggestThreadPoolSize(0)

        util.wait(d) # so that the shutdown event completes

    def test_interactionBetweenDifferentEvents(self):
        """
        L{IReactorCore.fireSystemEvent} should behave the same way for a
        particular system event regardless of whether Deferreds are being
        waited on for a different system event.
        """
        events = []

        firstEvent = "first-event"
        firstDeferred = Deferred()

        def beforeFirstEvent():
            events.append(("before", "first"))
            return firstDeferred

        def afterFirstEvent():
            events.append(("after", "first"))

        secondEvent = "second-event"
        secondDeferred = Deferred()

        def beforeSecondEvent():
            events.append(("before", "second"))
            return secondDeferred

        def afterSecondEvent():
            events.append(("after", "second"))

        self.addTrigger("before", firstEvent, beforeFirstEvent)
        self.addTrigger("after", firstEvent, afterFirstEvent)
        self.addTrigger("before", secondEvent, beforeSecondEvent)
        self.addTrigger("after", secondEvent, afterSecondEvent)

        self.assertEqual(events, [])

        # After this, firstEvent should be stuck before 'during' waiting for
        # firstDeferred.
        reactor.fireSystemEvent(firstEvent)
        self.assertEqual(events, [("before", "first")])

        # After this, secondEvent should be stuck before 'during' waiting for
        # secondDeferred.
        reactor.fireSystemEvent(secondEvent)
        self.assertEqual(events, [("before", "first"), ("before", "second")])

        # After this, firstEvent should have finished completely, but
        # secondEvent should be at the same place.
        firstDeferred.callback(None)
        self.assertEqual(events, [("before", "first"), ("before", "second"), ("after", "first")])

        # After this, secondEvent should have finished completely.
        secondDeferred.callback(None)
        self.assertEqual(events, [("before", "first"), ("before", "second"), ("after", "first"), ("after", "second")])

 def test_beforePreceedsDuring(self):
     """
     L{IReactorCore.addSystemEventTrigger} should call triggers added to the
     C{'before'} phase before it calls triggers added to the C{'during'}
     phase.
     """
     eventType = 'test'
     events = []
     def beforeTrigger():
         events.append('before')
     def duringTrigger():
         events.append('during')
     self.addTrigger('before', eventType, beforeTrigger)
     self.addTrigger('during', eventType, duringTrigger)
     self.assertEqual(events, [])
     reactor.fireSystemEvent(eventType)
     self.assertEqual(events, ['before', 'during'])

 def test_duringPreceedsAfter(self):
     """
     L{IReactorCore.addSystemEventTrigger} should call triggers added to the
     C{'during'} phase before it calls triggers added to the C{'after'}
     phase.
     """
     eventType = 'test'
     events = []
     def duringTrigger():
         events.append('during')
     def afterTrigger():
         events.append('after')
     self.addTrigger('during', eventType, duringTrigger)
     self.addTrigger('after', eventType, afterTrigger)
     self.assertEqual(events, [])
     reactor.fireSystemEvent(eventType)
     self.assertEqual(events, ['during', 'after'])

 def test_removeSystemEventTrigger(self):
     """
     A trigger removed with L{IReactorCore.removeSystemEventTrigger} should
     not be called when the event fires.
     """
     eventType = 'test'
     events = []
     def firstBeforeTrigger():
         events.append('first')
     def secondBeforeTrigger():
         events.append('second')
     self.addTrigger('before', eventType, firstBeforeTrigger)
     self.removeTrigger(
         self.addTrigger('before', eventType, secondBeforeTrigger))
     self.assertEqual(events, [])
     reactor.fireSystemEvent(eventType)
     self.assertEqual(events, ['first'])

    def test_removeSystemEventTrigger(self):
        """
        A trigger removed with L{IReactorCore.removeSystemEventTrigger} should
        not be called when the event fires.
        """
        eventType = "test"
        events = []

        def firstBeforeTrigger():
            events.append("first")

        def secondBeforeTrigger():
            events.append("second")

        self.addTrigger("before", eventType, firstBeforeTrigger)
        self.removeTrigger(self.addTrigger("before", eventType, secondBeforeTrigger))
        self.assertEqual(events, [])
        reactor.fireSystemEvent(eventType)
        self.assertEqual(events, ["first"])

 def test_beforeReturnsDeferred(self):
     """
     If a trigger added to the C{'before'} phase of an event returns a
     L{Deferred}, the C{'during'} phase should be delayed until it is called
     back.
     """
     triggerDeferred = Deferred()
     eventType = 'test'
     events = []
     def beforeTrigger():
         return triggerDeferred
     def duringTrigger():
         events.append('during')
     self.addTrigger('before', eventType, beforeTrigger)
     self.addTrigger('during', eventType, duringTrigger)
     self.assertEqual(events, [])
     reactor.fireSystemEvent(eventType)
     self.assertEqual(events, [])
     triggerDeferred.callback(None)
     self.assertEqual(events, ['during'])