def handle(self, *args, **options):
loop = asyncio.get_event_loop()
register_signal_handler(loop, shutdown_process)
async def main():
group_created_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=GROUP_CREATED_EVENT,
message_handler=self.group_created_event_handler))
ping_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=PING_COMMAND,
message_handler=self.ping_command_handler))
await asyncio.gather(
group_created_subscription_task,
ping_subscription_task,
)
thread = threading.Thread(target=self.grpc_server.listen)
thread.daemon = True
thread.start()
loop.create_task(main())
loop.run_forever()
self.grpc_server.listen()
def handle(self, *args, **options):
loop = asyncio.get_event_loop()
register_signal_handler(loop, shutdown_process)
async def main():
"""
create subscription tasks
"""
user_create_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=USER_CREATE_COMMAND,
message_handler=self.user_create_command_handler))
user_create_rpc_task = asyncio.create_task(
self.rpc_server.register_handler(
topic=USER_CREATE_COMMAND,
request_handler=self.user_create_command_handler))
user_login_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=USER_LOGIN_EVENT,
message_handler=self.user_login_event_handler))
user_login_rpc_task = asyncio.create_task(
self.rpc_server.register_handler(
topic=USER_LOGIN_EVENT,
request_handler=self.user_login_event_handler))
user_logout_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=USER_LOGOUT_EVENT,
message_handler=self.user_logout_event_handler))
user_logout_rpc_task = asyncio.create_task(
self.rpc_server.register_handler(
topic=USER_LOGOUT_EVENT,
request_handler=self.user_logout_event_handler))
"""
wait until application stop
"""
await asyncio.gather(
user_create_subscription_task,
user_create_rpc_task,
user_login_subscription_task,
user_login_rpc_task,
user_logout_subscription_task,
user_logout_rpc_task,
)
loop.create_task(main())
loop.run_forever()
def handle(self, *args, **options):
loop = asyncio.get_event_loop()
register_signal_handler(loop, shutdown=shutdown_process)
async def main():
"""
create subscription tasks
"""
group_create_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=GROUP_CREATE_COMMAND,
message_handler=self.group_create_command_handler))
group_create_rpc_task = asyncio.create_task(
self.rpc_server.register_handler(
topic=GROUP_CREATE_COMMAND,
request_handler=self.group_create_command_handler))
group_driver_update_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=GROUP_DRIVER_UPDATE_COMMAND,
message_handler=self.group_driver_update_command_handler))
group_driver_update_rpc_task = asyncio.create_task(
self.rpc_server.register_handler(
topic=GROUP_DRIVER_UPDATE_COMMAND,
request_handler=self.group_driver_update_command_handler))
group_cost_update_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=GROUP_COST_UPDATE_COMMAND,
message_handler=self.group_cost_update_command_handler))
group_cost_update_rpc_task = asyncio.create_task(
self.rpc_server.register_handler(
topic=GROUP_COST_UPDATE_COMMAND,
request_handler=self.group_cost_update_command_handler))
"""
wait until application stop
"""
await asyncio.gather(
group_create_subscription_task,
group_create_rpc_task,
group_driver_update_subscription_task,
group_driver_update_rpc_task,
group_cost_update_subscription_task,
group_cost_update_rpc_task,
)
loop.create_task(main())
loop.run_forever()
def handle(self, *args, **options):
loop = asyncio.get_event_loop()
register_signal_handler(loop, shutdown=shutdown_process)
async def main():
"""
create subscription tasks
"""
carpool_request_delete_rpc_task = asyncio.create_task(
self.rpc_server.register_handler(
topic=CARPOOL_REQUEST_DELETE_COMMAND,
request_handler=self.carpool_delete_command_handler))
carpool_request_create_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=CARPOOL_REQUEST_CREATE_COMMAND,
message_handler=self.carpool_create_command_handler))
carpool_request_create_rpc_task = asyncio.create_task(
self.rpc_server.register_handler(
topic=CARPOOL_REQUEST_CREATE_COMMAND,
request_handler=self.carpool_create_command_handler))
carpool_request_delete_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=CARPOOL_REQUEST_DELETE_COMMAND,
message_handler=self.carpool_delete_command_handler))
"""
wait until application stop
"""
await asyncio.gather(
carpool_request_create_subscription_task,
carpool_request_create_rpc_task,
carpool_request_delete_subscription_task,
carpool_request_delete_rpc_task
)
loop.create_task(main())
loop.run_forever()
