Do not recreated container each time it is needed

tagging/apply_tags.py

@@ -4,6 +4,7 @@
 import argparse
 import logging
 from plumbum.cmd import docker
+from docker_runner import DockerRunner
 from images_hierarchy import ALL_IMAGES
 
 
@@ -23,11 +24,14 @@ def apply_tags(short_image_name, owner):
     logger.info(f"Applying tags for image: {short_image_name}")
     taggers = get_all_taggers(short_image_name)
 
-    for tagger in taggers:
+    image = f"{owner}/{short_image_name}:latest"
-        tagger_name = tagger.__name__
+
-        tag_value = tagger.tag_value(short_image_name, owner)
+    with DockerRunner(image) as container:
-        logger.info(f"Applying tag tagger_name: {tagger_name} tag_value: {tag_value}")
+        for tagger in taggers:
-        docker["tag", f"{owner}/{short_image_name}:latest", f"{owner}/{short_image_name}:{tag_value}"]()
+            tagger_name = tagger.__name__
+            tag_value = tagger.tag_value(container)
+            logger.info(f"Applying tag tagger_name: {tagger_name} tag_value: {tag_value}")
+            docker["tag", f"{owner}/{short_image_name}:latest", f"{owner}/{short_image_name}:{tag_value}"]()
 
 
 if __name__ == "__main__":

tagging/docker_runner.py

@@ -27,3 +27,12 @@ class DockerRunner:
         if self.container:
             self.container.remove(force=True)
             logger.info(f"Container {self.container.name} removed")
+
+
+def run_simple_command(container, cmd):
+    logger.info(f"Running cmd: '{cmd}' on container: {container}")
+    out = container.exec_run(cmd)
+    assert out.exit_code == 0, f"Command: {cmd} failed"
+    result = out.output.decode("utf-8").strip()
+    logger.info(f"Command result: {result}")
+    return result

tagging/taggers.py

@@ -2,102 +2,92 @@
 # Distributed under the terms of the Modified BSD License.
 import logging
 from git_helper import GitHelper
-from docker_runner import DockerRunner
+from docker_runner import run_simple_command
 
 
 logger = logging.getLogger(__name__)
 
 
-def _get_program_version(short_image_name, owner, program):
+def _get_program_version(container, program):
-    image = f"{owner}/{short_image_name}:latest"
+    return run_simple_command(container, f"{program} --version")
-    cmd = f"{program} --version"
-    with DockerRunner(image) as cont:
-        logger.info(f"Running cmd: '{cmd}' on image: {image}")
-        # exit code doesn't have to be 0, so we won't check it
-        return cont.exec_run(cmd).output.decode("utf-8").strip()
 
 
-def _get_env_variable(short_image_name, owner, variable):
+def _get_env_variable(container, variable):
-    image = f"{owner}/{short_image_name}:latest"
+    env = run_simple_command(container, "env").split()
-    cmd = "env"
+    for env_entry in env:
-    with DockerRunner(image) as cont:
+        if env_entry.startswith(variable):
-        logger.info(f"Running 'env' on image: {image} to get environment")
+            return env_entry[len(variable) + 1:]
-        # exit code doesn't have to be 0, so we won't check it
+    raise KeyError(variable)
-        env = cont.exec_run(cmd).output.decode("utf-8").strip().splitlines()
-        for env_entry in env:
-            if env_entry.startswith(variable):
-                return env_entry[len(variable) + 1:]
-        raise KeyError(variable)
 
 
 class TaggerInterface:
     """HooksInterface for all hooks common interface"""
     @staticmethod
-    def tag_value(image):
+    def tag_value(container):
         raise NotImplementedError
 
 
 class SHATagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
         return GitHelper.commit_hash()[:12]
 
 
 class PythonVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
-        return "python-" + _get_program_version(short_image_name, owner, "python").split()[1]
+        return "python-" + _get_program_version(container, "python").split()[1]
 
 
 class JupyterNotebookVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
-        return "notebook-" + _get_program_version(short_image_name, owner, "jupyter-notebook")
+        return "notebook-" + _get_program_version(container, "jupyter-notebook")
 
 
 class JupyterLabVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
-        return "lab-" + _get_program_version(short_image_name, owner, "jupyter-lab")
+        return "lab-" + _get_program_version(container, "jupyter-lab")
 
 
 class JupyterHubVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
-        return "hub-" + _get_program_version(short_image_name, owner, "jupyterhub")
+        return "hub-" + _get_program_version(container, "jupyterhub")
 
 
 class RVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
-        return "r-" + _get_program_version(short_image_name, owner, "R")
+        return "r-" + _get_program_version(container, "R")
 
 
 class TensorflowVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
-        return "tensorflow-" + _get_program_version(short_image_name, owner, "tensorflow")
+        return "tensorflow-" + _get_program_version(container, "tensorflow")
 
 
 class JuliaVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
-        return "julia-" + _get_program_version(short_image_name, owner, "julia")
+        return "julia-" + _get_program_version(container, "julia")
 
 
 class SparkVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
-        return "spark-" + _get_env_variable(short_image_name, owner, "APACHE_SPARK_VERSION")
+        return "spark-" + _get_env_variable(container, "APACHE_SPARK_VERSION")
 
 
 class HadoopVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
-        return "hadoop-" + _get_env_variable(short_image_name, owner, "HADOOP_VERSION")
+        return "hadoop-" + _get_env_variable(container, "HADOOP_VERSION")
 
 
 class JavaVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(short_image_name, owner):
+    def tag_value(container):
-        return "java-" + _get_program_version(short_image_name, owner, "java").split()[1]
+        return "java-" + _get_program_version(container, "java").split()[1]