def test_pubsub_inheritance():
publisher = zerorpc.Publisher()
publisher.bind(endpoint)
trigger = gevent.event.Event()
class Subscriber(zerorpc.Subscriber):
def lolita(self, a, b):
print('lolita', a, b)
trigger.set()
subscriber = Subscriber()
subscriber.connect(endpoint)
gevent.spawn(subscriber.run)
trigger.clear()
# We need this retry logic to wait that the subscriber.run coroutine starts
# reading (the published messages will go to /dev/null until then).
for attempt in range(0, 10):
print("====", attempt)
publisher.lolita(1, 2)
if trigger.wait(0.2):
print('done')
return
raise RuntimeError("The subscriber didn't receive any published message")
def main(dataset, algorithm, model, num_users, async_process, batch_size,
num_global_iters):
if async_process is True:
print("async structure")
server = zerorpc.Server(
RpcController(dataset, algorithm, model, num_users, async_process,
batch_size))
server.bind('tcp://0.0.0.0:8888')
print('Server Start!')
server.run()
else:
print("sync structure")
server = zerorpc.Server(
RpcController(dataset, algorithm, model, num_users, async_process,
batch_size))
server.bind('tcp://0.0.0.0:8888')
publisher = zerorpc.Publisher()
publisher.bind('tcp://0.0.0.0:8889')
print('Server Start!')
trigger.clear()
gevent.spawn(server.run)
trigger.wait()
publisher.ready_start(time.time())
time.sleep(1)
for i in range(num_global_iters):
print("Epoch ", i)
trigger.clear()
publisher.new_epoch(i, time.time())
trigger.wait()
trigger.clear()
publisher.complete_train(time.time())
trigger.wait()
def test_pubsub_composite():
endpoint = random_ipc_endpoint()
trigger = gevent.event.Event()
class Subscriber(object):
def lolita(self, a, b):
print 'lolita', a, b
assert a + b == 3
trigger.set()
publisher = zerorpc.Publisher()
publisher.bind(endpoint)
service = Subscriber()
subscriber = zerorpc.Subscriber(service)
subscriber.connect(endpoint)
gevent.spawn(subscriber.run)
trigger.clear()
# We need this retry logic to wait that the subscriber.run coroutine starts
# reading (the published messages will go to /dev/null until then).
for attempt in xrange(0, 10):
publisher.lolita(1, 2)
if trigger.wait(0.2):
print 'done'
return
raise RuntimeError("The subscriber didn't receive any published message")
def test_pubsub_inheritance():
endpoint = random_ipc_endpoint()
publisher = zerorpc.Publisher()
publisher.bind(endpoint)
trigger = gevent.event.Event()
class Subscriber(zerorpc.Subscriber):
def lolita(self, a, b):
print 'lolita', a, b
assert a + b == 3
trigger.set()
subscriber = Subscriber()
subscriber.connect(endpoint)
gevent.spawn(subscriber.run)
trigger.clear()
publisher.lolita(1, 2)
trigger.wait()
print 'done'
def test_task_context_pubsub():
endpoint = random_ipc_endpoint()
subscriber_ctx = zerorpc.Context()
publisher_ctx = zerorpc.Context()
subscriber_tracer = Tracer('[subscriber]')
subscriber_ctx.register_middleware(subscriber_tracer)
publisher_tracer = Tracer('[publisher]')
publisher_ctx.register_middleware(publisher_tracer)
trigger = gevent.event.Event()
class Subscriber:
def echo(self, msg):
trigger.set()
subscriber = zerorpc.Subscriber(Subscriber(), context=subscriber_ctx)
subscriber.bind(endpoint)
subscriber_task = gevent.spawn(subscriber.run)
c = zerorpc.Publisher(context=publisher_ctx)
c.connect(endpoint)
trigger.clear()
# We need this retry logic to wait that the subscriber.run coroutine starts
# reading (the published messages will go to /dev/null until then).
for attempt in xrange(0, 10):
c.echo('pub...')
if trigger.wait(0.2):
break
subscriber.stop()
subscriber_task.join()
assert publisher_tracer._log == [
('new', publisher_tracer.trace_id),
]
assert subscriber_tracer._log == [
('load', publisher_tracer.trace_id),
]
def test_task_context_pubsub():
subscriber_ctx = zerorpc.Context()
publisher_ctx = zerorpc.Context()
subscriber_tracer = Tracer('[subscriber]')
subscriber_ctx.register_middleware(subscriber_tracer)
publisher_tracer = Tracer('[publisher]')
publisher_ctx.register_middleware(publisher_tracer)
trigger = gevent.event.Event()
class Subscriber(object):
def echo(self, msg):
trigger.set()
subscriber = zerorpc.Subscriber(Subscriber(), context=subscriber_ctx)
subscriber.bind(endpoint)
subscriber_task = gevent.spawn(subscriber.run)
c = zerorpc.Publisher(context=publisher_ctx)
c.connect(endpoint)
trigger.clear()
# We need this retry logic to wait that the subscriber.run coroutine starts
# reading (the published messages will go to /dev/null until then).
while not trigger.is_set():
c.echo('pub...')
if trigger.wait(TIME_FACTOR * 1):
break
subscriber.stop()
subscriber_task.join()
print(publisher_tracer._log)
assert ('new', publisher_tracer.trace_id) in publisher_tracer._log
print(subscriber_tracer._log)
assert ('load', publisher_tracer.trace_id) in subscriber_tracer._log
def test_task_context_pubsub():
endpoint = random_ipc_endpoint()
subscriber_ctx = zerorpc.Context()
publisher_ctx = zerorpc.Context()
subscriber_tracer = Tracer('[subscriber]')
subscriber_ctx.register_middleware(subscriber_tracer)
publisher_tracer = Tracer('[publisher]')
publisher_ctx.register_middleware(publisher_tracer)
trigger = gevent.event.Event()
class Subscriber:
def echo(self, msg):
trigger.set()
subscriber = zerorpc.Subscriber(Subscriber(), context=subscriber_ctx)
subscriber.bind(endpoint)
subscriber_task = gevent.spawn(subscriber.run)
c = zerorpc.Publisher(context=publisher_ctx)
c.connect(endpoint)
trigger.clear()
c.echo('pub...')
trigger.wait()
subscriber.stop()
subscriber_task.join()
assert publisher_tracer._log == [
('new', publisher_tracer.trace_id),
]
assert subscriber_tracer._log == [
('load', publisher_tracer.trace_id),
]
def runserver():
#server = zerorpc.Server(ServerRPC())
server = zerorpc.Publisher()
server.bind("tcp://0.0.0.0:4243")
return server
def test_call_procedure():
c = zerorpc.Context()
def test(argument):
return 'ret_real:' + argument
assert c.middleware_call_procedure(test, 'dummy') == 'ret_real:dummy'
def middleware_1(procedure, *args, **kwargs):
return 'ret_middleware_1:' + procedure(*args, **kwargs)
cnt = c.register_middleware({'call_procedure': middleware_1})
assert cnt == 1
assert c.middleware_call_procedure(test, 'dummy') == \
'ret_middleware_1:ret_real:dummy'
def middleware_2(procedure, *args, **kwargs):
return 'ret_middleware_2:' + procedure(*args, **kwargs)
cnt = c.register_middleware({'call_procedure': middleware_2})
assert cnt == 1
assert c.middleware_call_procedure(test, 'dummy') == \
'ret_middleware_2:ret_middleware_1:ret_real:dummy'
def mangle_arguments(procedure, *args, **kwargs):
return procedure(args[0].upper())
cnt = c.register_middleware({'call_procedure': mangle_arguments})
assert cnt == 1
assert c.middleware_call_procedure(test, 'dummy') == \
'ret_middleware_2:ret_middleware_1:ret_real:DUMMY'
endpoint = random_ipc_endpoint()
# client/server
class Server(zerorpc.Server):
def test(self, argument):
return 'ret_real:' + argument
server = Server(heartbeat=1, context=c)
server.bind(endpoint)
gevent.spawn(server.run)
client = zerorpc.Client(heartbeat=1, context=c)
client.connect(endpoint)
assert client.test('dummy') == \
'ret_middleware_2:ret_middleware_1:ret_real:DUMMY'
client.close()
server.close()
# push/pull
trigger = gevent.event.Event()
class Puller(zerorpc.Puller):
argument = None
def test(self, argument):
self.argument = argument
trigger.set()
return self.argument
puller = Puller(context=c)
puller.bind(endpoint)
gevent.spawn(puller.run)
pusher = zerorpc.Pusher(context=c)
pusher.connect(endpoint)
trigger.clear()
pusher.test('dummy')
trigger.wait()
assert puller.argument == 'DUMMY'
#FIXME: These seems to be broken
# pusher.close()
# puller.close()
# pub/sub
trigger = gevent.event.Event()
class Subscriber(zerorpc.Subscriber):
argument = None
def test(self, argument):
self.argument = argument
trigger.set()
return self.argument
subscriber = Subscriber(context=c)
subscriber.bind(endpoint)
gevent.spawn(subscriber.run)
publisher = zerorpc.Publisher(context=c)
publisher.connect(endpoint)
trigger.clear()
publisher.test('dummy')
trigger.wait()
assert subscriber.argument == 'DUMMY'