docker/utils/container_interface.py

# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

from __future__ import annotations

import os
import shutil
import subprocess
from pathlib import Path
from typing import Any

from .state_file import StateFile


class ContainerInterface:
    """A helper class for managing Isaac Lab containers."""

    def __init__(
        self,
        context_dir: Path,
        profile: str = "base",
        yamls: list[str] | None = None,
        envs: list[str] | None = None,
        statefile: StateFile | None = None,
        suffix: str | None = None,
    ):
        """Initialize the container interface with the given parameters.

        Args:
            context_dir:
                The context directory for Docker operations.
            profile:
                The profile name for the container. Defaults to "base".
            yamls:
                A list of yaml files to extend ``docker-compose.yaml`` settings. These are extended in the order
                they are provided. Defaults to None, in which case no additional yaml files are added.
            envs:
                A list of environment variable files to extend the ``.env.base`` file. These are extended in the order
                they are provided. Defaults to None, in which case no additional environment variable files are added.
            statefile:
                An instance of the :class:`Statefile` class to manage state variables. Defaults to None, in
                which case a new configuration object is created by reading the configuration file at the path
                ``context_dir/.container.cfg``.
            suffix:
                Optional docker image and container name suffix.  Defaults to None, in which case, the docker name
                suffix is set to the empty string. A hyphen is inserted in between the profile and the suffix if
                the suffix is a nonempty string.  For example, if "base" is passed to profile, and "custom" is
                passed to suffix, then the produced docker image and container will be named ``isaac-lab-base-custom``.
        """
        # set the context directory
        self.context_dir = context_dir

        # create a state-file if not provided
        # the state file is a manager of run-time state variables that are saved to a file
        if statefile is None:
            self.statefile = StateFile(path=self.context_dir / ".container.cfg")
        else:
            self.statefile = statefile

        # set the profile and container name
        self.profile = profile
        if self.profile == "isaaclab":
            # Silently correct from isaaclab to base, because isaaclab is a commonly passed arg
            # but not a real profile
            self.profile = "base"

        # set the docker image and container name suffix
        if suffix is None or suffix == "":
            # if no name suffix is given, default to the empty string as the name suffix
            self.suffix = ""
        else:
            # insert a hyphen before the suffix if a suffix is given
            self.suffix = f"-{suffix}"

        # set names for easier reference
        self.base_service_name = "isaac-lab-base"
        self.service_name = f"isaac-lab-{self.profile}"
        self.container_name = f"{self.service_name}{self.suffix}"
        self.image_name = f"{self.service_name}{self.suffix}:latest"

        # keep the environment variables from the current environment,
        # except make sure that the docker name suffix is set from the script
        self.environ = os.environ.copy()
        self.environ["DOCKER_NAME_SUFFIX"] = self.suffix

        # resolve the image extension through the passed yamls and envs
        self._resolve_image_extension(yamls, envs)
        # load the environment variables from the .env files
        self._parse_dot_vars()

    def print_info(self):
        """Print the container interface information."""
        print("=" * 60)
        print(f"{'DOCKER CONTAINER INFO':^60}")  # Centered title
        print("=" * 60)

        print(f"{'Profile:':25} {self.profile}")
        print(f"{'Suffix:':25} {self.suffix}")
        print(f"{'Service Name:':25} {self.service_name}")
        print(f"{'Image Name:':25} {self.image_name}")
        print(f"{'Container Name:':25} {self.container_name}")

        print("-" * 60)
        print(f"{'Docker Compose Arguments':^60}")
        print("-" * 60)
        print(f"{'YAMLs:':25} {' '.join(self.add_yamls)}")
        print(f"{'Profiles:':25} {' '.join(self.add_profiles)}")
        print(f"{'Env Files:':25} {' '.join(self.add_env_files)}")
        print("=" * 60)

    """
    Operations.
    """

    def is_container_running(self) -> bool:
        """Check if the container is running.

        Returns:
            True if the container is running, otherwise False.
        """
        status = subprocess.run(
            ["docker", "container", "inspect", "-f", "{{.State.Status}}", self.container_name],
            capture_output=True,
            text=True,
            check=False,
        ).stdout.strip()
        return status == "running"

    def does_image_exist(self) -> bool:
        """Check if the Docker image exists.

        Returns:
            True if the image exists, otherwise False.
        """
        result = subprocess.run(["docker", "image", "inspect", self.image_name], capture_output=True, text=True)
        return result.returncode == 0

    def build(self):
        """Build the Docker image."""
        print("[INFO] Building the docker image for the profile 'base'...\n")
        # build the image for the base profile
        cmd = (
            ["docker", "compose"]
            + ["--file", "docker-compose.yaml"]
            + ["--profile", "base"]
            + ["--env-file", ".env.base"]
            + ["build", self.base_service_name]
        )
        subprocess.run(cmd, check=False, cwd=self.context_dir, env=self.environ)
        print("[INFO] Finished building the docker image for the profile 'base'.\n")

        # build the image for the profile
        if self.profile != "base":
            print(f"[INFO] Building the docker image for the profile '{self.profile}'...\n")
            cmd = (
                ["docker", "compose"]
                + self.add_yamls
                + self.add_profiles
                + self.add_env_files
                + ["build", self.service_name]
            )
            subprocess.run(cmd, check=False, cwd=self.context_dir, env=self.environ)
            print(f"[INFO] Finished building the docker image for the profile '{self.profile}'.\n")

    def start(self):
        """Build and start the Docker container using the Docker compose command."""
        print(
            f"[INFO] Building the docker image and starting the container '{self.container_name}' in the"
            " background...\n"
        )
        # Check if the container history file exists
        container_history_file = self.context_dir / ".isaac-lab-docker-history"
        if not container_history_file.exists():
            # Create the file with sticky bit on the group
            container_history_file.touch(mode=0o2644, exist_ok=True)

        # build the image for the base profile if not running base (up will build base already if profile is base)
        if self.profile != "base":
            cmd = (
                ["docker", "compose"]
                + ["--file", "docker-compose.yaml"]
                + ["--profile", "base"]
                + ["--env-file", ".env.base"]
                + ["build", self.base_service_name]
            )
            subprocess.run(cmd, check=False, cwd=self.context_dir, env=self.environ)

        # start the container and build the image if not available
        cmd = (
            ["docker", "compose"]
            + self.add_yamls
            + self.add_profiles
            + self.add_env_files
            + ["up", "--detach", "--build", "--remove-orphans"]
        )
        subprocess.run(cmd, check=False, cwd=self.context_dir, env=self.environ)

    def enter(self):
        """Enter the running container by executing a bash shell.

        Raises:
            RuntimeError: If the container is not running.
        """
        if self.is_container_running():
            print(f"[INFO] Entering the existing '{self.container_name}' container in a bash session...\n")
            cmd = (
                ["docker", "exec", "--interactive", "--tty"]
                + (["-e", f"DISPLAY={os.environ['DISPLAY']}"] if "DISPLAY" in os.environ else [])
                + [self.container_name, "bash"]
            )
            subprocess.run(cmd)
        else:
            raise RuntimeError(f"The container '{self.container_name}' is not running.")

    def stop(self):
        """Stop the running container using the Docker compose command."""
        if self.is_container_running():
            print(f"[INFO] Stopping the launched docker container '{self.container_name}'...\n")
            # stop running services
            cmd = (
                ["docker", "compose"] + self.add_yamls + self.add_profiles + self.add_env_files + ["down", "--volumes"]
            )
            subprocess.run(cmd, check=False, cwd=self.context_dir, env=self.environ)
        else:
            print(
                f"[INFO] Can't stop container '{self.container_name}' as it is not running."
                " To check if the container is running, run 'docker ps' or 'docker container ls'.\n"
            )

    def copy(self, output_dir: Path | None = None):
        """Copy artifacts from the running container to the host machine.

        Args:
            output_dir: The directory to copy the artifacts to. Defaults to None, in which case
                the context directory is used.

        Raises:
            RuntimeError: If the container is not running.
        """
        if self.is_container_running():
            print(f"[INFO] Copying artifacts from the '{self.container_name}' container...\n")
            if output_dir is None:
                output_dir = self.context_dir

            # create a directory to store the artifacts
            output_dir = output_dir.joinpath("artifacts")
            if not output_dir.is_dir():
                output_dir.mkdir()

            # define dictionary of mapping from docker container path to host machine path
            docker_isaac_lab_path = Path(self.dot_vars["DOCKER_ISAACLAB_PATH"])
            artifacts = {
                docker_isaac_lab_path.joinpath("logs"): output_dir.joinpath("logs"),
                docker_isaac_lab_path.joinpath("docs/_build"): output_dir.joinpath("docs"),
                docker_isaac_lab_path.joinpath("data_storage"): output_dir.joinpath("data_storage"),
            }
            # print the artifacts to be copied
            for container_path, host_path in artifacts.items():
                print(f"\t -{container_path} -> {host_path}")
            # remove the existing artifacts
            for path in artifacts.values():
                shutil.rmtree(path, ignore_errors=True)

            # copy the artifacts
            for container_path, host_path in artifacts.items():
                cmd = ["docker", "cp", f"{self.container_name}:{container_path}/", host_path]
                subprocess.run(cmd, check=False, cwd=self.context_dir, env=self.environ)
            print("\n[INFO] Finished copying the artifacts from the container.")
        else:
            raise RuntimeError(f"The container '{self.container_name}' is not running.")

    def config(self, output_yaml: Path | None = None):
        """Process the Docker compose configuration based on the passed yamls and environment files.

        If the :attr:`output_yaml` is not None, the configuration is written to the file. Otherwise, it is printed to
        the terminal.

        Args:
            output_yaml: The path to the yaml file where the configuration is written to. Defaults
                to None, in which case the configuration is printed to the terminal.
        """
        print("[INFO] Configuring the passed options into a yaml...\n")

        # resolve the output argument
        if output_yaml is not None:
            output = ["--output", output_yaml]
        else:
            output = []

        # run the docker compose config command to generate the configuration
        cmd = ["docker", "compose"] + self.add_yamls + self.add_profiles + self.add_env_files + ["config"] + output
        subprocess.run(cmd, check=False, cwd=self.context_dir, env=self.environ)

    """
    Helper functions.
    """

    def _resolve_image_extension(self, yamls: list[str] | None = None, envs: list[str] | None = None):
        """Resolve the image extension by setting up YAML files, profiles, and environment files for the
        Docker compose command.

        Args:
            yamls: A list of yaml files to extend ``docker-compose.yaml`` settings. These are extended in the order
                they are provided.
            envs: A list of environment variable files to extend the ``.env.base`` file. These are extended in the order
                they are provided.
        """
        self.add_yamls = ["--file", "docker-compose.yaml"]
        self.add_profiles = ["--profile", f"{self.profile}"]
        self.add_env_files = ["--env-file", ".env.base"]

        # extend env file based on profile
        if self.profile != "base":
            self.add_env_files += ["--env-file", f".env.{self.profile}"]

        # extend the env file based on the passed envs
        if envs is not None:
            for env in envs:
                self.add_env_files += ["--env-file", env]

        # extend the docker-compose.yaml based on the passed yamls
        if yamls is not None:
            for yaml in yamls:
                self.add_yamls += ["--file", yaml]

    def _parse_dot_vars(self):
        """Parse the environment variables from the .env files.

        Based on the passed ".env" files, this function reads the environment variables and stores them in a dictionary.
        The environment variables are read in order and overwritten if there are name conflicts, mimicking the behavior
        of Docker compose.
        """
        self.dot_vars: dict[str, Any] = {}

        # check if the number of arguments is even for the env files
        if len(self.add_env_files) % 2 != 0:
            raise RuntimeError(
                "The parameters for env files are configured incorrectly. There should be an even number of arguments."
                f" Received: {self.add_env_files}."
            )

        # read the environment variables from the .env files
        for i in range(1, len(self.add_env_files), 2):
            with open(self.context_dir / self.add_env_files[i]) as f:
                self.dot_vars.update(dict(line.strip().split("=", 1) for line in f if "=" in line))