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'])

    def test_wsgi(self):
        """
        The I{--wsgi} option takes the fully-qualifed Python name of a WSGI
        application object and creates a L{WSGIResource} at the root which
        serves that application.
        """
        options = Options()
        options.parseOptions(['--wsgi', __name__ + '.application'])
        root = options['root']
        self.assertTrue(root, WSGIResource)
        self.assertIdentical(root._reactor, reactor)
        self.assertTrue(isinstance(root._threadpool, ThreadPool))
        self.assertIdentical(root._application, application)

        # The threadpool should start and stop with the reactor.
        self.assertFalse(root._threadpool.started)
        reactor.fireSystemEvent('startup')
        self.assertTrue(root._threadpool.started)
        self.assertFalse(root._threadpool.joined)
        reactor.fireSystemEvent('shutdown')
        self.assertTrue(root._threadpool.joined)

    def test_system_events_triggered(self):
        batons = list()
        stub_pipeline_provider = StubPipelineProvider(batons.append)
        self.runtime_environment.resource_manager.register('pipeline.test_pipeline', stub_pipeline_provider)
        
        provider = system_events_provider.SystemEventsProvider()

        configuration_manager = self.runtime_environment.configuration_manager

        for event_type in 'startup', 'shutdown':
            configuration_manager.set('system-events.%s.name' % event_type, 'test_pipeline')

        provider.configure(self.runtime_environment)

        self.runtime_environment.dependency_manager.resolve_initial_states()

        # wait a reactor iteration so the startup event is triggered
        yield util.wait(0)
        self.assertEquals(batons, [dict(event_type='startup')])
        batons[:] = list()

        # trigger the shutdown event, which should give our pipeline a baton
        reactor.fireSystemEvent('shutdown')
        self.assertEquals(batons, [dict(event_type='shutdown')])

 def stop(self):
     if reactor.running:
         log.info("Stopping the reactor")
         reactor.fireSystemEvent("shutdown")

 def exit_callback():
     log.msg("Exiting due to timeout (--exit-timeout/-t)")
     reactor.fireSystemEvent('shutdown')
     #reactor.stop()
     sys.exit(12)

      client.keys.from_network(msg)


  def iterate(self, step=0):
    self.reactor.iterate(step)

  def broadcast(self, msg):
    for address in list(self.active):
      client = self.active[address]
      client.time_to_live -= 1

      if client.time_to_live == 0:
        self.removed_monkeys.append(client.monkey)
        del self.active[address]
        continue

      client_id = client.monkey.player_id
      client_tag = str(client_id)+','
      self.transport.write(client_tag + msg, address)

  def shutdown(self):
    self.reactor.fireSystemEvent('shutdown')

# Singleton
Server = Server(reactor)
reactor.listenUDP(8007, Server)
reactor.fireSystemEvent('startup')