def main(addr, port):
loop = asyncio.get_event_loop()
coro = loop.create_connection(lambda: Worker(reverse, loop=loop), addr,
port)
_, worker = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
loop.run_until_complete(worker.shutdown())
loop.close()
async def test_grab_types(event_loop, unused_tcp_port, grab_type, mock_protocol, expected):
f = event_loop.create_future()
def _test_func(job_info):
nonlocal f
f.set_result(job_info.workload)
await run_mock_server(event_loop, unused_tcp_port, messaging=mock_protocol)
factory = lambda: Worker((_test_func, 'test_func'), loop=event_loop, grab_type=grab_type)
worker = await connect_worker(event_loop, unused_tcp_port, factory)
received = await asyncio.wait_for(f, timeout=1)
assert received == expected
await worker.shutdown()
def main(addr, port, worker_num):
loop = asyncio.get_event_loop()
workers = []
for _ in range(worker_num):
coro = loop.create_connection(lambda: Worker(reverse, loop=loop), addr,
port)
_, worker = loop.run_until_complete(coro)
workers.append(worker)
try:
loop.run_forever()
except KeyboardInterrupt:
for worker in workers:
loop.run_until_complete(worker.shutdown())
loop.close()
def main():
worker = Worker()
# start the gearman server
# sudo gearmand -d -p 4730
# sudo gearmand -d -p 4731
# sudo gearmand -d -p 4732
yield from worker.add_server('localhost', 4730)
yield from worker.add_server('localhost', 4731)
yield from worker.add_server('localhost', 4732)
yield from worker.add_func('echo', echo)
worker.work()
async def test_job_result(event_loop, unused_tcp_port):
f = event_loop.create_future()
def _return_good(job_info):
return 'good'
def _cb(param):
nonlocal f
f.set_result(param)
mock_protocol = {
PacketType.PRE_SLEEP: (PacketType.NOOP, ),
PacketType.GRAB_JOB:
(PacketType.JOB_ASSIGN, 'test_handle', 'return_good', 'test_workload'),
PacketType.WORK_COMPLETE:
_cb,
}
await run_mock_server(event_loop, unused_tcp_port, messaging=mock_protocol)
factory = lambda: Worker((_return_good, 'return_good'), loop=event_loop)
worker = await connect_worker(event_loop, unused_tcp_port, factory)
received = await asyncio.wait_for(f, timeout=1)
assert PacketType.WORK_COMPLETE == received
await worker.shutdown()
async def test_job_exception(event_loop, unused_tcp_port):
f = event_loop.create_future()
def _raise_exception(job_info):
raise RuntimeError
def _exception_cb(param):
nonlocal f
f.set_result(param)
mock_protocol = {
PacketType.PRE_SLEEP: (PacketType.NOOP, ),
PacketType.GRAB_JOB: (PacketType.JOB_ASSIGN, 'test_handle',
'test_exception', 'test_workload'),
PacketType.WORK_EXCEPTION:
_exception_cb,
}
await run_mock_server(event_loop, unused_tcp_port, messaging=mock_protocol)
factory = lambda: Worker(
(_raise_exception, 'test_exception'), loop=event_loop)
worker = await connect_worker(event_loop, unused_tcp_port, factory)
received = await asyncio.wait_for(f, timeout=1)
assert PacketType.WORK_EXCEPTION == received
await worker.shutdown()
def _worker(event_loop, timeout=None):
func = lambda x: x, 'func_test'
return Worker(func, loop=event_loop, timeout=timeout)
def worker():
w = Worker()
w.get_task = mock.Mock()
return w
def worker():
w = Worker()
return w
def test_invalid_grab_type():
Worker(grab_type=PacketType.ALL_YOURS)
async def register_worker(loop, addr, port):
factory = lambda: Worker(sleep, loop=loop)
_, worker = await loop.create_connection(factory, addr, port)
return worker