async def listen():
server = RedisRpcServer()
server_task = asyncio.create_task(
server.register_handler(
topic=TOPIC,
request_handler=TestRpcRequestHandler(check_message)))
shutdown_task = asyncio.create_task(shutdown(server))
await asyncio.gather(server_task, shutdown_task)
class Command(BaseCommand):
group_application_service = GroupApplicationService()
group_create_command_handler = GroupCreateCommandHandler(
group_application_service=group_application_service)
group_update_command_handler = GroupUpdateCommandHandler(
group_application_service=group_application_service)
subscriber = RedisMessageSubscriber()
rpc_server = RedisRpcServer()
def handle(self, *args, **options):
loop = asyncio.get_event_loop()
register_signal_handler(loop)
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_update_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=GROUP_UPDATE_COMMAND,
message_handler=self.group_update_command_handler))
group_update_rpc_task = asyncio.create_task(
self.rpc_server.register_handler(
topic=GROUP_UPDATE_COMMAND,
request_handler=self.group_update_command_handler))
"""
wait until application stop
"""
await asyncio.gather(
group_create_subscription_task,
group_create_rpc_task,
group_update_subscription_task,
group_update_rpc_task,
)
loop.create_task(main())
loop.run_forever()
async def shutdown(self, sig, loop):
print('caught {0}'.format(sig))
tasks = [
task for task in asyncio.Task.all_tasks()
if task is not asyncio.tasks.Task.current_task()
]
list(map(lambda task: task.cancel(), tasks))
results = await asyncio.gather(*tasks, return_exceptions=True)
print(
'finished awaiting cancelled tasks, results: {0}'.format(results))
loop.stop()
class Command(BaseCommand):
user_application_service = UserApplicationService()
user_point_update_command_handler = UserPointUpdateCommandHandler(
user_application_service=user_application_service)
user_create_command_handler = UserCreateCommandHandler(
user_application_service=user_application_service)
user_login_event_handler = UserLoginEventHandler(
user_application_service=user_application_service)
user_logout_event_handler = UserLogoutEventHandler(
user_application_service=user_application_service)
subscriber = RedisMessageSubscriber()
rpc_server = RedisRpcServer()
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_point_update_subscription_task = asyncio.create_task(
self.subscriber.subscribe_message(
topic=USER_POINT_UPDATE_COMMAND,
message_handler=self.user_point_update_command_handler))
user_point_update_rpc_task = asyncio.create_task(
self.rpc_server.register_handler(
topic=USER_POINT_UPDATE_COMMAND,
request_handler=self.user_point_update_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_point_update_subscription_task,
user_point_update_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()
class Command(BaseCommand):
carpool_application_service = CarpoolRequestApplicationService()
carpool_create_command_handler = CarpoolRequestCreateCommandHandler(
carpool_request_application_service=carpool_application_service)
carpool_delete_command_handler = CarpoolRequestDeleteCommandHandler(
carpool_request_application_service=carpool_application_service)
subscriber = RedisMessageSubscriber()
rpc_server = RedisRpcServer()
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()
async def shutdown(self, sig, loop):
print('caught {0}'.format(sig))
tasks = [task for task in asyncio.Task.all_tasks() if task is not
asyncio.tasks.Task.current_task()]
list(map(lambda task: task.cancel(), tasks))
results = await asyncio.gather(*tasks, return_exceptions=True)
print('finished awaiting cancelled tasks, results: {0}'
.format(results))
loop.stop()