def do_customEvent(self, reactor_handler, event_root): class CustomHandler: did_custom = False did_init = False def __init__(self, *handlers): self.handlers = handlers def on_reactor_init(self, event): self.did_init = True def on_custom(self, event): self.did_custom = True class CustomInvoker(CustomHandler): def on_reactor_init(self, event): h = event_root(event) event.dispatch(h, CUSTOM) self.did_init = True child = CustomInvoker() root = CustomHandler(child) reactor = Reactor() reactor_handler(reactor, root) reactor.run() assert root.did_init assert child.did_init assert root.did_custom assert child.did_custom
def __init__(self, *args): self.reactor = Reactor(*args) self.reactor.global_handler = self self.io = IOHandler() self.loop = tornado.ioloop.IOLoop.instance() self.count = 0 self.reactor.start() self.reactor.process()
def protonj_to_protonc(self, count): if (not self.proton_j_available): raise Skipped("ProtonJ not found") rh = ReceiveHandler(count) r = Reactor(rh) r.run() rh.java_thread.join() assert (rh.java_thread.result == 0) for i in range(1, count): assert (rh.messages[i - 1] == ("message-" + str(i)))
def protonj_to_protonc(self, count): if (not self.proton_j_available): raise Skipped("ProtonJ not found") rh = ReceiveHandler(count) r = Reactor(rh) r.run() rh.java_thread.join() assert(rh.java_thread.result == 0) for i in range(1, count): assert(rh.messages[i-1] == ("message-" + str(i)))
class SourceTest(TestCase): def setUp(self): self.source = Source("test-%s") self.server = Server(self.source) self.reactor = Reactor(self.server) def tearDown(self): pass def testReceiver(self, count=1): self.server.max_connections = 1 self.source.limit = count oself = self class Counter: def __init__(self): self.received = 0 self.receiver = None self.open_event = False def on_link_remote_open(self, event): self.open_event = True def on_message(self, event): assert event.message.body == oself.source.template % self.received self.received += 1 if self.received == count: self.receiver.stop(event.reactor) counter = Counter() rcv = Receiver("//localhost:%s" % PORT, Processor(counter)) counter.receiver = rcv self.reactor.handler.add(rcv) rcv.start(self.reactor) self.reactor.run() assert counter.received == count assert counter.open_event def testReceiver150(self): self.testReceiver(150) # This doesn't seem to work for any value > 150! This is a proton # bug that needs to be isolated and pushed upstream. Enable and # run under valgrind for more details. def XXXtestReceiver151(self): self.testReceiver(151)
def main(): parser = ArgumentParser() parser.add_argument("-n", "--host", default="127.0.0.1", help="network hostname") parser.add_argument("-p", "--port", default="5680", help="network port") args = parser.parse_args() Reactor(BizLogic(args)).run()
def setUp(self): import platform if platform.python_implementation() != "Jython": # Exception propagation does not work currently for CPython raise SkipTest() self.reactor = Reactor()
def protonc_to_protonj(self, count): if (not self.proton_j_available): raise Skipped("ProtonJ not found") port = free_tcp_port() java_thread = JavaThread("recv", port, count) java_thread.start() # Give the Java thread time to spin up a JVM and start listening # XXX: would be better to parse the stdout output for a message time.sleep(1) sh = SendHandler('127.0.0.1:' + str(port), count) r = Reactor(sh) r.run() java_thread.join() assert(java_thread.result == 0)
def protonc_to_protonj(self, count): if (not self.proton_j_available): raise Skipped("ProtonJ not found") port = free_tcp_port() java_thread = JavaThread("recv", port, count) java_thread.start() # Give the Java thread time to spin up a JVM and start listening # XXX: would be better to parse the stdout output for a message time.sleep(1) sh = SendHandler('127.0.0.1:' + str(port), count) r = Reactor(sh) r.run() java_thread.join() assert (java_thread.result == 0)
class AgentTest(TestCase): def setUp(self): fake_tether = Tether(None, "", None) self.agent = Agent(fake_tether, self) self.server = Server(self.agent) self.reactor = Reactor(self.server) self.samples = 0 def tearDown(self): if self.server.acceptor: self.server.acceptor.close() def sample(self, stats): stats["samples"] = self.samples self.samples += 1 def testAgent(self, count=1, frequency=10): self.server.max_connections = 1 self.agent.sampler.frequency = frequency class Counter(Timeout): def __init__(self): self.received = 0 def on_message(self, event): m = event.message assert event.message.body["samples"] == self.received, ( event.message.body, self.received) self.received += 1 if self.received == count: rcv.stop(event.reactor) self.cancel() def on_timer_task(self, event): rcv.stop(event.reactor) counter = Counter() rcv = Receiver("//localhost:%s" % PORT, Processor(counter)) rcv.start(self.reactor) counter.set_timeout(self.reactor, 20) self.reactor.run() assert counter.cancelled, "Sampling timed out" def testAgent10M100F(self): self.testAgent(10, 100)
def main(): parser = ArgumentParser() parser.add_argument("-n", "--host", default="127.0.0.1", help="network hostname") parser.add_argument("-p", "--port", default="6000", help="network port") parser.add_argument("-l", "--level", default="warning", help="logging level") args = parser.parse_args() logging.getLogger().setLevel(getattr(logging, args.level.upper())) Reactor(Monitor(args)).run()
def __init__(self): class FakeTether: def __init__(self): self.address = None self.agent = None self.agent_type = None self.agent = Agent(FakeTether(), self) self.server = Server(self.agent) self.reactor = Reactor(self.server) self.samples = 0
def main(): parser = ArgumentParser() parser.add_argument("rate", type=float, help="Barks per second") parser.add_argument("-n", "--host", default="127.0.0.1", help="hostname of outboxes") args = parser.parse_args() Reactor(AutoBark(args.rate, args.host)).run()
class AgentTest(TestCase): def setUp(self): fake_tether = Tether(None, "", None) self.agent = Agent(fake_tether, self) self.server = Server(self.agent) self.reactor = Reactor(self.server) self.samples = 0 def tearDown(self): if self.server.acceptor: self.server.acceptor.close() def sample(self, stats): stats["samples"] = self.samples self.samples += 1 def testAgent(self, count=1, frequency=10): self.server.max_connections = 1 self.agent.sampler.frequency = frequency class Counter(Timeout): def __init__(self): self.received = 0 def on_message(self, event): m = event.message assert event.message.body["samples"] == self.received, (event.message.body, self.received) self.received += 1 if self.received == count: rcv.stop(event.reactor) self.cancel() def on_timer_task(self, event): rcv.stop(event.reactor) counter = Counter() rcv = Receiver("//localhost:%s" % PORT, Processor(counter)) rcv.start(self.reactor) counter.set_timeout(self.reactor, 20) self.reactor.run() assert counter.cancelled, "Sampling timed out" def testAgent10M100F(self): self.testAgent(10, 100)
def test_reactorHandlerCycling(self, n=0): class CustomHandler(Handler): UNSET = 999999999 def __init__(self): self.offset = len(traceback.extract_stack()) def on_reactor_init(self, event): self.depth = len(traceback.extract_stack()) def reset(self): self.depth = self.UNSET @property def init_depth(self): d = self.depth - self.offset return d custom = CustomHandler() reactor = Reactor() reactor.handler = custom for i in range(n): h = reactor.handler reactor.handler = h custom.reset() reactor.run() assert custom.init_depth < 50, "Unexpectedly long traceback for a simple handler"
def main(): parser = ArgumentParser(prog="listen") parser.add_argument("user") parser.add_argument("-n", "--host", default="127.0.0.1", help="hostname of inboxes") args = parser.parse_args() users = common.load_data("users.pickle") assert args.user in users Reactor(GetBarks(args.user, args.host)).run()
class AgentTest: def __init__(self): class FakeTether: def __init__(self): self.address = None self.agent = None self.agent_type = None self.agent = Agent(FakeTether(), self) self.server = Server(self.agent) self.reactor = Reactor(self.server) self.samples = 0 def teardown(self): self.server.acceptor.close() def sample(self, stats): stats["samples"] = self.samples self.samples += 1 def testAgent(self, count=1, frequency=10): self.server.max_connections = 1 self.agent.sampler.frequency = frequency class Counter: def __init__(self): self.received = 0 def on_message(self, event): assert event.message.body["samples"] == self.received, (event.message.body, self.received) self.received += 1 if self.received == count: rcv.stop(event.reactor) rcv = Receiver("//localhost:%s" % PORT, Processor(Counter())) rcv.start(self.reactor) self.reactor.run() def testAgent10M100F(self): self.testAgent(10, 100)
def setUp(self): self.sink = Sink() self.server = Server(self.sink) self.reactor = Reactor(self.server)
class SinkTest(TestCase): def setUp(self): self.sink = Sink() self.server = Server(self.sink) self.reactor = Reactor(self.server) def tearDown(self): pass def testSender(self, count=1): self.server.max_connections = 1 snd = Sender("//localhost:%s" % PORT) self.reactor.handler.add(snd) snd.start(self.reactor) for i in range(count): snd.send("test-%s" % i) snd.close() self.reactor.run() assert len(self.sink.messages) == count for i in range(count): assert self.sink.messages[i] == "test-%s" % i, self.sink.messages[i] def testSender4K(self): self.testSender(4*1024) def testSampler(self, count=1, frequency=10): self.server.max_connections = 1 oself = self class Gen(Timeout): def __init__(self): self.sent = 0 def on_sample(self, event): event.link.send(Message("test-%s" % self.sent)) self.sent += 1 if self.sent >= count: event.link.close() self.cancel() def on_timer_task(self, event): snd.stop(event.reactor) gen = Gen(); snd = Sender("//localhost:%s" % PORT, Sampler(gen, frequency)) self.reactor.handler.add(snd) gen.set_timeout(self.reactor, 2) snd.start(self.reactor) self.reactor.run() assert gen.cancelled, "Sampling timed out" assert len(self.sink.messages) == count, len(self.sink.messages) for i in range(count): assert self.sink.messages[i] == "test-%s" % i def testSampler100M100F(self): self.testSampler(100, 100) def testLinker(self, address_count=1, message_count=1): self.server.max_connections = address_count linker = Linker() linker.start(self.reactor) for i in range(address_count): for j in range(message_count): snd = linker.sender("//localhost:%s/%s" % (PORT, i)) assert len(linker.senders) == i + 1 snd.send(dict(i=i, j=j)) linker.close() self.reactor.run() by_addr = dict((i,[]) for i in range(address_count)) for m in self.sink.messages: by_addr[m["i"]].append(m) for addr, msgs in by_addr.iteritems(): self.assertSequenceEqual(msgs, list(sorted(msgs, key=lambda x:(x["i"],x["j"])))) self.assertEqual(len(self.sink.messages), address_count*message_count) def testLinker2A1M(self): self.testLinker(2, 1) def testLinker4A1M(self): self.testLinker(4, 1) def testLinker16A1M(self): self.testLinker(16, 1) def testLinker1A2M(self): self.testLinker(1, 2) def testLinker1A4M(self): self.testLinker(1, 4) def testLinker1A16M(self): self.testLinker(1, 16) def testLinker2A2M(self): self.testLinker(2, 2) def testLinker4A4M(self): self.testLinker(4, 4) def testLinker16A16M(self): self.testLinker(16, 16)
def setUp(self): self.source = Source("test-%s") self.server = Server(self.source) self.reactor = Reactor(self.server)
snd = event.sender if snd.credit > 0: dlv = snd.send(self.message) dlv.settle() snd.close() snd.session.close() snd.connection.close() class Program: def __init__(self, hostname, content): self.hostname = hostname self.content = content def on_reactor_init(self, event): # You can use the connection method to create AMQP connections. # This connection's handler is the Send object. All the events # for this connection will go to the Send object instead of # going to the reactor. If you were to omit the Send object, # all the events would go to the reactor. event.reactor.connection(Send(self.hostname, Message(self.content))) args = sys.argv[1:] hostname = args.pop() if args else "localhost" content = args.pop() if args else "Hello World!" r = Reactor(Program(hostname, content)) r.run()
def setUp(self): self.reactor = Reactor()
dlv = snd.send(self.message) dlv.settle() snd.close() snd.session.close() snd.connection.close() class Program: def __init__(self, url, content): self.url = url self.content = content def on_reactor_init(self, event): # You can use the connection method to create AMQP connections. # This connection's handler is the Send object. All the events # for this connection will go to the Send object instead of # going to the reactor. If you were to omit the Send object, # all the events would go to the reactor. event.reactor.connection_to_host( self.url.host, self.url.port, Send(Message(self.content), self.url.path)) args = sys.argv[1:] url = Url(args.pop() if args else "localhost:5672/examples") content = args.pop() if args else "Hello World!" r = Reactor(Program(url, content)) r.run()
class SinkTest(TestCase): def setUp(self): self.sink = Sink() self.server = Server(self.sink) self.reactor = Reactor(self.server) def tearDown(self): pass def testSender(self, count=1): self.server.max_connections = 1 snd = Sender("//localhost:%s" % PORT) self.reactor.handler.add(snd) snd.start(self.reactor) for i in range(count): snd.send("test-%s" % i) snd.close() self.reactor.run() assert len(self.sink.messages) == count for i in range(count): assert self.sink.messages[i] == "test-%s" % i, self.sink.messages[i] def testSender4K(self): self.testSender(4 * 1024) def testSampler(self, count=1, frequency=10): self.server.max_connections = 1 oself = self class Gen(Timeout): def __init__(self): self.sent = 0 def on_sample(self, event): event.link.send(Message("test-%s" % self.sent)) self.sent += 1 if self.sent >= count: event.link.close() self.cancel() def on_timer_task(self, event): snd.stop(event.reactor) gen = Gen() snd = Sender("//localhost:%s" % PORT, Sampler(gen, frequency)) self.reactor.handler.add(snd) gen.set_timeout(self.reactor, 2) snd.start(self.reactor) self.reactor.run() assert gen.cancelled, "Sampling timed out" assert len(self.sink.messages) == count, len(self.sink.messages) for i in range(count): assert self.sink.messages[i] == "test-%s" % i def testSampler100M100F(self): self.testSampler(100, 100) def testLinker(self, address_count=1, message_count=1): self.server.max_connections = address_count linker = Linker() linker.start(self.reactor) for i in range(address_count): for j in range(message_count): snd = linker.sender("//localhost:%s/%s" % (PORT, i)) assert len(linker.senders) == i + 1 snd.send(dict(i=i, j=j)) linker.close() self.reactor.run() by_addr = dict((i, []) for i in range(address_count)) for m in self.sink.messages: by_addr[m["i"]].append(m) for addr, msgs in by_addr.iteritems(): self.assertSequenceEqual(msgs, list(sorted(msgs, key=lambda x: (x["i"], x["j"])))) self.assertEqual(len(self.sink.messages), address_count * message_count) def testLinker2A1M(self): self.testLinker(2, 1) def testLinker4A1M(self): self.testLinker(4, 1) def testLinker16A1M(self): self.testLinker(16, 1) def testLinker1A2M(self): self.testLinker(1, 2) def testLinker1A4M(self): self.testLinker(1, 4) def testLinker1A16M(self): self.testLinker(1, 16) def testLinker2A2M(self): self.testLinker(2, 2) def testLinker4A4M(self): self.testLinker(4, 4) def testLinker16A16M(self): self.testLinker(16, 16)
print "LOG:", name, event class Program: def on_reactor_init(self, event): print "Hello, World!" def on_reactor_final(self, event): print "Goodbye, World!" # You can pass multiple handlers to a reactor when you construct it. # Each of these handlers will see every event the reactor sees. By # combining this with on_unhandled, you can log each event that goes # to the reactor. r = Reactor(Program(), Logger()) r.run() # Note that if you wanted to add the logger later, you could also # write the above as below. All arguments to the reactor are just # added to the default handler for the reactor. def logging_enabled(): return False r = Reactor(Program()) if logging_enabled(): r.handler.add(Logger()) r.run()
class TornadoApp: def __init__(self, *args): self.reactor = Reactor(*args) self.reactor.global_handler = self self.io = IOHandler() self.loop = tornado.ioloop.IOLoop.instance() self.count = 0 self.reactor.start() self.reactor.process() def on_reactor_quiesced(self, event): event.reactor.yield_() def on_unhandled(self, name, event): event.dispatch(self.io) def _events(self, sel): events = self.loop.ERROR if sel.reading: events |= self.loop.READ if sel.writing: events |= self.loop.WRITE return events def _schedule(self, sel): if sel.deadline: self.loop.add_timeout(sel.deadline, lambda: self.expired(sel)) def _expired(self, sel): sel.expired() def _process(self): self.reactor.process() if not self.reactor.quiesced: self.loop.add_callback(self._process) def _callback(self, sel, events): if self.loop.READ & events: sel.readable() if self.loop.WRITE & events: sel.writable() self._process() def on_selectable_init(self, event): sel = event.context if sel.fileno() >= 0: self.loop.add_handler(sel.fileno(), lambda fd, events: self._callback(sel, events), self._events(sel)) self._schedule(sel) self.count += 1 def on_selectable_updated(self, event): sel = event.context if sel.fileno() > 0: self.loop.update_handler(sel.fileno(), self._events(sel)) self._schedule(sel) def on_selectable_final(self, event): sel = event.context if sel.fileno() > 0: self.loop.remove_handler(sel.fileno()) sel.release() self.count -= 1 if self.count == 0: self.loop.add_callback(self._stop) def _stop(self): self.reactor.stop() self.loop.stop()
def setup(self): self.reactor = Reactor()
from __future__ import print_function import time from proton.reactor import Reactor # Events know how to dispatch themselves to handlers. By combining # this with on_unhandled, you can provide a kind of inheritance # between handlers using delegation. class Hello: def on_reactor_init(self, event): print("Hello, World!") class Goodbye: def on_reactor_final(self, event): print("Goodbye, World!") class Program: def __init__(self, *delegates): self.delegates = delegates def on_unhandled(self, name, event): for d in self.delegates: event.dispatch(d) r = Reactor(Program(Hello(), Goodbye())) r.run()
class Logger: def on_unhandled(self, name, event): print("LOG:", name, event) class Task: def on_timer_task(self, event): print("Mission accomplished!") class Program: def on_reactor_init(self, event): print("Hello, World!") event.reactor.schedule(0, Task()) def on_reactor_final(self, event): print("Goodbye, World!") r = Reactor(Program()) # In addition to having a regular handler, the reactor also has a # global handler that sees every event. By adding the Logger to the # global handler instead of the regular handler, we can log every # single event that occurs in the system regardless of whether or not # there are specific handlers associated with the objects that are the # target of those events. r.global_handler.add(Logger()) r.run()
class ExceptionTest(Test): def setup(self): self.reactor = Reactor() def test_reactor_final(self): self.reactor.global_handler = BarfOnFinal() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_global_set(self): self.reactor.global_handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_global_add(self): self.reactor.global_handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_reactor_set(self): self.reactor.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_reactor_add(self): self.reactor.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_connection(self): self.reactor.connection(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_connection_set(self): c = self.reactor.connection() c.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_connection_add(self): c = self.reactor.connection() c.handler = object() c.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_session_set(self): c = self.reactor.connection() s = c.session() s.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_session_add(self): c = self.reactor.connection() s = c.session() s.handler = object() s.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_link_set(self): c = self.reactor.connection() s = c.session() l = s.sender("xxx") l.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_link_add(self): c = self.reactor.connection() s = c.session() l = s.sender("xxx") l.handler = object() l.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_schedule(self): self.reactor.schedule(0, BarfOnTask()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass
#!/usr/bin/python import time from proton.reactor import Reactor class World: def on_reactor_init(self, event): print "World!" class Goodbye: def on_reactor_final(self, event): print "Goodbye, World!" class Hello: def __init__(self): self.handlers = [World(), Goodbye()] # The parent handler always receives the event first. def on_reactor_init(self, event): print "Hello", r = Reactor(Hello()) r.run()
class HandlerDerivationTest(Test): def setUp(self): import platform if platform.python_implementation() != "Jython": # Exception propagation does not work currently for CPython raise SkipTest() self.reactor = Reactor() def wrong_exception(self): import sys ex = sys.exc_info() assert False, " Unexpected exception " + str(ex[1]) def test_reactor_final_derived(self): h = BarfOnFinalDerived() self.reactor.global_handler = h try: self.reactor.run() assert False, "expected to barf" except Barf: pass except: self.wrong_exception() def test_reactor_final_py_child_py(self): class APoorExcuseForAHandler: def __init__(self): self.handlers = [BarfOnFinal()] self.reactor.global_handler = APoorExcuseForAHandler() try: self.reactor.run() assert False, "expected to barf" except Barf: pass except: self.wrong_exception() def test_reactor_final_py_child_derived(self): class APoorExcuseForAHandler: def __init__(self): self.handlers = [BarfOnFinalDerived()] self.reactor.global_handler = APoorExcuseForAHandler() try: self.reactor.run() assert False, "expected to barf" except Barf: pass except: self.wrong_exception() def test_reactor_final_derived_child_derived(self): class APoorExcuseForAHandler(CHandshaker): def __init__(self): CHandshaker.__init__(self) self.handlers = [BarfOnFinalDerived()] self.reactor.global_handler = APoorExcuseForAHandler() try: self.reactor.run() assert False, "expected to barf" except Barf: pass except: self.wrong_exception() def test_reactor_final_derived_child_py(self): class APoorExcuseForAHandler(CHandshaker): def __init__(self): CHandshaker.__init__(self) self.handlers = [BarfOnFinal()] self.reactor.global_handler = APoorExcuseForAHandler() try: self.reactor.run() assert False, "expected to barf" except Barf: pass except: self.wrong_exception() def test_reactor_init_derived(self): h = BarfOnFinalDerived() self.reactor.global_handler = h try: self.reactor.run() assert False, "expected to barf" except: assert h.init, "excpected the init" def test_reactor_init_py_child_py(self): h = BarfOnFinal() class APoorExcuseForAHandler: def __init__(self): self.handlers = [h] self.reactor.global_handler = APoorExcuseForAHandler() try: self.reactor.run() assert False, "expected to barf" except: assert h.init, "excpected the init" def test_reactor_init_py_child_derived(self): h = BarfOnFinalDerived() class APoorExcuseForAHandler: def __init__(self): self.handlers = [h] self.reactor.global_handler = APoorExcuseForAHandler() try: self.reactor.run() assert False, "expected to barf" except: assert h.init, "excpected the init" def test_reactor_init_derived_child_derived(self): h = BarfOnFinalDerived() class APoorExcuseForAHandler(CHandshaker): def __init__(self): CHandshaker.__init__(self) self.handlers = [h] self.reactor.global_handler = APoorExcuseForAHandler() try: self.reactor.run() assert False, "expected to barf" except: assert h.init, "excpected the init" def test_reactor_init_derived_child_py(self): h = BarfOnFinal() class APoorExcuseForAHandler(CHandshaker): def __init__(self): CHandshaker.__init__(self) self.handlers = [h] self.reactor.global_handler = APoorExcuseForAHandler() try: self.reactor.run() assert False, "expected to barf" except: assert h.init, "excpected the init"
class ExceptionTest(Test): def setUp(self): self.reactor = Reactor() def test_reactor_final(self): self.reactor.global_handler = BarfOnFinal() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_global_set(self): self.reactor.global_handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_global_add(self): self.reactor.global_handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_reactor_set(self): self.reactor.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_reactor_add(self): self.reactor.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_connection(self): self.reactor.connection(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_connection_set(self): c = self.reactor.connection() c.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_connection_add(self): c = self.reactor.connection() c.handler = object() c.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_session_set(self): c = self.reactor.connection() s = c.session() s.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_session_add(self): c = self.reactor.connection() s = c.session() s.handler = object() s.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_link_set(self): c = self.reactor.connection() s = c.session() l = s.sender("xxx") l.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_link_add(self): c = self.reactor.connection() s = c.session() l = s.sender("xxx") l.handler = object() l.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_schedule(self): self.reactor.schedule(0, BarfOnTask()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_schedule_many_nothings(self): class Nothing: results = [] def on_timer_task(self, event): self.results.append(None) num = 12345 for a in range(num): self.reactor.schedule(0, Nothing()) self.reactor.run() assert len(Nothing.results) == num def test_schedule_many_nothing_refs(self): class Nothing: results = [] def on_timer_task(self, event): self.results.append(None) num = 12345 tasks = [] for a in range(num): tasks.append(self.reactor.schedule(0, Nothing())) self.reactor.run() assert len(Nothing.results) == num def test_schedule_many_nothing_refs_cancel_before_run(self): class Nothing: results = [] def on_timer_task(self, event): self.results.append(None) num = 12345 tasks = [] for a in range(num): tasks.append(self.reactor.schedule(0, Nothing())) for task in tasks: task.cancel() self.reactor.run() assert len(Nothing.results) == 0 def test_schedule_cancel(self): barf = self.reactor.schedule(10, BarfOnTask()) class CancelBarf: def __init__(self, barf): self.barf = barf def on_timer_task(self, event): self.barf.cancel() pass self.reactor.schedule(0, CancelBarf(barf)) now = self.reactor.mark() try: self.reactor.run() elapsed = self.reactor.mark() - now assert elapsed < 10, "expected cancelled task to not delay the reactor by %s" % elapsed except Barf: assert False, "expected barf to be cancelled" def test_schedule_cancel_many(self): num = 12345 barfs = set() for a in range(num): barf = self.reactor.schedule(10*(a+1), BarfOnTask()) class CancelBarf: def __init__(self, barf): self.barf = barf def on_timer_task(self, event): self.barf.cancel() barfs.discard(self.barf) pass self.reactor.schedule(0, CancelBarf(barf)) barfs.add(barf) now = self.reactor.mark() try: self.reactor.run() elapsed = self.reactor.mark() - now assert elapsed < num, "expected cancelled task to not delay the reactor by %s" % elapsed assert not barfs, "expected all barfs to be discarded" except Barf: assert False, "expected barf to be cancelled"
def setUp(self): fake_tether = Tether(None, "", None) self.agent = Agent(fake_tether, self) self.server = Server(self.agent) self.reactor = Reactor(self.server) self.samples = 0
class TornadoApp: def __init__(self, *args): self.reactor = Reactor(*args) self.reactor.global_handler = self self.io = IOHandler() self.loop = tornado.ioloop.IOLoop.instance() self.count = 0 self.reactor.start() self.reactor.process() def on_reactor_quiesced(self, event): event.reactor.yield_() def on_unhandled(self, name, event): event.dispatch(self.io) def _events(self, sel): events = self.loop.ERROR if sel.reading: events |= self.loop.READ if sel.writing: events |= self.loop.WRITE return events def _schedule(self, sel): if sel.deadline: self.loop.add_timeout(sel.deadline, lambda: self.expired(sel)) def _expired(self, sel): sel.expired() def _process(self): self.reactor.process() if not self.reactor.quiesced: self.loop.add_callback(self._process) def _callback(self, sel, events): if self.loop.READ & events: sel.readable() if self.loop.WRITE & events: sel.writable() self._process() def on_selectable_init(self, event): sel = event.context if sel.fileno() >= 0: self.loop.add_handler( sel.fileno(), lambda fd, events: self._callback(sel, events), self._events(sel)) self._schedule(sel) self.count += 1 def on_selectable_updated(self, event): sel = event.context if sel.fileno() > 0: self.loop.update_handler(sel.fileno(), self._events(sel)) self._schedule(sel) def on_selectable_final(self, event): sel = event.context if sel.fileno() > 0: self.loop.remove_handler(sel.fileno()) sel.release() self.count -= 1 if self.count == 0: self.loop.add_callback(self._stop) def _stop(self): self.reactor.stop() self.loop.stop()
class ExceptionTest(Test): def setup(self): self.reactor = Reactor() def test_reactor_final(self): self.reactor.global_handler = BarfOnFinal() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_global_set(self): self.reactor.global_handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_global_add(self): self.reactor.global_handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_reactor_set(self): self.reactor.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_reactor_add(self): self.reactor.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_connection(self): self.reactor.connection(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_connection_set(self): c = self.reactor.connection() c.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_connection_add(self): c = self.reactor.connection() c.handler = object() c.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_session_set(self): c = self.reactor.connection() s = c.session() s.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_session_add(self): c = self.reactor.connection() s = c.session() s.handler = object() s.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_link_set(self): c = self.reactor.connection() s = c.session() l = s.sender("xxx") l.handler = BarfOnInit() try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_link_add(self): c = self.reactor.connection() s = c.session() l = s.sender("xxx") l.handler = object() l.handler.add(BarfOnInit()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_schedule(self): self.reactor.schedule(0, BarfOnTask()) try: self.reactor.run() assert False, "expected to barf" except Barf: pass def test_schedule_many_nothings(self): class Nothing: results = [] def on_timer_task(self, event): self.results.append(None) num = 12345 for a in range(num): self.reactor.schedule(0, Nothing()) self.reactor.run() assert len(Nothing.results) == num def test_schedule_many_nothing_refs(self): class Nothing: results = [] def on_timer_task(self, event): self.results.append(None) num = 12345 tasks = [] for a in range(num): tasks.append(self.reactor.schedule(0, Nothing())) self.reactor.run() assert len(Nothing.results) == num def test_schedule_many_nothing_refs_cancel_before_run(self): class Nothing: results = [] def on_timer_task(self, event): self.results.append(None) num = 12345 tasks = [] for a in range(num): tasks.append(self.reactor.schedule(0, Nothing())) for task in tasks: task.cancel() self.reactor.run() assert len(Nothing.results) == 0 def test_schedule_cancel(self): barf = self.reactor.schedule(10, BarfOnTask()) class CancelBarf: def __init__(self, barf): self.barf = barf def on_timer_task(self, event): self.barf.cancel() pass self.reactor.schedule(0, CancelBarf(barf)) now = self.reactor.mark() try: self.reactor.run() elapsed = self.reactor.mark() - now assert elapsed < 10, "expected cancelled task to not delay the reactor by %s" % elapsed except Barf: assert False, "expected barf to be cancelled" def test_schedule_cancel_many(self): num = 12345 barfs = set() for a in range(num): barf = self.reactor.schedule(10 * (a + 1), BarfOnTask()) class CancelBarf: def __init__(self, barf): self.barf = barf def on_timer_task(self, event): self.barf.cancel() barfs.discard(self.barf) pass self.reactor.schedule(0, CancelBarf(barf)) barfs.add(barf) now = self.reactor.mark() try: self.reactor.run() elapsed = self.reactor.mark() - now assert elapsed < num, "expected cancelled task to not delay the reactor by %s" % elapsed assert not barfs, "expected all barfs to be discarded" except Barf: assert False, "expected barf to be cancelled"
from proton.reactor import Reactor class Program: def on_reactor_init(self, event): self.start = time.time() print "Hello, World!" # We can schedule a task event for some point in the future. # This will cause the reactor to stick around until it has a # chance to process the event. # The first argument is the delay. The second argument is the # handler for the event. We are just using self for now, but # we could pass in another object if we wanted. task = event.reactor.schedule(1.0, self) # We can ignore the task if we want to, but we can also use it # to pass stuff to the handler. task.something_to_say = "Yay" def on_timer_task(self, event): task = event.context # xxx: don't have a task property on event yet print task.something_to_say, "my task is complete!" def on_reactor_final(self, event): print "Goodbye, World! (after %s long seconds)" % (time.time() - self.start) r = Reactor(Program()) r.run()
def on_reactor_init(self, event): # You can use the connection method to create AMQP connections. # This connection's handler is the Send object. All the events # for this connection will go to the Send object instead of # going to the reactor. If you were to omit the Send object, # all the events would go to the reactor. event.reactor.connection_to_host(self.url.host, self.url.port, Perfy(self.node, self.count)) _usage = """Usage: %prog [options]""" parser = optparse.OptionParser(usage=_usage) parser.add_option("-a", dest="server", type="string", default="amqp://0.0.0.0:5672", help="The address of the server [amqp://0.0.0.0:5672]") parser.add_option("--node", type='string', default='amq.topic', help='Name of source/target node') parser.add_option("--count", type='int', default=100, help='Send N messages (send forever if N==0)') opts, _ = parser.parse_args(args=sys.argv) r = Reactor(Program(Url(opts.server), opts.node, opts.count)) r.run()