album-docker 0.2.0__tar.gz

album_docker-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021, album developers.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

album_docker-0.2.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: album_docker
+Version: 0.2.0
+Summary: album plugin for building docker images from solutions
+Home-page: https://gitlab.com/album-app/plugins/album-docker
+Author: Lucas Rieckert, Jan Philipp Albrecht, Deborah Schmidt
+Maintainer: Lucas Rieckert, Jan Philipp Albrecht, Deborah Schmidt
+Maintainer-email: album@kyleharrington.com
+License: MIT
+Project-URL: Source, https://gitlab.com/album-app/plugins/album-docker
+Project-URL: Tracker, https://gitlab.com/album-app/album/issues
+Keywords: virtual,environments,imaging,data analysis
+Platform: any
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: album<0.13.0,>=0.11.0
+Requires-Dist: docker
+Dynamic: license-file
+
+# Album plugin for creating Docker images from solutions
+
+Plugin for creating Docker images from Album solutions.
+
+The plugin allows you to package an Album solution into a Docker image, which can then be used to run the solution in a containerized environment,
+containing all necessary dependencies and configurations.
+Behavior of the container will be similar to the `album run` command, but the solution will be installed in a
+Docker image instead of the local environment.
+This is particularly useful for ensuring that the solution runs with all its dependencies in a consistent environment.
+
+## Installation:
+
+1. [Install Album](https://docs.album.solutions/en/latest/installation-instructions.html#)
+2. Activate the album environment:
+
+```
+conda activate album
+```
+
+3. Install the album docker plugin:
+
+```
+pip install album-docker
+```
+
+## Usage:
+
+To create a docker image which contains Album with the passed solution installed run following command:
+
+If your solution is in a directory, you can copy the solution.py file into a new folder, e.g. `mySolutionFolder`, and then run the command from that folder.
+
+```
+mkdir mySolutionFolder
+cp /path/to/your/solution.py mySolutionFolder/
+```
+
+Then run the following command to create the docker image:
+
+```
+
+album docker --solution mySolutionFolder --output_path /your/output/path
+```
+
+The outcome will be a docker image with the tag `<group>:<name>:<version>` of the solution, where `<group>`, `<name>`, and `<version>` are defined in the solution.py file.
+
+### Input parameter:
+
+- solution: The album solution which should be packed into an executable.
+- output_path: The path where the executable should be saved
+- install-flags: Flags to pass to the album install command, e.g. '--allow-recursive'.
+- install-deps: Dependencies to install in the docker image, e.g. 'gxx' or 'gxx cmake'. This line will be added to the Dockerfile as a RUN command, so you can use any command that is valid in a Dockerfile.
+
+## Example:
+
+```
+album docker --solution mySolutionFolder --output_path /your/output/path --install-flags="--allow-recursive" --install-deps="apt update && apt install -y gxx cmake"
+```
+
+This will create a docker image with the tag <group:name:version> of the solution.
+Inside the image, the solution is installed together with the dependencies gxx and cmake.

album_docker-0.2.0/README.md

@@ -0,0 +1,60 @@
+# Album plugin for creating Docker images from solutions
+
+Plugin for creating Docker images from Album solutions.
+
+The plugin allows you to package an Album solution into a Docker image, which can then be used to run the solution in a containerized environment,
+containing all necessary dependencies and configurations.
+Behavior of the container will be similar to the `album run` command, but the solution will be installed in a
+Docker image instead of the local environment.
+This is particularly useful for ensuring that the solution runs with all its dependencies in a consistent environment.
+
+## Installation:
+
+1. [Install Album](https://docs.album.solutions/en/latest/installation-instructions.html#)
+2. Activate the album environment:
+
+```
+conda activate album
+```
+
+3. Install the album docker plugin:
+
+```
+pip install album-docker
+```
+
+## Usage:
+
+To create a docker image which contains Album with the passed solution installed run following command:
+
+If your solution is in a directory, you can copy the solution.py file into a new folder, e.g. `mySolutionFolder`, and then run the command from that folder.
+
+```
+mkdir mySolutionFolder
+cp /path/to/your/solution.py mySolutionFolder/
+```
+
+Then run the following command to create the docker image:
+
+```
+
+album docker --solution mySolutionFolder --output_path /your/output/path
+```
+
+The outcome will be a docker image with the tag `<group>:<name>:<version>` of the solution, where `<group>`, `<name>`, and `<version>` are defined in the solution.py file.
+
+### Input parameter:
+
+- solution: The album solution which should be packed into an executable.
+- output_path: The path where the executable should be saved
+- install-flags: Flags to pass to the album install command, e.g. '--allow-recursive'.
+- install-deps: Dependencies to install in the docker image, e.g. 'gxx' or 'gxx cmake'. This line will be added to the Dockerfile as a RUN command, so you can use any command that is valid in a Dockerfile.
+
+## Example:
+
+```
+album docker --solution mySolutionFolder --output_path /your/output/path --install-flags="--allow-recursive" --install-deps="apt update && apt install -y gxx cmake"
+```
+
+This will create a docker image with the tag <group:name:version> of the solution.
+Inside the image, the solution is installed together with the dependencies gxx and cmake.

album_docker-0.2.0/setup.cfg

@@ -0,0 +1,55 @@
+[metadata]
+name = album_docker
+version = 0.2.0
+description = album plugin for building docker images from solutions
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://gitlab.com/album-app/plugins/album-docker
+author = Lucas Rieckert, Jan Philipp Albrecht, Deborah Schmidt
+maintainer = Lucas Rieckert, Jan Philipp Albrecht, Deborah Schmidt
+maintainer_email = album@kyleharrington.com
+license = MIT
+license_file = LICENSE
+platforms = any
+classifiers = 
+	Development Status :: 3 - Alpha
+	License :: OSI Approved :: MIT License
+	Operating System :: MacOS :: MacOS X
+	Operating System :: Microsoft :: Windows
+	Operating System :: POSIX
+	Programming Language :: Python :: 3.8
+	Programming Language :: Python :: 3.9
+	Programming Language :: Python :: Implementation :: PyPy
+	Topic :: Utilities
+keywords = virtual, environments, imaging, data analysis
+project_urls = 
+	Source=https://gitlab.com/album-app/plugins/album-docker
+	Tracker=https://gitlab.com/album-app/album/issues
+
+[options]
+package_dir = 
+	=src
+packages = find_namespace:
+include_package_data = True
+install_requires = 
+	album>=0.11.0,<0.13.0
+	docker
+python_requires = >=3.7
+
+[options.package_data]
+* = *.txt, *.rst, *.sh, *.sql, *.json
+
+[options.packages.find]
+where = src
+
+[options.entry_points]
+console_parsers_album = 
+	docker=album.docker_plugin.argument_parsing:create_docker_parser
+
+[flake8]
+max-line-length = 120
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

album_docker-0.2.0/setup.py

@@ -0,0 +1,4 @@
+"""Setup script for packaging the album Docker plugin."""
+from setuptools import setup
+
+setup()

album_docker-0.2.0/src/album/__init__.py

@@ -0,0 +1,4 @@
+"""This package is a namespace package for the album project."""
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)

album_docker-0.2.0/src/album/docker_plugin/__init__.py

@@ -0,0 +1 @@
+"""Docker plugin for Album."""

album_docker-0.2.0/src/album/docker_plugin/argument_parsing.py

@@ -0,0 +1,46 @@
+"""Album Docker Plugin Argument Parsing Module."""
+from pathlib import Path
+
+from album.api import Album
+
+
+def album_docker(album_instance: Album, args):
+    """Launch the building of a Docker image from the input solution."""
+    from album.docker_plugin.build_image import run
+
+    run(album_instance, args)
+
+
+def create_docker_parser(parser):
+    """Create the argument parser for the Docker plugin."""
+    p = parser.create_command_parser(
+        "docker",
+        album_docker,
+        "Launch the building of a docker image from the input solution.",
+    )
+    p.add_argument(
+        "--solution",
+        type=str,
+        help="Path for the solution file or coordinates of the solution (group:name:version)",
+    )
+    p.add_argument(
+        "--output",
+        type=str,
+        required=True,
+        default=str(Path.home()),
+        help="The path where the build image should be saved",
+    )
+    p.add_argument(
+        "--install-flags",
+        type=str,
+        default="",
+        required=False,
+        help="Flags to pass to the solution install command",
+    )
+    p.add_argument(
+        "--install-deps",
+        type=str,
+        default="",
+        required=False,
+        help="Dependencies to install in the docker image, e.g. 'gxx' or 'gxx cmake'",
+    )

album_docker-0.2.0/src/album/docker_plugin/build_image.py

@@ -0,0 +1,111 @@
+"""Module to build a Docker image for an Album solution."""
+import shutil
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import docker
+
+import album.core.model.default_values
+from album.api import Album
+from album.runner.album_logging import get_active_logger
+
+CUR_DIR = Path(__file__).parent
+
+
+def create_dockerfile(output_path, install_deps=None, install_flags=None):
+    """Create a Dockerfile for the Album solution."""
+    if install_flags is None:
+        install_flags = ""
+    if install_deps is not None and install_deps != "":
+        install_deps = "RUN %s" % install_deps
+    dockerfile_str = f"""FROM albumsolutions/album:{album.core.__version__}
+COPY . /solution
+SHELL ["/bin/bash", "-l", "-c"]
+RUN chmod +x /solution/solution_entrypoint.sh
+RUN apt update
+RUN apt install -y dos2unix
+RUN dos2unix /solution/solution_entrypoint.sh
+{install_deps}
+RUN album install {install_flags} /solution
+ENTRYPOINT ["./solution/solution_entrypoint.sh"]
+"""
+    dockerfile_path = Path(output_path).joinpath("Dockerfile")
+    with open(dockerfile_path, "w") as file:
+        file.write(dockerfile_str)
+    return dockerfile_path
+
+
+def build_image(coordinates, context, output):
+    """Build a Docker image from the given context and save it to the output directory."""
+    coordinates = str(coordinates).replace(":", "_").lower()
+    image_tar_name = "%s_image.tar" % coordinates
+    client = docker.from_env(timeout=1200)
+    image, build_output = client.images.build(path=context, tag=coordinates, rm=True)
+
+    for chunk in build_output:
+        if "stream" in chunk:
+            get_active_logger().info(chunk["stream"].strip())
+        elif "error" in chunk:
+            get_active_logger().error(chunk["error"].strip())
+
+    with open(Path(output).joinpath(image_tar_name), "wb") as file:
+        for chunk in image.save():
+            file.write(chunk)
+
+
+def get_solution_info(album_instance: Album, solution):
+    """Get the solution path and coordinates from the Album instance."""
+    if not Path(solution).exists():
+        path = album_instance.resolve(str(solution)).path()
+    else:
+        path = solution
+    coordinates = album_instance.resolve(str(solution)).coordinates()
+    return path, coordinates
+
+
+def copy_to_context(src, target):
+    """Copy the solution files to the Docker build context."""
+    if Path(src).is_dir():
+        for file in Path(src).glob("*"):
+            if Path(file).is_file():
+                shutil.copy(Path(file), target)
+            else:
+                shutil.copytree(Path(file), Path(target).joinpath(Path(file).name))
+    else:
+        shutil.copy(src, target)
+
+    # copy solution_entrypoint.sh to target
+    entrypoint_script = CUR_DIR.joinpath("solution_entrypoint.sh")
+    if entrypoint_script.exists():
+        shutil.copy(entrypoint_script, target)
+    else:
+        get_active_logger().error("solution_entrypoint.sh not found in %s" % CUR_DIR)
+        raise FileNotFoundError("solution_entrypoint.sh not found in %s" % CUR_DIR)
+
+
+def run(album_instance: Album, args):
+    """Run the Docker image build process for the given Album solution."""
+    if not (Path(args.output).exists()):
+        Path(args.output).mkdir()
+
+    solution_path, coordinates = get_solution_info(album_instance, args.solution)
+
+    get_active_logger().info("Building an docker image which runs the solution.")
+    get_active_logger().info(f"solution: {coordinates} at {solution_path}")
+    get_active_logger().info("output directory: %s" % args.output)
+    get_active_logger().info("Using install flags: %s" % args.install_flags)
+    get_active_logger().info("Using install dependencies: %s" % args.install_deps)
+    get_active_logger().info(
+        "This may take a while. Logs will be printed after the build is finished. Please be patient."
+    )
+
+    with TemporaryDirectory() as tmpdir:
+        get_active_logger().debug("Temporary directory for docker build: %s" % tmpdir)
+        copy_to_context(solution_path, Path(tmpdir))
+        get_active_logger().debug(
+            "Copied solution %s to temporary directory." % solution_path
+        )
+        create_dockerfile(Path(tmpdir), args.install_deps, args.install_flags)
+        get_active_logger().debug("Created Dockerfile in temporary directory.")
+        build_image(coordinates, tmpdir, args.output)
+        get_active_logger().info("Docker image built successfully.")

album_docker-0.2.0/src/album/docker_plugin/solution_entrypoint.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+source /root/.bashrc
+album run /solution/solution.py "$@"

album_docker-0.2.0/src/album_docker.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: album_docker
+Version: 0.2.0
+Summary: album plugin for building docker images from solutions
+Home-page: https://gitlab.com/album-app/plugins/album-docker
+Author: Lucas Rieckert, Jan Philipp Albrecht, Deborah Schmidt
+Maintainer: Lucas Rieckert, Jan Philipp Albrecht, Deborah Schmidt
+Maintainer-email: album@kyleharrington.com
+License: MIT
+Project-URL: Source, https://gitlab.com/album-app/plugins/album-docker
+Project-URL: Tracker, https://gitlab.com/album-app/album/issues
+Keywords: virtual,environments,imaging,data analysis
+Platform: any
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: album<0.13.0,>=0.11.0
+Requires-Dist: docker
+Dynamic: license-file
+
+# Album plugin for creating Docker images from solutions
+
+Plugin for creating Docker images from Album solutions.
+
+The plugin allows you to package an Album solution into a Docker image, which can then be used to run the solution in a containerized environment,
+containing all necessary dependencies and configurations.
+Behavior of the container will be similar to the `album run` command, but the solution will be installed in a
+Docker image instead of the local environment.
+This is particularly useful for ensuring that the solution runs with all its dependencies in a consistent environment.
+
+## Installation:
+
+1. [Install Album](https://docs.album.solutions/en/latest/installation-instructions.html#)
+2. Activate the album environment:
+
+```
+conda activate album
+```
+
+3. Install the album docker plugin:
+
+```
+pip install album-docker
+```
+
+## Usage:
+
+To create a docker image which contains Album with the passed solution installed run following command:
+
+If your solution is in a directory, you can copy the solution.py file into a new folder, e.g. `mySolutionFolder`, and then run the command from that folder.
+
+```
+mkdir mySolutionFolder
+cp /path/to/your/solution.py mySolutionFolder/
+```
+
+Then run the following command to create the docker image:
+
+```
+
+album docker --solution mySolutionFolder --output_path /your/output/path
+```
+
+The outcome will be a docker image with the tag `<group>:<name>:<version>` of the solution, where `<group>`, `<name>`, and `<version>` are defined in the solution.py file.
+
+### Input parameter:
+
+- solution: The album solution which should be packed into an executable.
+- output_path: The path where the executable should be saved
+- install-flags: Flags to pass to the album install command, e.g. '--allow-recursive'.
+- install-deps: Dependencies to install in the docker image, e.g. 'gxx' or 'gxx cmake'. This line will be added to the Dockerfile as a RUN command, so you can use any command that is valid in a Dockerfile.
+
+## Example:
+
+```
+album docker --solution mySolutionFolder --output_path /your/output/path --install-flags="--allow-recursive" --install-deps="apt update && apt install -y gxx cmake"
+```
+
+This will create a docker image with the tag <group:name:version> of the solution.
+Inside the image, the solution is installed together with the dependencies gxx and cmake.

album_docker-0.2.0/src/album_docker.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.cfg
+setup.py
+src/album/__init__.py
+src/album/docker_plugin/__init__.py
+src/album/docker_plugin/argument_parsing.py
+src/album/docker_plugin/build_image.py
+src/album/docker_plugin/solution_entrypoint.sh
+src/album_docker.egg-info/PKG-INFO
+src/album_docker.egg-info/SOURCES.txt
+src/album_docker.egg-info/dependency_links.txt
+src/album_docker.egg-info/entry_points.txt
+src/album_docker.egg-info/requires.txt
+src/album_docker.egg-info/top_level.txt

album_docker-0.2.0/src/album_docker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

album_docker-0.2.0/src/album_docker.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_parsers_album]
+docker = album.docker_plugin.argument_parsing:create_docker_parser

album_docker-0.2.0/src/album_docker.egg-info/requires.txt

@@ -0,0 +1,2 @@
+album<0.13.0,>=0.11.0
+docker

album_docker-0.2.0/src/album_docker.egg-info/top_level.txt

@@ -0,0 +1 @@
+album