def setUp(self): assert settings.INTEGRATION_TESTS assert settings.RUNNING_TESTS self.loop = asyncio.get_event_loop() self.publisher = RedisMultipleQueuesPublisher(get_redis_factory( RedisType.QUEUES), num_queues=5) self.consumers = [ RedisQueueConsumer(get_redis_factory(RedisType.QUEUES), x) for x in range(0, 5) ]
async def asyncio_test(self): sut = RedisMapRepository(get_redis_factory(RedisType.DATA)) await (await sut.redis()).flushdb() max_x, max_y, max_z = 500, 500, 1 sut.max_y = max_y sut.max_x = max_x start = time.time() i = 0 print('\nBaking {}x{} map'.format(max_x, max_y)) for x in range(max_x, -1, -1): roomz = OrderedDict() for y in range(max_y, -1, -1): for z in range(0, max_z): i += 1 position = PositionComponent( coord='{},{},{}'.format(x, y, z)) roomz['{}.{}.{}'.format(x, y, z)] = Room( position=position, terrain=random.choice( [TerrainEnum.WALL_OF_BRICKS, TerrainEnum.PATH]), ) print(i, ' rooms saved') await sut.set_rooms(*roomz.values()) print('\n{}x{} map baked in {}'.format(max_x, max_y, time.time() - start)) start = time.time() print('\nFetching {}x{} map'.format(max_x, max_y)) tot = 0 for x in range(0, max_x): res = await sut.get_rooms(*(PositionComponent( coord='{},{},{}'.format(x, y, 0)) for y in range(0, max_y))) tot += len(res) print('\n{}x{} map fetched in {} - total: {}'.format( max_x, max_y, time.time() - start, tot))
def setUp(self): assert settings.INTEGRATION_TESTS assert settings.RUNNING_TESTS asyncio.get_event_loop().run_until_complete(self._flush_redis()) self.lib_repo = Mock() self.map_repo = Mock() self.sut = RedisDataRepository(get_redis_factory(RedisType.DATA), self.lib_repo, self.map_repo) self.test_success = False
def setUp(self): self.messages = [] self.loop = asyncio.get_event_loop() self.publisher = RedisMultipleQueuesPublisher(get_redis_factory( RedisType.QUEUES), num_queues=5) self.workers = [ WorkerQueueService( RedisQueueConsumer(get_redis_factory(RedisType.QUEUES), x)) for x in range(0, 5) ] class Obs: @staticmethod async def on_message(msg): self.messages.append(msg) self.observers = [] for i, worker in enumerate(self.workers): self.loop.create_task(worker.run()) self.observers.append(Obs()) worker.add_queue_observer('cmd', self.observers[i])
async def asyncio_test(self): sut = RedisMapRepository(get_redis_factory(RedisType.DATA)) await (await sut.redis()).flushdb() max_x, max_y = 50, 50 sut.max_y = max_y sut.max_x = max_x start = time.time() print('\nBaking {}x{} map'.format(max_x, max_y)) roomz = OrderedDict() for x in range(0, max_x): for y in range(0, max_y): position = PositionComponent(coord='{},{},{}'.format(x, y, 0)) roomz['{}.{}.{}'.format(x, y, 0)] = Room( position=position, terrain=random.choice( [TerrainEnum.WALL_OF_BRICKS, TerrainEnum.PATH])) await sut.set_rooms(*roomz.values()) print('\n{}x{} map baked in {}'.format(max_x, max_y, time.time() - start)) from_x, to_x = 0, 9 for yy in range(0, 210, 10): futures = [ sut.get_rooms_on_y(0, from_x, to_x, 0) for _ in range(0, yy) ] s = time.time() res = await asyncio.gather(*futures) print('Get line of {} rooms. Concurrency: '.format(to_x - from_x), yy, ' users. Time: {:.8f}'.format(time.time() - s)) for r in res: for req in range(0, to_x): k = '{}.{}.{}'.format(from_x + req, 0, 0) self.assertEqual([ r[req].position.x, r[req].position.y, r[req].position.z ], [ roomz[k].position.x, roomz[k].position.y, roomz[k].position.z ])
async def async_test(self): sut = RedisMapRepository(get_redis_factory(RedisType.DATA)) await (await sut.redis()).flushdb() futures = [] d = {} i = 0 max_x, max_y, max_z = 25, 25, 5 sut.max_y = max_y sut.max_x = max_x start = time.time() for x in range(0, max_x): for y in range(0, max_y): for z in range(0, max_z): i += 1 d['{}.{}.{}'.format(x, y, z)] = [ random.randint(0, 65530), random.randint(0, 65530) ] futures.append( sut.set_room( Room(position=PositionComponent( coord='{},{},{}'.format(x, y, z)), terrain=TerrainEnum.WALL_OF_BRICKS))) await asyncio.gather(*futures) for x in range(0, max_x): for y in range(0, max_y): for z in range(0, max_z): room = await sut.get_room( PositionComponent(coord='{},{},{}'.format(x, y, z))) self.assertEqual( [room.position.x, room.position.y, room.position.z], [x, y, z]) print( '\n', i, ' rooms tested NO pipeline in {:.10f}'.format(time.time() - start)) await (await sut.redis()).flushdb() _start = time.time() roomz = OrderedDict() positions = [] for x in range(0, max_x): for y in range(0, max_y): for z in range(0, max_z): position = PositionComponent( coord='{},{},{}'.format(x, y, z)) positions.append(position) roomz['{}.{}.{}'.format(x, y, z)] = Room( position=position, terrain=TerrainEnum.WALL_OF_BRICKS, ) await sut.set_rooms(*roomz.values()) rooms = await sut.get_rooms(*positions) for i, room in enumerate(rooms): self.assertEqual([ room.position.x, room.position.y, room.position.z, ], [ positions[i].x, positions[i].y, positions[i].z, ]) print( '\n', i + 1, ' rooms tested WITH pipeline in {:.10f}'.format(time.time() - _start)) positions = [] i = 0 for x in range(0, 9): for y in range(0, 9): positions.append( PositionComponent(coord='{},{},{}'.format(x, y, 0))) i += 1 print('\n Starting benchmarks: \n') for x in range(1, 110, 10): futures = [sut.get_rooms(*positions) for _ in range(0, x)] s = time.time() await asyncio.gather(*futures) print('Rooms: ', i, '. Concurrency: ', x, ' users. Time: {:.8f}'.format(time.time() - s)) positions = [] i = 0 for x in range(0, 9): y = 1 positions.append( PositionComponent(coord='{},{},{}'.format(x, y, 0))) i += 1 for x in range(1, 110, 10): futures = [sut.get_rooms(*positions) for _ in range(0, x)] s = time.time() await asyncio.gather(*futures) print('Rooms: ', i, '. Concurrency: ', x, ' users. Time: {:.8f}'.format(time.time() - s))
async def _flush_redis(self): r = get_redis_factory(RedisType.DATA) await (await r()).flushdb()
from core.src.world.transport.websocket_channels_service import WebsocketChannelsService from etc import settings from core.src.auth.repositories.redis_websocket_channels_repository import WebsocketChannelsRepository from core.src.world.repositories.map_repository import RedisMapRepository from core.src.world.services.redis_queue import RedisMultipleQueuesPublisher, RedisQueueConsumer from core.src.world.services.system_utils import get_redis_factory, RedisType from core.src.auth.builder import strict_redis from core.src.world.repositories.data_repository import RedisDataRepository if settings.RUNNING_TESTS and not settings.INTEGRATION_TESTS: from unittest.mock import Mock async_redis_data = Mock() async_redis_queue = Mock() else: async_redis_data = get_redis_factory(RedisType.DATA) async_redis_queue = get_redis_factory(RedisType.QUEUES) WORLD_SYSTEM_PATH = os.getcwd() library_repository = RedisLibraryRepository(async_redis_data) map_repository = RedisMapRepository(async_redis_data) world_repository = RedisDataRepository(async_redis_data, library_repository, map_repository) channels_repository = WebsocketChannelsRepository(strict_redis) redis_queues_service = RedisMultipleQueuesPublisher( async_redis_queue, num_queues=settings.WORKERS) websocket_channels_service = WebsocketChannelsService( channels_repository=channels_repository, data_repository=world_repository, redis_queue=redis_queues_service)