def test_async_rpc_success(self):
handler_results = []
sender_results = []
def handler(x):
handler_results.append(x)
return x ** 2
self.peer.accept_rpc("service", 0, 0, "method", handler)
backend.pause_for(TIMEOUT)
rpcs = []
rpcs.append(self.sender.send_rpc("service", 0, "method", (1,), {}))
rpcs.append(self.sender.send_rpc("service", 0, "method", (2,), {}))
rpcs.append(self.sender.send_rpc("service", 0, "method", (3,), {}))
rpcs.append(self.sender.send_rpc("service", 0, "method", (4,), {}))
while rpcs:
rpc = junction.wait_any(rpcs, TIMEOUT)
rpcs.remove(rpc)
sender_results.append(rpc.value)
self.assertEqual(handler_results, [1, 2, 3, 4])
self.assertEqual(sender_results, [1, 4, 9, 16])
def test_downed_recipient_cancels_the_hub_sender_during_chunked_request(self):
global PORT
hub = junction.Hub(("127.0.0.1", PORT), [])
PORT += 2
triggered = [False]
@hub.accept_rpc('service', 0, 0, 'method')
def handle(chunks):
for item in chunks:
pass
return "all done"
hub.start()
hub2 = junction.Hub(("127.0.0.1", PORT), [("127.0.0.1", PORT - 2)])
PORT += 2
hub2.start()
hub2.wait_connected()
def gen():
try:
while 1:
yield None
backend.pause_for(TIMEOUT)
finally:
triggered[0] = True
rpc = hub2.send_rpc('service', 0, 'method', (gen(),))
hub = [hub]
backend.schedule_in(TIMEOUT * 4, self.kill_hub, args=(hub,))
backend.pause_for(TIMEOUT * 5)
assert triggered[0]
def test_downed_recipient_cancels_the_hub_sender_during_chunked_publish(self):
port = _free_port()
hub = junction.Hub(("127.0.0.1", port), [])
triggered = [False]
@hub.accept_publish('service', 0, 0, 'method')
def handle(chunks):
for item in chunks:
pass
hub.start()
port2 = _free_port()
hub2 = junction.Hub(("127.0.0.1", port2), [("127.0.0.1", port)])
hub2.start()
hub2.wait_connected()
def gen():
try:
while 1:
yield None
backend.pause_for(TIMEOUT)
finally:
triggered[0] = True
hub2.publish('service', 0, 'method', (gen(),))
hub = [hub]
backend.schedule_in(TIMEOUT * 4, self.kill_hub, args=(hub,))
backend.pause_for(TIMEOUT * 5)
assert triggered[0]
def test_downed_recipient_cancels_the_hub_sender_during_chunked_request(
self):
port = _free_port()
hub = junction.Hub(("127.0.0.1", port), [])
triggered = [False]
@hub.accept_rpc('service', 0, 0, 'method')
def handle(chunks):
for item in chunks:
pass
return "all done"
hub.start()
port2 = _free_port()
hub2 = junction.Hub(("127.0.0.1", port2), [("127.0.0.1", port)])
hub2.start()
hub2.wait_connected()
def gen():
try:
while 1:
yield None
backend.pause_for(TIMEOUT)
finally:
triggered[0] = True
rpc = hub2.send_rpc('service', 0, 'method', (gen(), ))
hub = [hub]
backend.schedule_in(TIMEOUT * 4, self.kill_hub, args=(hub, ))
backend.pause_for(TIMEOUT * 5)
assert triggered[0]
def gen():
try:
while 1:
yield None
backend.pause_for(TIMEOUT)
finally:
triggered[0] = True
def test_singular_rpc(self):
handler_results = []
sender_results = []
@self.peer.accept_rpc("service", 0, 0, "method")
def handler(x):
handler_results.append(x)
return x**2
backend.pause_for(TIMEOUT)
sender_results.append(
self.sender.rpc("service", 0, "method", (1, ), {},
timeout=TIMEOUT))
sender_results.append(
self.sender.rpc("service", 0, "method", (2, ), {},
timeout=TIMEOUT))
sender_results.append(
self.sender.rpc("service", 0, "method", (3, ), {},
timeout=TIMEOUT))
sender_results.append(
self.sender.rpc("service", 0, "method", (4, ), {},
timeout=TIMEOUT))
self.assertEqual(handler_results, [1, 2, 3, 4])
self.assertEqual(sender_results, [1, 4, 9, 16])
def test_async_rpc_success(self):
handler_results = []
sender_results = []
def handler(x):
handler_results.append(x)
return x**2
self.peer.accept_rpc("service", 0, 0, "method", handler)
backend.pause_for(TIMEOUT)
rpcs = []
rpcs.append(self.sender.send_rpc("service", 0, "method", (1, ), {}))
rpcs.append(self.sender.send_rpc("service", 0, "method", (2, ), {}))
rpcs.append(self.sender.send_rpc("service", 0, "method", (3, ), {}))
rpcs.append(self.sender.send_rpc("service", 0, "method", (4, ), {}))
while rpcs:
rpc = junction.wait_any(rpcs, TIMEOUT)
rpcs.remove(rpc)
sender_results.append(rpc.value)
self.assertEqual(handler_results, [1, 2, 3, 4])
self.assertEqual(sender_results, [1, 4, 9, 16])
def test_downed_recipient_cancels_the_hub_sender_during_chunked_publish(
self):
global PORT
hub = junction.Hub(("127.0.0.1", PORT), [])
PORT += 2
triggered = [False]
@hub.accept_publish('service', 0, 0, 'method')
def handle(chunks):
for item in chunks:
pass
hub.start()
hub2 = junction.Hub(("127.0.0.1", PORT), [("127.0.0.1", PORT - 2)])
PORT += 2
hub2.start()
hub2.wait_connected()
def gen():
try:
while 1:
yield None
backend.pause_for(TIMEOUT)
finally:
triggered[0] = True
hub2.publish('service', 0, 'method', (gen(), ))
hub = [hub]
backend.schedule_in(TIMEOUT * 4, self.kill_hub, args=(hub, ))
backend.pause_for(TIMEOUT * 5)
assert triggered[0]
def gen():
try:
while 1:
yield None
backend.pause_for(TIMEOUT)
finally:
triggered[0] = True
def test_rpc_ruled_out_by_method(self):
results = []
self.peer.accept_rpc("service", 0, 0, "method1", results.append)
backend.pause_for(TIMEOUT)
self.assertRaises(junction.errors.UnsupportedRemoteMethod,
self.sender.rpc, "service", 0, "method2", (1,), {}, TIMEOUT)
def test_rpc_ruled_out_by_method(self):
results = []
self.peer.accept_rpc("service", 0, 0, "method1", results.append)
backend.pause_for(TIMEOUT)
self.assertRaises(junction.errors.UnsupportedRemoteMethod,
self.sender.rpc, "service", 0, "method2", (1, ), {},
TIMEOUT)
def test_rpc_ruled_out_by_routing_id(self):
results = []
self.peer.accept_rpc("service", 1, 0, "method", results.append)
backend.pause_for(TIMEOUT)
self.assertRaises(junction.errors.Unroutable,
self.sender.rpc, "service", 1, "method", (1,), {}, TIMEOUT)
self.assertEqual(results, [])
def test_rpc_ruled_out_by_routing_id(self):
results = []
self.peer.accept_rpc("service", 1, 0, "method", results.append)
backend.pause_for(TIMEOUT)
self.assertRaises(junction.errors.Unroutable, self.sender.rpc,
"service", 1, "method", (1, ), {}, TIMEOUT)
self.assertEqual(results, [])
def test_publish_receiver_count_includes_self(self):
@self.peer.accept_publish('service', 0, 0, 'method')
def handler():
return 8
@self.sender.accept_publish('service', 0, 0, 'method')
def handler():
return 9
backend.pause_for(TIMEOUT)
self.assertEqual(2, self.sender.publish_receiver_count('service', 0))
def test_publish_receiver_count_includes_self(self):
@self.peer.accept_publish('service', 0, 0, 'method')
def handler():
return 8
@self.sender.accept_publish('service', 0, 0, 'method')
def handler():
return 9
backend.pause_for(TIMEOUT)
self.assertEqual(2,
self.sender.publish_receiver_count('service', 0))
def test_rpc_handler_unknown_exception(self):
class CustomError(Exception):
pass
def handler():
raise CustomError("WOOPS")
self.peer.accept_rpc("service", 0, 0, "method", handler)
backend.pause_for(TIMEOUT)
try:
self.sender.rpc("service", 0, "method", (), {}, TIMEOUT)
except junction.errors.RemoteException, exc:
result = exc
def test_rpc_handler_recognized_exception(self):
class CustomError(junction.errors.HandledError):
code = 3
def handler():
raise CustomError("gaah")
self.peer.accept_rpc("service", 0, 0, "method", handler)
backend.pause_for(TIMEOUT)
try:
self.sender.rpc("service", 0, "method", (), {}, TIMEOUT)
except CustomError, exc:
result = exc
def test_rpc_handler_unknown_exception(self):
class CustomError(Exception):
pass
def handler():
raise CustomError("WOOPS")
self.peer.accept_rpc("service", 0, 0, "method", handler)
backend.pause_for(TIMEOUT)
try:
self.sender.rpc("service", 0, "method", (), {}, TIMEOUT)
except junction.errors.RemoteException, exc:
result = exc
def test_rpc_handler_recognized_exception(self):
class CustomError(junction.errors.HandledError):
code = 3
def handler():
raise CustomError("gaah")
self.peer.accept_rpc("service", 0, 0, "method", handler)
backend.pause_for(TIMEOUT)
try:
self.sender.rpc("service", 0, "method", (), {}, TIMEOUT)
except CustomError, exc:
result = exc
def test_unrelated_client_chunked_publishes_are_unrelated(self):
global PORT
hub = junction.Hub(("127.0.0.1", PORT), [])
PORT += 2
d = {}
@hub.accept_publish('service', 0, 0, 'method')
def handle(x, source):
for item in x:
d.setdefault(source, 0)
d[source] += 1
hub.start()
c1 = junction.Client(("127.0.0.1", PORT - 2))
c1.connect()
c1.wait_connected()
c2 = junction.Client(("127.0.0.1", PORT - 2))
c2.connect()
c2.wait_connected()
def gen():
backend.pause_for(TIMEOUT)
yield None
backend.pause_for(TIMEOUT)
yield None
backend.pause_for(TIMEOUT)
yield None
backend.schedule(c1.publish,
args=('service', 0, 'method'),
kwargs={
'args': (gen(), ),
'kwargs': {
'source': 'a'
}
})
backend.schedule(c2.publish,
args=('service', 0, 'method'),
kwargs={
'args': (gen(), ),
'kwargs': {
'source': 'b'
}
})
backend.pause_for(TIMEOUT)
c2 = [c2]
self.kill_client(c2)
backend.pause_for(TIMEOUT)
backend.pause_for(TIMEOUT)
backend.pause_for(TIMEOUT)
self.assertEquals(d, {'a': 3, 'b': 1})
def test_chunked_publish_success(self):
results = []
ev = backend.Event()
@self.peer.accept_publish("service", 0, 0, "method")
def handler(items):
for item in items:
results.append(item)
ev.set()
backend.pause_for(TIMEOUT)
self.sender.publish("service", 0, "method", ((x for x in xrange(5)),))
assert not ev.wait(TIMEOUT)
self.assertEqual(results, [0, 1, 2, 3, 4])
def test_rpc_ruled_out_by_service(self):
results = []
ev = backend.Event()
@self.peer.accept_rpc("service1", 0, 0, "method")
def handler(item):
results.append(item)
ev.set()
backend.pause_for(TIMEOUT)
self.assertRaises(junction.errors.Unroutable,
self.sender.rpc, "service2", 0, "method", (1,), {}, TIMEOUT)
assert ev.wait(TIMEOUT)
self.assertEqual(results, [])
def test_rpc_ruled_out_by_service(self):
results = []
ev = backend.Event()
@self.peer.accept_rpc("service1", 0, 0, "method")
def handler(item):
results.append(item)
ev.set()
backend.pause_for(TIMEOUT)
self.assertRaises(junction.errors.Unroutable, self.sender.rpc,
"service2", 0, "method", (1, ), {}, TIMEOUT)
assert ev.wait(TIMEOUT)
self.assertEqual(results, [])
def test_chunked_publish_success(self):
results = []
ev = backend.Event()
@self.peer.accept_publish("service", 0, 0, "method")
def handler(items):
for item in items:
results.append(item)
ev.set()
backend.pause_for(TIMEOUT)
self.sender.publish("service", 0, "method", ((x for x in xrange(5)), ))
assert not ev.wait(TIMEOUT)
self.assertEqual(results, [0, 1, 2, 3, 4])
def test_publish_success(self):
results = []
ev = backend.Event()
@self.peer.accept_publish("service", 0, 0, "method")
def handler(item):
results.append(item)
if len(results) == 4:
ev.set()
backend.pause_for(TIMEOUT)
self.sender.publish("service", 0, "method", (1,), {})
self.sender.publish("service", 0, "method", (2,), {})
self.sender.publish("service", 0, "method", (3,), {})
self.sender.publish("service", 0, "method", (4,), {})
ev.wait(TIMEOUT)
self.assertEqual(results, [1, 2, 3, 4])
def test_publish_ruled_out_by_service(self):
results = []
ev = backend.Event()
@self.peer.accept_publish("service1", 0, 0, "method")
def handler(item):
results.append(item)
ev.set()
backend.pause_for(TIMEOUT)
try:
self.sender.publish("service2", 0, "method", (1, ), {})
except junction.errors.Unroutable:
# eat this as Clients don't get this raised, only Hubs
pass
assert ev.wait(TIMEOUT)
self.assertEqual(results, [])
def test_publish_ruled_out_by_service(self):
results = []
ev = backend.Event()
@self.peer.accept_publish("service1", 0, 0, "method")
def handler(item):
results.append(item)
ev.set()
backend.pause_for(TIMEOUT)
try:
self.sender.publish("service2", 0, "method", (1,), {})
except junction.errors.Unroutable:
# eat this as Clients don't get this raised, only Hubs
pass
assert ev.wait(TIMEOUT)
self.assertEqual(results, [])
def test_publish_success(self):
results = []
ev = backend.Event()
@self.peer.accept_publish("service", 0, 0, "method")
def handler(item):
results.append(item)
if len(results) == 4:
ev.set()
backend.pause_for(TIMEOUT)
self.sender.publish("service", 0, "method", (1, ), {})
self.sender.publish("service", 0, "method", (2, ), {})
self.sender.publish("service", 0, "method", (3, ), {})
self.sender.publish("service", 0, "method", (4, ), {})
ev.wait(TIMEOUT)
self.assertEqual(results, [1, 2, 3, 4])
def test_chunked_publish(self):
results = []
@self.peer.accept_rpc('service', 0, 0, 'method')
def handler(chunks):
for chunk in chunks:
results.append(chunk)
return 5
backend.pause_for(TIMEOUT)
def gen():
yield 1
yield 2
self.assertEqual(
self.sender.rpc('service', 0, 'method', (gen(), ),
timeout=TIMEOUT), 5)
self.assertEqual(results, [1, 2])
def test_chunked_publish(self):
results = []
@self.peer.accept_rpc('service', 0, 0, 'method')
def handler(chunks):
for chunk in chunks:
results.append(chunk)
return 5
backend.pause_for(TIMEOUT)
def gen():
yield 1
yield 2
self.assertEqual(
self.sender.rpc('service', 0, 'method', (gen(),),
timeout=TIMEOUT),
5)
self.assertEqual(results, [1,2])
def gen():
backend.pause_for(TIMEOUT)
yield None
backend.pause_for(TIMEOUT)
yield None
backend.pause_for(TIMEOUT)
yield None
def gen():
backend.pause_for(TIMEOUT)
yield None
backend.pause_for(TIMEOUT)
yield None
backend.pause_for(TIMEOUT)
yield None
def test_singular_rpc(self):
handler_results = []
sender_results = []
@self.peer.accept_rpc("service", 0, 0, "method")
def handler(x):
handler_results.append(x)
return x ** 2
backend.pause_for(TIMEOUT)
sender_results.append(self.sender.rpc("service", 0, "method", (1,), {},
timeout=TIMEOUT))
sender_results.append(self.sender.rpc("service", 0, "method", (2,), {},
timeout=TIMEOUT))
sender_results.append(self.sender.rpc("service", 0, "method", (3,), {},
timeout=TIMEOUT))
sender_results.append(self.sender.rpc("service", 0, "method", (4,), {},
timeout=TIMEOUT))
self.assertEqual(handler_results, [1,2,3,4])
self.assertEqual(sender_results, [1,4,9,16])
def test_unrelated_client_chunked_publishes_are_unrelated(self):
global PORT
hub = junction.Hub(("127.0.0.1", PORT), [])
PORT += 2
d = {}
@hub.accept_publish('service', 0, 0, 'method')
def handle(x, source):
for item in x:
d.setdefault(source, 0)
d[source] += 1
hub.start()
c1 = junction.Client(("127.0.0.1", PORT - 2))
c1.connect()
c1.wait_connected()
c2 = junction.Client(("127.0.0.1", PORT - 2))
c2.connect()
c2.wait_connected()
def gen():
backend.pause_for(TIMEOUT)
yield None
backend.pause_for(TIMEOUT)
yield None
backend.pause_for(TIMEOUT)
yield None
backend.schedule(c1.publish, args=('service', 0, 'method'),
kwargs={'args': (gen(),), 'kwargs': {'source': 'a'}})
backend.schedule(c2.publish, args=('service', 0, 'method'),
kwargs={'args': (gen(),), 'kwargs': {'source': 'b'}})
backend.pause_for(TIMEOUT)
c2 = [c2]
self.kill_client(c2)
backend.pause_for(TIMEOUT)
backend.pause_for(TIMEOUT)
backend.pause_for(TIMEOUT)
self.assertEquals(d, {'a': 3, 'b': 1})
def handle():
backend.pause_for(TIMEOUT)
return 1
def handle():
backend.pause_for(TIMEOUT)
return 1
