Simplify log copying

Author: john-b-yang

codeclash/games/battlecode/battlecode.py

@@ -5,9 +5,8 @@
 
 from codeclash.constants import DIR_WORK, RESULT_TIE
 from codeclash.games.game import CodeGame, RoundStats
-from codeclash.utils.environment import copy_from_container
 
-BATTLECODE_LOG = "sim.log"
+BC_LOG = "sim.log"
 
 
 class BattleCodeGame(CodeGame):
@@ -24,17 +23,9 @@ def __init__(self, config, *, tournament_id: str, local_output_dir: Path):
             else:
                 self.run_cmd_round += f" --{arg} {val}"
 
-    def copy_logs_from_env(self, round_num):
-        super().copy_logs_from_env(round_num)
-        copy_from_container(
-            container=self.environment,
-            src_path="/testbed/sim.log",
-            dest_path=self.log_round(round_num) / f"sim_{round_num}.log",
-        )
-
-    def get_stats(self, agents: list[Any], round_num: int) -> RoundStats:
+    def get_results(self, agents: list[Any], round_num: int) -> RoundStats:
         winners = []
-        with open(self.log_round(round_num) / f"sim_{round_num}.log") as f:
+        with open(self.log_round(round_num) / BC_LOG) as f:
             lines = f.read().strip().split("\n")
         # Get the third-to-last line which contains the winner info
         winner_line = lines[-3] if len(lines) >= 3 else ""
@@ -62,5 +53,5 @@ def execute_round(self, agents: list[Any]):
         cmd = f"{self.run_cmd_round} {' '.join(args)}"
         self.logger.info(f"Running game: {cmd}")
 
-        response = self.environment.execute(cmd + f" > {BATTLECODE_LOG}")
+        response = self.environment.execute(cmd + f" > {self.log_env / BC_LOG}")
         assert response["returncode"] == 0, response

codeclash/games/battlesnake/battlesnake.py

@@ -8,7 +8,7 @@
 from codeclash.agents.player import Player
 from codeclash.constants import RESULT_TIE
 from codeclash.games.game import CodeGame, RoundStats
-from codeclash.utils.environment import assert_zero_exit_code, copy_from_container
+from codeclash.utils.environment import assert_zero_exit_code
 
 
 class BattleSnakeGame(CodeGame):
@@ -38,18 +38,10 @@ def _wait_for_ports(self, ports: list[int], timeout: float = 3.0) -> None:
 
             time.sleep(0.1)
 
-    def copy_logs_from_env(self, round_num):
-        super().copy_logs_from_env(round_num)
-        copy_from_container(
-            container=self.environment,
-            src_path=f"{self.environment.config.cwd}/game/logs",
-            dest_path=self.log_round(round_num),
-        )
-
-    def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
+    def get_results(self, agents: list[Player], round_num: int) -> RoundStats:
         scores = {}
         for idx in range(self.game_config["sims_per_round"]):
-            with open(self.log_round(round_num) / f"logs/sim_{idx}.jsonl") as f:
+            with open(self.log_round(round_num) / f"sim_{idx}.jsonl") as f:
                 lines = f.read().strip().split("\n")
                 results = json.loads(lines[-1])  # Get the last line which contains the game result
                 winner = RESULT_TIE if results["isDraw"] else results["winnerName"]
@@ -78,7 +70,6 @@ def execute_round(self, agents: list[Player]):
         try:
             cmd = self.run_cmd_round + " " + " ".join(cmd)
             self.logger.info(f"Running game: {cmd}")
-            self.environment.execute("rm -rf logs; mkdir logs", cwd=f"{self.environment.config.cwd}/game")
 
             # Use ThreadPoolExecutor for parallel execution
             with ThreadPoolExecutor(20) as executor:
@@ -99,7 +90,7 @@ def _run_single_simulation(self, cmd: str, idx: int) -> tuple[str, str]:
         """Run a single battlesnake simulation and return log and result outputs."""
         assert_zero_exit_code(
             self.environment.execute(
-                cmd + f" -o logs/sim_{idx}.jsonl",
+                cmd + f" -o {self.log_env / f'sim_{idx}.jsonl'}",
                 cwd=f"{self.environment.config.cwd}/game",
             )
         )

codeclash/games/corewar/corewar.py

@@ -4,7 +4,6 @@
 
 from codeclash.agents.player import Player
 from codeclash.games.game import CodeGame, RoundStats
-from codeclash.utils.environment import copy_from_container
 
 COREWAR_LOG = "sim.log"
 
@@ -22,15 +21,7 @@ def __init__(self, config, *, tournament_id: str, local_output_dir: Path):
             else:
                 self.run_cmd_round += f" -{arg} {val}"
 
-    def copy_logs_from_env(self, round_num: int) -> None:
-        super().copy_logs_from_env(round_num)
-        copy_from_container(
-            container=self.environment,
-            src_path=f"/testbed/{COREWAR_LOG}",
-            dest_path=self.log_round(round_num) / COREWAR_LOG,
-        )
-
-    def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
+    def get_results(self, agents: list[Player], round_num: int) -> RoundStats:
         with open(self.log_round(round_num) / COREWAR_LOG) as f:
             result_output = f.read()
         self.logger.debug(f"Determining winner from result output: {result_output}")
@@ -64,7 +55,11 @@ def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
 
     def execute_round(self, agents: list[Player]):
         args = [f"/{agent.name}/warriors/warrior.red" for agent in agents]
-        cmd = f"{self.run_cmd_round} {shlex.join(args)} -r {self.game_config['sims_per_round']} > {COREWAR_LOG};"
+        cmd = (
+            f"{self.run_cmd_round} {shlex.join(args)} "
+            f"-r {self.game_config['sims_per_round']} "
+            f"> {self.log_env / COREWAR_LOG};"
+        )
         self.logger.info(f"Running game: {cmd}")
         response = self.environment.execute(cmd)
         assert response["returncode"] == 0, response

codeclash/games/dummy/dummy_game.py

@@ -2,22 +2,16 @@
 
 from codeclash.agents.player import Player
 from codeclash.games.game import CodeGame, RoundStats
-from codeclash.utils.environment import assert_zero_exit_code, copy_from_container
+from codeclash.utils.environment import assert_zero_exit_code
+
+DUMMY_LOG = "result.log"
 
 
 class DummyGame(CodeGame):
     name: str = "DummyGame"
 
-    def copy_logs_from_env(self, round_num):
-        super().copy_logs_from_env(round_num)
-        copy_from_container(
-            container=self.environment,
-            src_path="/testbed/result.log",
-            dest_path=self.log_round(round_num) / "result.log",
-        )
-
-    def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
-        with open(self.log_round(round_num) / "result.log") as f:
+    def get_results(self, agents: list[Player], round_num: int) -> RoundStats:
+        with open(self.log_round(round_num) / DUMMY_LOG) as f:
             round_log = f.read()
         lines = round_log.split("FINAL_RESULTS")[-1].splitlines()
 
@@ -37,6 +31,6 @@ def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
 
     def execute_round(self, agents: list[Player]) -> None:
         args = [f"/{agent.name}/main.py" for agent in agents]
-        cmd = f"python engine.py {' '.join(args)} -r {self.game_config['sims_per_round']} > result.log;"
+        cmd = f"python engine.py {' '.join(args)} -r {self.game_config['sims_per_round']} > {self.log_env / DUMMY_LOG};"
         self.logger.info(f"Running game: {cmd}")
         assert_zero_exit_code(self.environment.execute(cmd))

codeclash/games/game.py

@@ -10,7 +10,7 @@
 
 from codeclash.agents.player import Player
 from codeclash.constants import DIR_LOGS, DIR_WORK, GH_ORG
-from codeclash.utils.environment import assert_zero_exit_code, copy_between_containers
+from codeclash.utils.environment import assert_zero_exit_code, copy_between_containers, copy_from_container
 from codeclash.utils.log import get_logger
 
 
@@ -102,6 +102,11 @@ def build_image(self):
     def copy_logs_from_env(self, round_num: int) -> None:
         """Copy logs from the game's environment to the local machine."""
         (self.log_local / "rounds" / str(round_num)).mkdir(parents=True, exist_ok=True)
+        copy_from_container(
+            container=self.environment,
+            src_path=str(self.log_env) + "/.",
+            dest_path=self.log_round(round_num),
+        )
 
     def end(self, cleanup: bool = False):
         if cleanup:
@@ -175,10 +180,10 @@ def run_round(self, agents: list[Player], round_num: int) -> RoundStats:
         self._pre_round_setup(agents)
         self.execute_round(agents)
         self.copy_logs_from_env(round_num)
-        return self.get_stats(agents, round_num)
+        return self.get_results(agents, round_num)
 
     @abstractmethod
-    def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
+    def get_results(self, agents: list[Player], round_num: int) -> RoundStats:
         """Determine the winner of the game based on the result output.
 
         Args:

codeclash/games/huskybench/huskybench.py

@@ -3,9 +3,8 @@
 
 from codeclash.agents.player import Player
 from codeclash.games.game import CodeGame, RoundStats
-from codeclash.utils.environment import copy_from_container
 
-HB_LOG_DIR = Path("/testbed/engine/logs/")
+HB_LOG_ENGINE = "engine.log"
 HB_REGEX_SCORE = re.compile(r"Player\s(\d+)\sdelta\supdated\:[\d\s\-\+\=]+,\smoney\:\s\d+\s\-\>\s(\d+)")
 
 
@@ -26,26 +25,17 @@ def __init__(self, config, *, tournament_id: str, local_output_dir: Path):
             else:
                 self.run_cmd_round += f" --{arg} {val}"
 
-    def copy_logs_from_env(self, round_num):
-        super().copy_logs_from_env(round_num)
-        log_path = self.log_round(round_num)
-        copy_from_container(
-            container=self.environment,
-            src_path=HB_LOG_DIR,
-            dest_path=log_path,
-        )
-
-    def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
+    def get_results(self, agents: list[Player], round_num: int) -> RoundStats:
         map_id_to_agent = {}
         for agent in agents:
-            with open(self.log_round(round_num) / f"logs/{agent.name}.log") as f:
+            with open(self.log_round(round_num) / f"{agent.name}.log") as f:
                 for line in f:
                     if line.startswith("My id:"):
                         agent_id = line.strip().split()[-1]
                         map_id_to_agent[agent_id] = agent.name
         self.logger.info("Agent IDs: " + str(map_id_to_agent))
 
-        with open(self.log_round(round_num) / "logs/engine.log") as f:
+        with open(self.log_round(round_num) / HB_LOG_ENGINE) as f:
             score_updates = [
                 (match.group(1), int(match.group(2))) for l in f.readlines() if (match := HB_REGEX_SCORE.search(l))
             ]
@@ -55,13 +45,12 @@ def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
         return RoundStats(winner=max(agent_to_score, key=agent_to_score.get), scores=agent_to_score)
 
     def execute_round(self, agents: list[Player]):
-        self.environment.execute(f"rm -rf {HB_LOG_DIR}; mkdir -p {HB_LOG_DIR}")
         try:
-            cmd = f"{self.run_cmd_round} > {HB_LOG_DIR / 'engine.log'} &"
+            cmd = f"{self.run_cmd_round} > {self.log_env / HB_LOG_ENGINE} &"
             self.logger.debug(f"Starting game engine with command: {cmd}")
             self.environment.execute(cmd)
             for agent in agents:
-                cmd = f"python client/main.py --port 8000 > {HB_LOG_DIR / f'{agent.name}.log'} &"
+                cmd = f"python client/main.py --port 8000 > {self.log_env / f'{agent.name}.log'} &"
                 self.logger.debug(f"Adding agent with command: {cmd}")
                 self.environment.execute(cmd, cwd=f"/{agent.name}")
         finally:

codeclash/games/robocode/robocode.py

@@ -4,7 +4,9 @@
 
 from codeclash.agents.player import Player
 from codeclash.games.game import CodeGame, RoundStats
-from codeclash.utils.environment import assert_zero_exit_code, copy_from_container, create_file_in_container
+from codeclash.utils.environment import assert_zero_exit_code, create_file_in_container
+
+RC_LOG = "scoreboard.txt"
 
 
 class RoboCodeGame(CodeGame):
@@ -53,16 +55,8 @@ def dict_to_lines(d, prefix=""):
         dict_to_lines(default_battle_config)
         return "\n".join(battle_lines)
 
-    def copy_logs_from_env(self, round_num: int) -> None:
-        super().copy_logs_from_env(round_num)
-        copy_from_container(
-            container=self.environment,
-            src_path="/testbed/logs",
-            dest_path=self.log_round(round_num),
-        )
-
-    def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
-        with open(self.log_round(round_num) / "logs/results.txt") as f:
+    def get_results(self, agents: list[Player], round_num: int) -> RoundStats:
+        with open(self.log_round(round_num) / RC_LOG) as f:
             result_output = f.read()
         print(result_output)
         lines = result_output.strip().split("\n")
@@ -104,6 +98,6 @@ def execute_round(self, agents: list[Player]):
         create_file_in_container(self.environment, content=battle_content, dest_path=f"battles/{battle_file}")
 
         # Run battle with results output to file
-        cmd = f"mkdir -p logs; {self.run_cmd_round} -battle {battle_file} -results logs/results.txt"
+        cmd = f"{self.run_cmd_round} -battle {battle_file} -results {self.log_env / RC_LOG}"
         self.logger.info(f"Running game: {cmd}")
         assert_zero_exit_code(self.environment.execute(cmd))

codeclash/games/robotrumble/robotrumble.py

@@ -5,7 +5,7 @@
 from codeclash.agents.player import Player
 from codeclash.constants import RESULT_TIE
 from codeclash.games.game import CodeGame, RoundStats
-from codeclash.utils.environment import assert_zero_exit_code, copy_from_container
+from codeclash.utils.environment import assert_zero_exit_code
 
 
 class RobotRumbleGame(CodeGame):
@@ -16,18 +16,10 @@ def __init__(self, config, *, tournament_id: str, local_output_dir: Path):
         assert len(config["players"]) == 2, "RobotRumble is a two-player game"
         self.run_cmd_round: str = "./rumblebot run term"
 
-    def copy_logs_from_env(self, round_num: int) -> None:
-        super().copy_logs_from_env(round_num)
-        copy_from_container(
-            container=self.environment,
-            src_path="/testbed/logs",
-            dest_path=self.log_round(round_num),
-        )
-
-    def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
+    def get_results(self, agents: list[Player], round_num: int) -> RoundStats:
         winners = []
         for idx in range(self.game_config.get("sims_per_round", 100)):
-            with open(self.log_round(round_num) / f"logs/sim_{idx}.txt") as f:
+            with open(self.log_round(round_num) / f"sim_{idx}.txt") as f:
                 lines = f.read().strip().split("\n")
 
             # Get the last 2 lines which contain the game result (same as original)
@@ -58,9 +50,8 @@ def get_stats(self, agents: list[Player], round_num: int) -> RoundStats:
         return RoundStats(winner=final_winner, scores=dict(counts))
 
     def execute_round(self, agents: list[Player]):
-        self.environment.execute("rm -rf logs; mkdir -p logs")
         args = [f"/{agent.name}/robot.py" for agent in agents]
         cmd = f"{self.run_cmd_round} {shlex.join(args)}"
         self.logger.info(f"Running game: {cmd}")
         for idx in range(self.game_config.get("sims_per_round", 100)):
-            assert_zero_exit_code(self.environment.execute(cmd + f" > logs/sim_{idx}.txt"))
+            assert_zero_exit_code(self.environment.execute(cmd + f" > {self.log_env / f'sim_{idx}.txt'}"))