Fix kubernetes mode

aimmo-game/Dockerfile

@@ -13,7 +13,7 @@ COPY . .
 FROM base as runner
 RUN apk add --no-cache bash
 ENV WORKER_MANAGER=kubernetes
-CMD python ./service.py 0.0.0.0
+CMD python ./service.py 0.0.0.0 5000
 
 FROM base as tester
 ENV WORKER_MANAGER=kubernetes

aimmo-game/simulation/game_runner.py

@@ -48,7 +48,6 @@ def update_workers(self):
         game_metadata = self.communicator.get_game_metadata()['main']
 
         users_to_add = self.get_users_to_add(game_metadata)
-        LOGGER.info(users_to_add)
         users_to_delete = self.get_users_to_delete(game_metadata)
 
         self.worker_manager.add_workers(users_to_add)
@@ -61,7 +60,7 @@ def update_workers(self):
         self.worker_manager.fetch_all_worker_data(self.game_state.get_serialised_game_states_for_workers())
 
     async def update_simulation(self, player_id_to_serialised_actions):
-        self.simulation_runner.run_single_turn(player_id_to_serialised_actions)
+        await self.simulation_runner.run_single_turn(player_id_to_serialised_actions)
         await self._end_turn_callback()
 
     async def update(self):

aimmo-game/simulation/simulation_runner.py

@@ -1,8 +1,8 @@
 import logging
+import asyncio
 from abc import ABCMeta, abstractmethod
-from concurrent import futures
-from concurrent.futures import ALL_COMPLETED
-from simulation.action import PRIORITIES
+from concurrent.futures import ALL_COMPLETED, ThreadPoolExecutor
+from simulation.action import PRIORITIES, WaitAction
 from threading import Thread
 
 LOGGER = logging.getLogger(__name__)
@@ -22,10 +22,10 @@ def __init__(self, game_state, communicator):
         self.communicator = communicator
 
     @abstractmethod
-    def run_turn(self, player_id_to_serialised_actions):
+    async def run_turn(self, player_id_to_serialised_actions):
         pass
 
-    def _run_turn_for_avatar(self, avatar, serialised_action):
+    async def _run_turn_for_avatar(self, avatar, serialised_action):
         """
         Send an avatar its view of the game state and register its
         chosen action & logs.
@@ -50,44 +50,39 @@ def _update_environment(self, game_state):
     def _mark_complete(self):
         self.communicator.mark_game_complete(data=self.game_state.serialise())
 
-    def run_single_turn(self, player_id_to_serialised_actions):
-        self.run_turn(player_id_to_serialised_actions)
+    async def run_single_turn(self, player_id_to_serialised_actions):
+        await self.run_turn(player_id_to_serialised_actions)
         self.game_state.update_environment()
 
 
 class SequentialSimulationRunner(SimulationRunner):
-    def run_turn(self, player_id_to_serialised_actions):
+    async def run_turn(self, player_id_to_serialised_actions):
         """
         Get and apply each avatar's action in turn.
         """
         avatars = self.game_state.avatar_manager.active_avatars
 
         for avatar in avatars:
-            self._run_turn_for_avatar(avatar, player_id_to_serialised_actions[avatar.player_id])
+            await self._run_turn_for_avatar(avatar, player_id_to_serialised_actions[avatar.player_id])
             location_to_clear = avatar.action.target_location
             avatar.action.process(self.game_state.world_map)
             self.game_state.world_map.clear_cell_actions(location_to_clear)
 
 
 class ConcurrentSimulationRunner(SimulationRunner):
-    def _parallel_map(self, func, iterable_args):
-        with futures.ThreadPoolExecutor() as executor:
-            results = executor.map(func, iterable_args)
-            futures.wait(results, timeout=2, return_when=ALL_COMPLETED)
-        return [results]
+    async def async_map(self, func, iterable_args):
+        futures = [func(*arg) for arg in iterable_args]
+        await asyncio.gather(*futures)
 
-    def run_turn(self, player_id_to_serialised_actions):
+    async def run_turn(self, player_id_to_serialised_actions):
         """
         Concurrently get the intended actions from all avatars and register
         them on the world map. Then apply actions in order of priority.
         """
 
         avatars = self.game_state.avatar_manager.active_avatars
-        threads = [Thread(target=self._run_turn_for_avatar,
-                          args=(avatar, player_id_to_serialised_actions[avatar.player_id])) for avatar in avatars]
-
-        [thread.start() for thread in threads]
-        [thread.join() for thread in threads]
+        args = [(avatar, player_id_to_serialised_actions[avatar.player_id]) for avatar in avatars]
+        await self.async_map(self._run_turn_for_avatar, args)
 
         # Waits applied first, then attacks, then moves.
         avatars.sort(key=lambda a: PRIORITIES[type(a.action)])

aimmo-game/simulation/worker_managers/kubernetes_worker_manager.py

@@ -46,7 +46,7 @@ def _make_container(self, player_id):
             env=[client.V1EnvVar(
                 name='DATA_URL',
                 value='%s/player/%d' % (self.game_url, player_id)),
-                kubernetes.client.V1EnvVar(
+                client.V1EnvVar(
                 name='PORT',
                 value='5000')],
             name='aimmo-game-worker',

aimmo-game/simulation/worker_managers/worker_manager.py

@@ -73,7 +73,7 @@ def update_code(self, player):
 
     def add_new_worker(self, player_id):
         worker_url_base = self.create_worker(player_id)
-        self.player_id_to_worker[player_id] = Worker('{}/turn/'.format(worker_url_base))
+        self.player_id_to_worker[player_id] = Worker(f'{worker_url_base}/turn/')
 
     def _parallel_map(self, func, iterable_args):
         with futures.ThreadPoolExecutor() as executor:

aimmo-game/tests/functional/test_damage_pickups_and_effects.py

@@ -2,6 +2,7 @@
 from hypothesis import given, assume
 from hypothesis import strategies as st
 import math
+import asyncio
 
 from .mock_world import MockWorld
 from simulation.location import Location
@@ -19,12 +20,13 @@ def setUp(self):
         _avatar_spawn_cell = self.game.game_state.world_map.get_cell(Location(0, 0))
         self.initial_attack_strength = _avatar_spawn_cell.avatar.attack_strength
         self.cell = self.game.game_state.world_map.get_cell(Location(1, 0))
+        self.loop = asyncio.get_event_loop()
 
     def test_damage_boost_pickup_can_be_picked_up_default(self):
         pickup_created = DamageBoostPickup(self.cell)
         self.cell.pickup = pickup_created
 
-        self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+        self.loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
 
         self.assertEqual(self.cell.avatar, self.game.avatar_manager.get_avatar(1))
         self.assertEqual(len(self.game.avatar_manager.get_avatar(1).effects), 1)
@@ -37,7 +39,7 @@ def test_damage_boost_pickup_can_be_picked_up_custom_integer(self, boost_value):
         pickup_created = DamageBoostPickup(self.cell, boost_value)
         self.cell.pickup = pickup_created
 
-        self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+        self.loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
 
         self.assertEqual(self.cell.avatar, self.game.avatar_manager.get_avatar(1))
         self.assertEqual(len(self.game.avatar_manager.get_avatar(1).effects), 1)
@@ -51,7 +53,7 @@ def test_damage_boost_pickup_can_be_picked_up_custom_floats(self, boost_value):
         pickup_created = DamageBoostPickup(self.cell, boost_value)
         self.cell.pickup = pickup_created
 
-        self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+        self.loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
 
         self.assertEqual(self.cell.avatar, self.game.avatar_manager.get_avatar(1))
         self.assertEqual(len(self.game.avatar_manager.get_avatar(1).effects), 1)
@@ -65,7 +67,7 @@ def test_damage_boost_increases_attack_strength_with_default_integer(self):
         pickup_created = DamageBoostPickup(self.cell)
         self.cell.pickup = pickup_created
 
-        self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+        self.loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
 
         self.assertTrue(self.cell.avatar.attack_strength, self.initial_attack_strength + DAMAGE_BOOST_DEFAULT)
 
@@ -78,6 +80,6 @@ def test_damage_boost_increases_attack_strength_with_custom_integers(self, boost
         pickup_created = DamageBoostPickup(self.cell, boost_value)
         self.cell.pickup = pickup_created
 
-        self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+        self.loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
 
         self.assertTrue(self.cell.avatar.attack_strength, self.initial_attack_strength + boost_value)

aimmo-game/tests/functional/test_effect_expiry.py

@@ -1,4 +1,5 @@
 from unittest import TestCase
+import asyncio
 
 from .mock_world import MockWorld
 
@@ -39,20 +40,21 @@ def test_single_damage_boost_pickup_expiry(self):
         self.assertEqual(self.avatar.attack_strength, 1)
 
         # Avatar moves EAST to (1,0) where pickup is located, then repeats it 5 times.
+        loop = asyncio.get_event_loop()
         for i in range(6):
-            self.game.simulation_runner.run_single_turn(
+            loop.run_until_complete(self.game.simulation_runner.run_single_turn(
                 self.game.avatar_manager.get_player_id_to_serialised_action()
-            )
+            ))
 
         self.assertTrue(isinstance(list(self.avatar.effects)[0], pickup_created.EFFECT))
         self.assertEqual(list(self.avatar.effects)[0]._time_remaining, 5)
         self.assertEqual(self.avatar.attack_strength, 11)
 
         # Run 5 more turns and expect the effect to expire.
         for i in range(5):
-            self.game.simulation_runner.run_single_turn(
+            loop.run_until_complete(self.game.simulation_runner.run_single_turn(
                 self.game.avatar_manager.get_player_id_to_serialised_action()
-            )
+            ))
 
         self.assertEqual(len(self.avatar.effects), 0)
         self.assertEqual(self.avatar.attack_strength, 1)
@@ -67,16 +69,17 @@ def test_single_invulnerability_pickup_pickup_expiry(self):
         self.assertEqual(self.avatar.resistance, 0)
 
         # Avatar moves EAST to (1,0) where pickup is located, then repeats it 5 times.
+        loop = asyncio.get_event_loop()
         for i in range(6):
-            self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+            loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
 
         self.assertTrue(isinstance(list(self.avatar.effects)[0], pickup_created.EFFECT))
         self.assertEqual(list(self.avatar.effects)[0]._time_remaining, 5)
         self.assertEqual(self.avatar.resistance, INVULNERABILITY_RESISTANCE)
 
         # Run 5 more turns and expect the effect to expire.
         for i in range(5):
-            self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+            loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
 
         self.assertEqual(len(self.avatar.effects), 0)
         self.assertEqual(self.avatar.resistance, 0)
@@ -97,9 +100,10 @@ def test_multiple_damage_boost_pickup_expiry(self):
         self.assertEqual(self.avatar.attack_strength, 1)
 
         # Avatar moves EAST to (1,0) where pickup one is located.
-        self.game.simulation_runner.run_single_turn(
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(self.game.simulation_runner.run_single_turn(
             self.game.avatar_manager.get_player_id_to_serialised_action()
-        )
+        ))
 
         self.assertTrue(isinstance(list(self.avatar.effects)[0], pickup_created_one.EFFECT))
         self.assertEqual(len(self.avatar.effects), 1)
@@ -108,29 +112,29 @@ def test_multiple_damage_boost_pickup_expiry(self):
 
         # Move twice to the second pickup.
         for i in range(2):
-            self.game.simulation_runner.run_single_turn(
+            loop.run_until_complete(self.game.simulation_runner.run_single_turn(
                 self.game.avatar_manager.get_player_id_to_serialised_action()
-            )
+            ))
 
         self.assertTrue(isinstance(list(self.avatar.effects)[1], pickup_created_two.EFFECT))
         self.assertEqual(len(self.avatar.effects), 2)
         self.assertEqual(self.avatar.attack_strength, 26)
 
         # Eight turns later, we expect the first effect to expire.
         for i in range(8):
-            self.game.simulation_runner.run_single_turn(
+            loop.run_until_complete(self.game.simulation_runner.run_single_turn(
                 self.game.avatar_manager.get_player_id_to_serialised_action()
-            )
+            ))
 
         self.assertEqual(len(self.avatar.effects), 1)
         self.assertEqual(list(self.avatar.effects)[0]._time_remaining, 2)
         self.assertEqual(self.avatar.attack_strength, 16)
 
         # Two turns later, the second pickup expires too.
         for i in range(2):
-            self.game.simulation_runner.run_single_turn(
+            loop.run_until_complete(self.game.simulation_runner.run_single_turn(
                 self.game.avatar_manager.get_player_id_to_serialised_action()
-            )
+            ))
 
         self.assertEqual(len(self.avatar.effects), 0)
         self.assertEqual(self.avatar.attack_strength, 1)
@@ -151,9 +155,10 @@ def test_multiple_invulnerability_boost_pickup_expiry(self):
         self.assertEqual(self.avatar.resistance, 0)
 
         # Avatar moves EAST to (1,0) where pickup one is located.
-        self.game.simulation_runner.run_single_turn(
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(self.game.simulation_runner.run_single_turn(
             self.game.avatar_manager.get_player_id_to_serialised_action()
-        )
+        ))
 
         self.assertTrue(isinstance(list(self.avatar.effects)[0], pickup_created_one.EFFECT))
         self.assertEqual(len(self.avatar.effects), 1)
@@ -162,29 +167,29 @@ def test_multiple_invulnerability_boost_pickup_expiry(self):
 
         # Move twice to the second pickup.
         for i in range(2):
-            self.game.simulation_runner.run_single_turn(
+            loop.run_until_complete(self.game.simulation_runner.run_single_turn(
                 self.game.avatar_manager.get_player_id_to_serialised_action()
-            )
+            ))
 
         self.assertTrue(isinstance(list(self.avatar.effects)[1], pickup_created_two.EFFECT))
         self.assertEqual(len(self.avatar.effects), 2)
         self.assertEqual(self.avatar.resistance, INVULNERABILITY_RESISTANCE * 2)
 
         # Eight turns later, we expect the first effect to expire.
         for i in range(8):
-            self.game.simulation_runner.run_single_turn(
+            loop.run_until_complete(self.game.simulation_runner.run_single_turn(
                 self.game.avatar_manager.get_player_id_to_serialised_action()
-            )
+            ))
 
         self.assertEqual(len(self.avatar.effects), 1)
         self.assertEqual(list(self.avatar.effects)[0]._time_remaining, 2)
         self.assertEqual(self.avatar.resistance, INVULNERABILITY_RESISTANCE)
 
         # Two turns later, the second pickup expires too.
         for i in range(2):
-            self.game.simulation_runner.run_single_turn(
+            loop.run_until_complete(self.game.simulation_runner.run_single_turn(
                 self.game.avatar_manager.get_player_id_to_serialised_action()
-            )
+            ))
 
         self.assertEqual(len(self.avatar.effects), 0)
         self.assertEqual(self.avatar.resistance, 0)

aimmo-game/tests/functional/test_health_pickups_and_effects.py

@@ -1,5 +1,6 @@
 import random
 from unittest import TestCase
+import asyncio
 
 from hypothesis import given
 import hypothesis.strategies as st
@@ -22,14 +23,15 @@ def setUp(self):
         self.game.game_state.add_avatar(1, Location(0, 0))
         self.cell = self.game.game_state.world_map.get_cell(Location(1, 0))
         self.initial_health = self.game.avatar_manager.get_avatar(1).health
+        self.loop = asyncio.get_event_loop()
 
     def test_health_pickups_and_effects_apply_default(self):
         """
         HealthPickups without any parameter provided.
         """
         self.cell.pickup = HealthPickup(self.cell)
 
-        self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+        self.loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
 
         self.assertEqual(self.cell.avatar, self.game.avatar_manager.get_avatar(1))
         self.assertEqual(self.cell.avatar.health, self.initial_health +
@@ -43,7 +45,7 @@ def test_health_pickups_and_effects_apply_custom_integers(self, restore_value):
         self.setUp()
         self.cell.pickup = HealthPickup(self.cell, restore_value)
 
-        self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+        self.loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
         self.assertEqual(self.cell.avatar, self.game.avatar_manager.get_avatar(1))
 
         if self.initial_health + restore_value > HEALTH_RESTORE_MAX:
@@ -61,7 +63,7 @@ def test_health_pickups_and_effects_apply_custom_floats(self, restore_value):
         self.setUp()
         self.cell.pickup = HealthPickup(self.cell, restore_value)
 
-        self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+        self.loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
         self.assertEqual(self.cell.avatar, self.game.avatar_manager.get_avatar(1))
 
         if self.initial_health + restore_value > HEALTH_RESTORE_MAX:
@@ -81,7 +83,7 @@ def test_health_effect_is_capped_at_HEALTH_RESTORE_MAX(self, restore_value):
         self.setUp()
         self.cell.pickup = HealthPickup(self.cell, restore_value)
 
-        self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action())
+        self.loop.run_until_complete(self.game.simulation_runner.run_single_turn(self.game.avatar_manager.get_player_id_to_serialised_action()))
 
         self.assertEqual(self.cell.avatar, self.game.avatar_manager.get_avatar(1))
         self.assertEqual(self.cell.avatar.health, AVATAR_HEALTH_MAX)