diff --git a/tagging/apply_tags.py b/tagging/apply_tags.py index 8b4e0998..fee455d1 100755 --- a/tagging/apply_tags.py +++ b/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: - tagger_name = tagger.__name__ - tag_value = tagger.tag_value(short_image_name, owner) - 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}"]() + image = f"{owner}/{short_image_name}:latest" + + with DockerRunner(image) as container: + for tagger in taggers: + 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__": diff --git a/tagging/docker_runner.py b/tagging/docker_runner.py index d927a7c0..b6edb03b 100644 --- a/tagging/docker_runner.py +++ b/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 diff --git a/tagging/taggers.py b/tagging/taggers.py index 8adea6ee..03351025 100644 --- a/tagging/taggers.py +++ b/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): - image = f"{owner}/{short_image_name}:latest" - 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_program_version(container, program): + return run_simple_command(container, f"{program} --version") -def _get_env_variable(short_image_name, owner, variable): - image = f"{owner}/{short_image_name}:latest" - cmd = "env" - with DockerRunner(image) as cont: - logger.info(f"Running 'env' on image: {image} to get environment") - # exit code doesn't have to be 0, so we won't check it - 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) +def _get_env_variable(container, variable): + env = run_simple_command(container, "env").split() + 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): - return "python-" + _get_program_version(short_image_name, owner, "python").split()[1] + def tag_value(container): + return "python-" + _get_program_version(container, "python").split()[1] class JupyterNotebookVersionTagger(TaggerInterface): @staticmethod - def tag_value(short_image_name, owner): - return "notebook-" + _get_program_version(short_image_name, owner, "jupyter-notebook") + def tag_value(container): + return "notebook-" + _get_program_version(container, "jupyter-notebook") class JupyterLabVersionTagger(TaggerInterface): @staticmethod - def tag_value(short_image_name, owner): - return "lab-" + _get_program_version(short_image_name, owner, "jupyter-lab") + def tag_value(container): + return "lab-" + _get_program_version(container, "jupyter-lab") class JupyterHubVersionTagger(TaggerInterface): @staticmethod - def tag_value(short_image_name, owner): - return "hub-" + _get_program_version(short_image_name, owner, "jupyterhub") + def tag_value(container): + return "hub-" + _get_program_version(container, "jupyterhub") class RVersionTagger(TaggerInterface): @staticmethod - def tag_value(short_image_name, owner): - return "r-" + _get_program_version(short_image_name, owner, "R") + def tag_value(container): + return "r-" + _get_program_version(container, "R") class TensorflowVersionTagger(TaggerInterface): @staticmethod - def tag_value(short_image_name, owner): - return "tensorflow-" + _get_program_version(short_image_name, owner, "tensorflow") + def tag_value(container): + return "tensorflow-" + _get_program_version(container, "tensorflow") class JuliaVersionTagger(TaggerInterface): @staticmethod - def tag_value(short_image_name, owner): - return "julia-" + _get_program_version(short_image_name, owner, "julia") + def tag_value(container): + return "julia-" + _get_program_version(container, "julia") class SparkVersionTagger(TaggerInterface): @staticmethod - def tag_value(short_image_name, owner): - return "spark-" + _get_env_variable(short_image_name, owner, "APACHE_SPARK_VERSION") + def tag_value(container): + return "spark-" + _get_env_variable(container, "APACHE_SPARK_VERSION") class HadoopVersionTagger(TaggerInterface): @staticmethod - def tag_value(short_image_name, owner): - return "hadoop-" + _get_env_variable(short_image_name, owner, "HADOOP_VERSION") + def tag_value(container): + return "hadoop-" + _get_env_variable(container, "HADOOP_VERSION") class JavaVersionTagger(TaggerInterface): @staticmethod - def tag_value(short_image_name, owner): - return "java-" + _get_program_version(short_image_name, owner, "java").split()[1] + def tag_value(container): + return "java-" + _get_program_version(container, "java").split()[1]