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 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 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 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 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 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():
try:
OscInterface("Test", 8000)
except:
import traceback
traceback.print_exc()
print >> sys.stderr, "Caught exception during startup."
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 _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 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 _bail(self):
from twisted.internet import reactor, utils
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)
utils.suppressWarnings(lambda: util.wait(d),
(['ignore', 'Do NOT use wait.*'], {}))
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 _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 _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 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 _bail(self):
from twisted.internet import reactor, utils
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)
# 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
utils.suppressWarnings(lambda: util.wait(d),
(['ignore', 'Do NOT use wait.*'], {}))
def _bail(self):
from twisted.internet import reactor, utils
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)
# 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
utils.suppressWarnings(lambda: util.wait(d),
(['ignore', 'Do NOT use wait.*'], {}))
def start_server_and_listen(use_auth, analytics_manager, max_tries=5):
"""The primary entry point for launching the daemon.
Args:
use_auth: set to true to enable http authentication
analytics_manager: to send analytics
"""
analytics_manager.send_server_startup()
daemon_server = DaemonServer(analytics_manager)
try:
yield daemon_server.start(use_auth)
analytics_manager.send_server_startup_success()
except Exception as e:
log.exception('Failed to startup')
yield daemon_server.stop()
analytics_manager.send_server_startup_error(str(e))
reactor.fireSystemEvent("shutdown")
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_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_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_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_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_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 start_listening(self):
from twisted.internet import reactor, error as tx_error
try:
self.server = self.get_server_factory()
if self.server.use_ssl:
log.info("Using SSL")
self.listening_port = reactor.listenSSL(
conf.settings['api_port'],
self.server,
self.server.options,
interface=conf.settings['api_host'])
else:
log.info("Not using SSL")
self.listening_port = reactor.listenTCP(
conf.settings['api_port'],
self.server,
interface=conf.settings['api_host'])
log.info("lbrynet API listening on TCP %s:%i",
conf.settings['api_host'], conf.settings['api_port'])
yield self.setup()
self.analytics_manager.send_server_startup_success()
except tx_error.CannotListenError:
log.error(
'lbrynet API failed to bind TCP %s:%i for listening. Daemon is already running or this port is '
'already in use by another application.',
conf.settings['api_host'], conf.settings['api_port'])
reactor.fireSystemEvent("shutdown")
except defer.CancelledError:
log.info("shutting down before finished starting")
reactor.fireSystemEvent("shutdown")
except Exception as err:
self.analytics_manager.send_server_startup_error(str(err))
log.exception('Failed to start lbrynet-daemon')
reactor.fireSystemEvent("shutdown")
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 start_listening(self):
from twisted.internet import reactor, error as tx_error
try:
self.server = self.get_server_factory()
self.listening_port = reactor.listenTCP(
conf.settings['api_port'], self.server, interface=conf.settings['api_host']
)
log.info("lbrynet API listening on TCP %s:%i", conf.settings['api_host'], conf.settings['api_port'])
yield self.setup()
self.analytics_manager.send_server_startup_success()
except tx_error.CannotListenError:
log.error('lbrynet API failed to bind TCP %s:%i for listening', conf.settings['api_host'],
conf.settings['api_port'])
reactor.fireSystemEvent("shutdown")
except defer.CancelledError:
log.info("shutting down before finished starting")
reactor.fireSystemEvent("shutdown")
except Exception as err:
self.analytics_manager.send_server_startup_error(str(err))
log.exception('Failed to start lbrynet-daemon')
reactor.fireSystemEvent("shutdown")
import tornado.ioloop
import tornado.web
import tornado.platform.twisted
tornado.platform.twisted.install()
from twisted.internet import reactor
from internals.commandRegistry import CommandRegistry
from connectors import irc, jabber
from commands import shutdown, deploy
if __name__ == "__main__":
import config
reg = CommandRegistry.getRegistry()
if reg.websinks:
application = tornado.web.Application(reg.websinks)
p = getattr(config, 'webport', 8808)
application.listen(p)
try:
print "Starting loop"
tornado.ioloop.IOLoop.instance().start()
except:
print "Stopping loop ... shutdown"
reactor.fireSystemEvent('shutdown')
print "Disconnect all"
reactor.disconnectAll()
print "Actual stop"
tornado.ioloop.IOLoop.instance().stop()
print "Stopped"
def clientConnectionFailed(self, connector, reason):
print("connection failed: {}".format(reason))
reactor.fireSystemEvent('shutdown')
reactor.disconnectAll()
tornado.ioloop.IOLoop.instance().stop()
def going_away(registry, user, instruction, match):
reactor.fireSystemEvent('shutdown')
reactor.disconnectAll()
tornado.ioloop.IOLoop.instance().stop()
return {'success': True, 'answer': "So long and thanks for all the fish."}
def run(self):
import objectfactory
import objectid
import keymap
pygame.mixer.Sound('spin.ogg').play(-1)
game_world = objectfactory.ObjectFactory.from_id(objectid.world_id)
client_proto = ClientProtocol(game_world)
reactor.listenUDP(self.client_port, client_proto)
reactor.fireSystemEvent('startup')
fps = 30
clock = pygame.time.Clock()
sequence_number = 0
keys = keymap.KeyMap()
active = True
try:
while active:
delta_t = clock.tick(fps)
msg = [sequence_number]
sequence_number += 1
keys.read_keys(pygame.key.get_pressed())
keys.to_network(msg)
msg = map(str, msg)
msg = ','.join(msg)
client_proto.transport.write(msg, (self.host, self.host_port))
reactor.iterate(0)
if client_proto.our_monkey == None:
continue
events = []
for event in pygame.event.get():
events.append(event)
if event.type == pygame.QUIT:
active = False
elif event.type == pygame.KEYDOWN:
if event.unicode == 'q':
active = False
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
zoom = 0.1
glScale(zoom, zoom, 1)
# center camera on monkey
mx, my = client_proto.our_monkey.body.position
glTranslate(-mx, -my, 0)
game_world.tree_render()
game_world.play_sounds()
pygame.display.flip()
except Exception as e:
print e
pygame.mixer.stop()
reactor.fireSystemEvent('shutdown')
def blockMeNow(self):
global lst
print json.dumps(lst)
reactor.fireSystemEvent('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)
def exit_callback():
log.msg("Exiting due to timeout (--exit-timeout/-t)")
reactor.fireSystemEvent('shutdown')
#reactor.stop()
sys.exit(12)
def _bootstrap_complete():
# do some things after bootstrap
# e.g. provide a way to alert the BridgeManager
# that this bridge has completed bootstrap
reactor.fireSystemEvent('bootstrap')
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')
def _shutdown_by_ros(self, why):
reactor.fireSystemEvent('shutdown')
def shutdown_by_ros(why):
reactor.fireSystemEvent('shutdown')
def stop(self):
if reactor.running:
log.info("Stopping the reactor")
reactor.fireSystemEvent("shutdown")
def _shutdown_by_ros(self, *args):
"""
ROS shutdown callback. Sends a signal to reactor to shutdown.
"""
reactor.fireSystemEvent('shutdown')
def _bootstrap_complete():
# do some things after bootstrap
# e.g. provide a way to alert the BridgeManager
# that this bridge has completed bootstrap
reactor.fireSystemEvent('bootstrap')
def clientConnectionFailed(self, connector, reason):
print("connection failed: {}".format(reason))
reactor.fireSystemEvent('shutdown')
reactor.disconnectAll()
tornado.ioloop.IOLoop.instance().stop()
def start():
try:
t = TouchOscInterface()
default = rospy.get_param("~load_default", False)
handlers = rospy.get_param("~handlers", None)
loaded_handlers = {}
if handlers:
rospy.loginfo("Adding handlers from configuration")
for handler in handlers:
params = rospy.get_param("~" + handler)
HandlerClass = load_handler(params['pkg'], params['class'])
try:
aliases = [handler] + params['tabpage_aliases']
except KeyError:
aliases = [handler]
pass
rospy.loginfo("Adding %s handler with names %s" %
(handler, aliases))
loaded_handlers[handler] = HandlerClass(
t, handler, aliases)
t.register_handler(loaded_handlers[handler])
if default:
names = set()
default_handlers = {}
for tabpage in t.tabpage_handlers.itervalues():
[names.add(n) for n in tabpage.tabpage_names]
layout_file = rospy.get_param("layout_file", None)
layout_path = rospy.get_param("layout_path", None)
layouts = rospy.get_param("layouts", None)
if not layout_file and not layout_path:
rospy.logfatal(
"""Default set, but layout_file and layout_path
were not given, default tabpage will not operate""")
if layout_path and not layouts:
rospy.logfatal("""layout_path given, but no layouts
listed, rososc will not operate""")
if layout_path and layouts:
for layout in layouts:
source = pytouchosc.Layout.createFromExisting(
os.path.join(layout_path, layout))
for tp in source.getTabpageNames():
if tp not in names:
names.add(tp)
default_handlers[tp] = DefaultTabpageHandler(
t, source.getTabpage(tp))
t.register_handler(default_handlers[tp])
if layout_file:
source = pytouchosc.Layout.createFromExisting(layout_file)
for tp in source.getTabpageNames():
if tp not in names:
names.add(tp)
default_handlers[tp] = DefaultTabpageHandler(
t, source.getTabpage(tp))
t.register_handler(default_handlers[tp])
t.initialize_tabpages()
except:
import traceback
traceback.print_exc()
print >> sys.stderr, "Caught exception during startup. Shutting down."
reactor.fireSystemEvent('shutdown')
def start():
try:
t = TouchOscInterface()
default = rospy.get_param("~load_default", False)
handlers = rospy.get_param("~handlers", None)
loaded_handlers = {}
if handlers:
rospy.loginfo("Adding handlers from configuration")
for handler in handlers:
params = rospy.get_param("~" + handler)
HandlerClass = load_handler(params['pkg'],
params['class'])
try:
aliases = [handler] + params['tabpage_aliases']
except KeyError:
aliases = [handler]
pass
rospy.loginfo("Adding %s handler with names %s" % (handler, aliases))
loaded_handlers[handler] = HandlerClass(t,
handler,
aliases)
t.register_handler(loaded_handlers[handler])
if default:
names = set()
default_handlers = {}
for tabpage in t.tabpage_handlers.itervalues():
[names.add(n) for n in tabpage.tabpage_names]
layout_file = rospy.get_param("layout_file", None)
layout_path = rospy.get_param("layout_path", None)
layouts = rospy.get_param("layouts", None)
if not layout_file and not layout_path:
rospy.logfatal("""Default set, but layout_file and layout_path
were not given, default tabpage will not operate""")
if layout_path and not layouts:
rospy.logfatal("""layout_path given, but no layouts
listed, rososc will not operate""")
if layout_path and layouts:
for layout in layouts:
source = pytouchosc.Layout.createFromExisting(os.path.join(layout_path,
layout))
for tp in source.getTabpageNames():
if tp not in names:
names.add(tp)
default_handlers[tp] = DefaultTabpageHandler(t, source.getTabpage(tp))
t.register_handler(default_handlers[tp])
if layout_file:
source = pytouchosc.Layout.createFromExisting(layout_file)
for tp in source.getTabpageNames():
if tp not in names:
names.add(tp)
default_handlers[tp] = DefaultTabpageHandler(t, source.getTabpage(tp))
t.register_handler(default_handlers[tp])
t.initialize_tabpages()
except:
import traceback
traceback.print_exc()
print >> sys.stderr, "Caught exception during startup. Shutting down."
reactor.fireSystemEvent('shutdown')
