Merge pull request #65 from ImogenBits/local_docker

Isolate docker build environments

Author: Benezivas

algobattle/__init__.py

@@ -1,4 +1,4 @@
 __title__ = 'Algorithmic Battle'
-__version__ = '3.0.2'
+__version__ = '3.1.0'
 __author__ = 'Jan Dreier, Henri Lotze'
 __license__ = 'MIT'

algobattle/match.py

@@ -1,4 +1,5 @@
 """Match class, provides functionality for setting up and executing battles between given teams."""
+from pathlib import Path
 import subprocess
 import os
 
@@ -9,7 +10,7 @@
 import algobattle.sighandler as sigh
 from algobattle.team import Team
 from algobattle.problem import Problem
-from algobattle.util import run_subprocess, update_nested_dict
+from algobattle.util import build_image, run_subprocess, update_nested_dict
 from algobattle.subject import Subject
 from algobattle.observer import Observer
 from algobattle.battle_wrappers.averaged import Averaged
@@ -25,9 +26,16 @@ class Match(Subject):
     generating_team = None
     solving_team = None
     battle_wrapper = None
+    creationflags = 0
 
     def __init__(self, problem: Problem, config_path: str, teams: list,
-                 runtime_overhead=0, approximation_ratio=1.0, cache_docker_containers=True) -> None:
+                 runtime_overhead=0, approximation_ratio=1.0,
+                 cache_docker_containers=True, unsafe_build: bool = False) -> None:
+
+        if os.name != 'posix':
+            self.creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
+        else:
+            self.creationflags = 0
 
         config = configparser.ConfigParser()
         logger.debug('Using additional configuration options from file "%s".', config_path)
@@ -43,7 +51,7 @@ def __init__(self, problem: Problem, config_path: str, teams: list,
         self.config = config
         self.approximation_ratio = approximation_ratio
 
-        self.build_successful = self._build(teams, cache_docker_containers)
+        self.build_successful = self._build(teams, cache_docker_containers, unsafe_build)
 
         if approximation_ratio != 1.0 and not problem.approximable:
             logger.error('The given problem is not approximable and can only be run with an approximation ratio of 1.0!')
@@ -92,11 +100,8 @@ def wrapper(self, *args, **kwargs):
     def docker_running(function: Callable) -> Callable:
         """Ensure that internal methods are only callable if docker is running."""
         def wrapper(self, *args, **kwargs):
-            creationflags = 0
-            if os.name != 'posix':
-                creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
             docker_running = subprocess.Popen(['docker', 'info'], stdout=subprocess.PIPE,
-                                              stderr=subprocess.PIPE, creationflags=creationflags)
+                                              stderr=subprocess.PIPE, creationflags=self.creationflags)
             _ = docker_running.communicate()
             if docker_running.returncode:
                 logger.error('Could not connect to the docker daemon. Is docker running?')
@@ -132,7 +137,7 @@ def update_match_data(self, new_data: dict) -> bool:
         return True
 
     @docker_running
-    def _build(self, teams: list, cache_docker_containers=True) -> bool:
+    def _build(self, teams: list, cache_docker_containers=True, unsafe_build: bool = False) -> bool:
         """Build docker containers for the given generators and solvers of each team.
 
         Any team for which either the generator or solver does not build successfully
@@ -144,6 +149,8 @@ def _build(self, teams: list, cache_docker_containers=True) -> bool:
             List of Team objects.
         cache_docker_containers : bool
             Flag indicating whether to cache built docker containers.
+        unsafe_build: bool
+            If set, images are not removed after building, risking exposure to build process of other teams.
 
         Returns
         -------
@@ -169,36 +176,31 @@ def _build(self, teams: list, cache_docker_containers=True) -> bool:
 
         self.single_player = (len(teams) == 1)
 
+        image_archives: list = []
         for team in teams:
             build_commands = []
-            build_commands.append(base_build_command + ["solver-" + str(team.name), team.solver_path])
-            build_commands.append(base_build_command + ["generator-" + str(team.name), team.generator_path])
+            build_commands.append(("solver-" + str(team.name), team.solver_path))
+            build_commands.append(("generator-" + str(team.name), team.generator_path))
 
             build_successful = True
-            for command in build_commands:
-                logger.debug('Building docker container with the following command: {}'.format(command))
-                creationflags = 0
-                if os.name != 'posix':
-                    creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
-                with subprocess.Popen(command, stdout=subprocess.PIPE,
-                                      stderr=subprocess.PIPE, creationflags=creationflags) as process:
-                    try:
-                        output, _ = process.communicate(timeout=self.timeout_build)
-                        logger.debug(output.decode(errors="ignore"))
-                    except subprocess.TimeoutExpired:
-                        process.kill()
-                        process.wait()
-                        logger.error('Build process for {} ran into a timeout!'.format(command[5]))
-                        build_successful = False
-                    if process.returncode != 0:
-                        process.kill()
-                        process.wait()
-                        logger.error('Build process for {} failed!'.format(command[5]))
-                        build_successful = False
-            if not build_successful:
-                logger.error("Removing team {} as their containers did not build successfully.".format(team.name))
-                self.team_names.remove(team.name)
-
+            for name, path in build_commands:
+                logger.debug(f"Building docker container with the following command: {base_build_command} {name} {path}")
+                build_successful = build_image(base_build_command, name, path, timeout=self.timeout_build)
+                if not build_successful:
+                    logger.error("Removing team {} as their containers did not build successfully.".format(team.name))
+                    self.team_names.remove(team.name)
+                    if name.startswith("generator") and not unsafe_build:
+                        image_archives.pop().unlink()
+                    break
+                elif not unsafe_build:
+                    path = Path(path) / f"{name}-archive.tar"
+                    subprocess.run(["docker", "save", name, "-o", str(path)], stdout=subprocess.PIPE)
+                    image_archives.append(path)
+                    subprocess.run(["docker", "image", "rm", "-f", name], stdout=subprocess.PIPE)
+
+        for path in image_archives:
+            subprocess.run(["docker", "load", "-q", "-i", str(path)], stdout=subprocess.PIPE)
+            path.unlink()
         return len(self.team_names) > 0
 
     @build_successful
@@ -296,6 +298,9 @@ def run(self, battle_type: str = 'iterated', rounds: int = 5, iterated_cap: int
                 self.solving_team = pair[1]
                 self.battle_wrapper.wrapper(self, options)
 
+        for team in self.team_names:
+            for role in ("generator", "solver"):
+                subprocess.run(["docker", "image", "rm", "-f", f"{role}-{team}"], stdout=subprocess.PIPE)
         return self.match_data
 
     @docker_running

algobattle/util.py

@@ -1,6 +1,7 @@
 """Collection of utility functions."""
 import os
 import logging
+from pathlib import Path
 import timeit
 import subprocess
 import importlib.util
@@ -13,7 +14,12 @@
 from algobattle.problem import Problem
 
 
-logger = logging.getLogger('algobattle.util')
+logger = logging.getLogger("algobattle.util")
+
+
+creationflags = 0
+if os.name != "posix":
+    creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
 
 
 def import_problem_from_path(problem_path: str) -> Problem:
@@ -50,21 +56,24 @@ def measure_runtime_overhead() -> float:
         I/O overhead in seconds, rounded to two decimal places.
     """
     problem = DelaytestProblem.Problem()
-    config_path = os.path.join(os.path.dirname(os.path.abspath(algobattle.__file__)), 'config', 'config_delaytest.ini')
+    config_path = os.path.join(os.path.dirname(os.path.abspath(algobattle.__file__)), "config", "config_delaytest.ini")
     delaytest_path = DelaytestProblem.__file__[:-12]  # remove /__init__.py
-    delaytest_team = algobattle.team.Team(0, delaytest_path + '/generator', delaytest_path + '/solver')
+    delaytest_team = algobattle.team.Team(0, delaytest_path + "/generator", delaytest_path + "/solver")
 
     match = algobattle.match.Match(problem, config_path, [delaytest_team])
 
     if not match.build_successful:
-        logger.warning('Building a match for the time tolerance calculation failed!')
+        logger.warning("Building a match for the time tolerance calculation failed!")
         return 0
 
     overheads = []
     for i in range(5):
         sigh.latest_running_docker_image = "generator0"
-        _, timeout = run_subprocess(match.generator_base_run_command(match.space_generator) + ["generator0"],
-                                    input=str(50 * i).encode(), timeout=match.timeout_generator)
+        _, timeout = run_subprocess(
+            match.generator_base_run_command(match.space_generator) + ["generator0"],
+            input=str(50 * i).encode(),
+            timeout=match.timeout_generator,
+        )
         if not timeout:
             timeout = match.timeout_generator
         overheads.append(float(timeout))
@@ -126,6 +135,46 @@ def run_subprocess(run_command: list, input: bytes, timeout: float, suppress_out
     return raw_output, elapsed_time
 
 
+def build_image(base_cmd: list, name: str, path: Path, timeout: float) -> bool:
+    """Builds a docker image of the given name using the base_command.
+
+    Parameters
+    ----------
+    base_cmd : list
+        A list containing a shared prefix of a command.
+    name : str
+        The intended name (tag) of the image.
+    path: Path
+        Path to the image.
+    timeout: float
+        Timeout after which the build process is terminated preemptively.
+
+    Returns
+    -------
+    bool
+        Determines whether an image with the given tag is now built and thus accessible.
+    """
+    path = Path(path)
+    build_successful = True
+    with subprocess.Popen(
+        base_cmd + [name, str(path)], stdout=subprocess.PIPE, stderr=subprocess.PIPE, creationflags=creationflags
+    ) as process:
+        try:
+            output, _ = process.communicate(timeout=timeout)
+            logger.debug(output.decode())
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait()
+            logger.error(f"Build process for {name} ran into a timeout!")
+            build_successful = False
+        if process.returncode != 0:
+            process.kill()
+            process.wait()
+            logger.error(f"Build process for {name} failed!")
+            build_successful = False
+    return build_successful
+
+
 def update_nested_dict(current_dict, updates):
     """Update a nested dictionary with new data recursively.
 

scripts/battle

@@ -95,6 +95,7 @@ if __name__ == "__main__":
     parser.add_option('--silent', dest='silent', action='store_true', help='Disable forking the logging output to stderr.')
     parser.add_option('--no_overhead_calculation', dest='no_overhead_calculation', action='store_true', help='If set, the program does not benchmark the I/O of the host system to calculate the runtime overhead when started.')
     parser.add_option('--ui', dest='display_ui', action='store_true', help='If set, the program sets the --silent option and displays a small ui on STDOUT that shows the progress of the battles.')
+    parser.add_option('--unsafe_build', dest='unsafe_build', action='store_true', help='If set, the build processes of the docker containers will not be isolated from each other.')
 
     (options, args) = parser.parse_args()
 
@@ -140,7 +141,7 @@ if __name__ == "__main__":
         runtime_overhead = measure_runtime_overhead()
         logger.info('Maximal measured runtime overhead is at {} seconds. Adding this amount to the configured runtime.'.format(runtime_overhead))
 
-    match = Match(problem, options.config, teams, runtime_overhead=runtime_overhead, approximation_ratio=options.approximation_ratio)
+    match = Match(problem, options.config, teams, runtime_overhead=runtime_overhead, approximation_ratio=options.approximation_ratio, unsafe_build=options.unsafe_build)
 
     if not match.build_successful:
         logger.critical('Building the match object failed, exiting!')