ybox 0.9.8__py3-none-any.whl

ybox/config.py

@@ -0,0 +1,255 @@
+"""
+Configuration locations, distribution and box name of ybox container.
+"""
+
+import os
+import re
+from typing import Iterable, Optional
+
+from .env import Environ
+
+
+class StaticConfiguration:
+    """
+    Configuration paths for a ybox container, its name and distribution.
+    This class also setups up related environment variables which can be used by the
+    INI configuration files.
+    """
+
+    def __init__(self, env: Environ, distribution: str, box_name: str):
+        self._env = env
+        # set up the additional environment variables
+        os.environ["YBOX_DISTRIBUTION_NAME"] = distribution
+        os.environ["YBOX_CONTAINER_NAME"] = box_name
+        self._distribution = distribution
+        self._box_name = box_name
+        self._box_image = f"{Consts.image_prefix()}/{distribution}/{box_name}"
+        self._shared_box_image = f"{Consts.shared_image_prefix()}/{distribution}"
+        # timezone properties
+        self._localtime = None
+        self._timezone = None
+        if os.path.islink("/etc/localtime"):
+            self._localtime = os.readlink("/etc/localtime")
+        if os.path.exists("/etc/timezone"):
+            with open("/etc/timezone", "r", encoding="utf-8") as timezone:
+                self._timezone = timezone.read().rstrip("\n")
+        self._pager = os.environ.get("YBOX_PAGER", Consts.default_pager())
+        container_dir = f"{env.data_dir}/{box_name}"
+        os.environ["YBOX_CONTAINER_DIR"] = container_dir
+        self._configs_dir = f"{container_dir}/configs"
+        self._target_configs_dir = f"{env.target_data_dir}/{box_name}/configs"
+        self._scripts_dir = f"{container_dir}/ybox-scripts"
+        self._target_scripts_dir = "/usr/local/ybox"
+        os.environ["YBOX_TARGET_SCRIPTS_DIR"] = self._target_scripts_dir
+        self._status_file = f"{container_dir}/status"
+        self._config_list = f"{self._scripts_dir}/config.list"
+        self._app_list = f"{self._scripts_dir}/app.list"
+
+    @property
+    def env(self) -> Environ:
+        """the `Environ` object used for this configuration"""
+        return self._env
+
+    @property
+    def distribution(self) -> str:
+        """linux distribution being used by the ybox container"""
+        return self._distribution
+
+    @staticmethod
+    def distribution_config(distribution: str, config_file: str = "distro.ini") -> str:
+        """
+        Relative configuration file path for the Linux distribution being used.
+
+        :param distribution: name of the Linux distribution
+        :param config_file: name of the configuration file, defaults to "distro.ini"
+        :return: relative path of the configuration file
+        """
+        return f"distros/{distribution}/{config_file}"
+
+    @property
+    def box_name(self) -> str:
+        """name of the ybox container"""
+        return self._box_name
+
+    def box_image(self, has_shared_root: bool) -> str:
+        """
+        Container image created with basic required user configuration from base image.
+        This can either be container specific, or if `base.shared_root` is provided, then
+        it will be common for all such images for the same distribution.
+
+        :param has_shared_root: whether `base.shared_root` is provided in configuration file
+        :return: the podman/docker image to be created and used for the ybox
+        """
+        return self._shared_box_image if has_shared_root else self._box_image
+
+    @property
+    def localtime(self) -> Optional[str]:
+        """the target link for /etc/localtime"""
+        return self._localtime
+
+    @property
+    def timezone(self) -> Optional[str]:
+        """the contents of /etc/timezone"""
+        return self._timezone
+
+    @property
+    def pager(self) -> str:
+        """pager command to show output one screenful at a time on the terminal"""
+        return self._pager
+
+    @property
+    def configs_dir(self) -> str:
+        """user directory where configuration files specified in [configs] are copied or
+           hard-linked for sharing with the container"""
+        return self._configs_dir
+
+    @property
+    def target_configs_dir(self) -> str:
+        """target container directory where shared [configs] are mounted in the container"""
+        return self._target_configs_dir
+
+    @property
+    def scripts_dir(self) -> str:
+        """local directory where scripts to be shared with container are copied"""
+        return self._scripts_dir
+
+    @property
+    def target_scripts_dir(self) -> str:
+        """target container directory where shared scripts are mounted"""
+        return self._target_scripts_dir
+
+    @property
+    def status_file(self) -> str:
+        """local status file to communicate when the container is ready for use"""
+        return self._status_file
+
+    # file containing list of configuration files to be linked on that container to host
+    # as mentioned in the [configs] section
+    @property
+    def config_list(self) -> str:
+        """file containing list of configuration files to be linked on that container to host
+            as mentioned in the [configs] section"""
+        return self._config_list
+
+    @property
+    def app_list(self) -> str:
+        """file containing list of applications to be installed in the container"""
+        return self._app_list
+
+
+class Consts:
+    """
+    Defines fixed file/path and other names used by ybox that are not configurable.
+    """
+
+    _MAN_DIRS_PATTERN = re.compile(r"/usr(/local)?(/share)?/man(/[^/]*)?/man[0-9][a-zA-Z_]*")
+
+    @staticmethod
+    def image_prefix() -> str:
+        """prefix used for the non-shared root images"""
+        return "ybox-local"
+
+    @staticmethod
+    def shared_image_prefix() -> str:
+        """prefix used for the shared root images"""
+        return "ybox-shared-local"
+
+    @staticmethod
+    def default_directory_mode() -> int:
+        """return the default mode to use for new directories"""
+        return 0o750
+
+    @staticmethod
+    def entrypoint_base() -> str:
+        """entrypoint script name for the base container (which is booted to configure
+           the final container)"""
+        return "entrypoint-base.sh"
+
+    @staticmethod
+    def entrypoint_cp() -> str:
+        """entrypoint script name for the "copy" container that copies files to shared root"""
+        return "entrypoint-cp.sh"
+
+    @staticmethod
+    def entrypoint() -> str:
+        """entrypoint script name for the final ybox container"""
+        return "entrypoint.sh"
+
+    @staticmethod
+    def run_user_bash_cmd() -> str:
+        """script used to force run a command as non-root user using `sudo` with `/bin/bash`"""
+        return "run-user-bash-cmd"
+
+    @staticmethod
+    def resource_scripts() -> Iterable[str]:
+        """all the scripts in the resources directory"""
+        return (Consts.entrypoint_base(), Consts.entrypoint_cp(), Consts.entrypoint(),
+                "entrypoint-common.sh", "entrypoint-root.sh", "entrypoint-user.sh",
+                "prime-run", "run-in-dir", Consts.run_user_bash_cmd())
+
+    @staticmethod
+    def shared_root_mount_dir() -> str:
+        """directory where shared root directory is mounted in a container during setup"""
+        return "/ybox-root"
+
+    @staticmethod
+    def status_target_file() -> str:
+        """target location where status_file is mounted in container"""
+        return "/usr/local/ybox-status"  # this should match the one in entrypoint-common.sh
+
+    @staticmethod
+    def entrypoint_init_done_file() -> str:
+        """file that indicates completion of first run initialization by entrypoint.sh script"""
+        return "ybox-init.done"
+
+    @staticmethod
+    def container_desktop_dirs() -> Iterable[str]:
+        """directories on the container that has desktop files that may need to be wrapped"""
+        return ("/usr/share/applications",)
+
+    @staticmethod
+    def container_icon_dirs() -> Iterable[str]:
+        """directories on the container (as regexes) that may have application icons"""
+        return ("/usr/share/icons/hicolor/scalable/.*", "/usr/share/icons/hicolor/([1-9]+)x.*",
+                "/usr/share/icons/hicolor/symbolic/.*", "/usr/share/icons", "/usr/share/pixmaps")
+
+    @staticmethod
+    def container_bin_dirs() -> Iterable[str]:
+        """directories on the container that has executables that may need to be wrapped"""
+        return ("/usr/bin", "/usr/sbin", "/bin", "/sbin", "/usr/local/bin", "/usr/local/sbin")
+
+    @staticmethod
+    def container_man_dir_pattern() -> re.Pattern[str]:
+        """directory regex pattern on the container having man-pages that may need to be linked"""
+        return Consts._MAN_DIRS_PATTERN
+
+    @staticmethod
+    def nvidia_target_base_dir() -> str:
+        """base directory path where NVIDIA libs/data are linked in the container"""
+        return "/usr/local/nvidia"
+
+    @staticmethod
+    def nvidia_setup_script() -> str:
+        """
+        name of the NVIDIA setup script in the container
+        (location is `StaticConfiguration.target_scripts_dir`)
+        """
+        return "nvidia-setup.sh"
+
+    @staticmethod
+    def default_pager() -> str:
+        """
+        default pager to show output one screenful at a time on the terminal when YBOX_PAGER
+        environment variable is not set
+        """
+        return "/usr/bin/less -RLFXK"
+
+    @staticmethod
+    def default_field_separator() -> str:
+        """default separator used between the fields in output of podman/docker exec commands"""
+        return "::::"
+
+    @staticmethod
+    def default_key_server() -> str:
+        """default gpg key server to use when not specified in the distribution's `distro.ini`"""
+        return "hkps://keys.openpgp.org"

ybox/env.py

@@ -0,0 +1,205 @@
+"""
+Useful user environment settings.
+"""
+
+import getpass
+import os
+import pwd
+import site
+import subprocess
+from datetime import datetime
+from importlib.abc import Traversable
+from importlib.resources import files
+from pathlib import Path
+from typing import Optional, Union
+
+from .print import print_error, print_notice
+
+PathName = Union[Path, Traversable]
+
+
+def get_docker_command() -> str:
+    """
+    If a custom podman/docker executable is defined by YBOX_CONTAINER_MANAGER environment variable,
+    then return it else check for podman and docker (in that order) in the standard /usr/bin path.
+
+    :return: the podman/docker executable specified in arguments or defined by
+             YBOX_CONTAINER_MANAGER environment variable
+    """
+    # check for podman first then docker
+    if cmd := os.environ.get("YBOX_CONTAINER_MANAGER"):
+        if os.access(cmd, os.X_OK):
+            return cmd
+        raise PermissionError(
+            f"Cannot execute '{cmd}' provided in YBOX_CONTAINER_MANAGER environment variable")
+    if os.access("/usr/bin/podman", os.X_OK):
+        return "/usr/bin/podman"
+    if os.access("/usr/bin/docker", os.X_OK):
+        return "/usr/bin/docker"
+    raise FileNotFoundError(
+        "No podman/docker found in /usr/bin and $YBOX_CONTAINER_MANAGER not defined")
+
+
+class NotSupportedError(Exception):
+    """Raised when an operation or configuration is not supported or invalid."""
+
+
+class Environ:
+    """
+    Holds common environment variables useful for the scripts like $HOME, $XDG_RUNTIME_DIR.
+    It sets up the $TARGET_HOME environment variable which is the $HOME inside the container.
+    Also captures the current time and sets up the $NOW environment variable.
+    """
+
+    def __init__(self, docker_cmd: Optional[str] = None, home_dir: Optional[str] = None):
+        """
+        Initialize the `Environ` object providing the podman/docker command to use.
+
+        :param docker_cmd: the podman/docker executable to use,
+                           defaults to :func:`get_docker_command()`
+        :param home_dir: if a non-default user home directory has to be set
+        """
+        self._home_dir = home_dir or os.path.expanduser("~")
+        self._docker_cmd = docker_cmd or get_docker_command()
+        cmd_version = subprocess.check_output([self._docker_cmd, "--version"])
+        self._uses_podman = "podman" in cmd_version.decode("utf-8").lower()
+        # local user home might be in a different location than /home but target user in the
+        # container will always be in /home with podman else /root for the root user with docker
+        # as ensured by entrypoint-base.sh script
+        target_uid = 0
+        if self._uses_podman:
+            self._target_user = getpass.getuser()
+            target_uid = pwd.getpwnam(self._target_user).pw_uid
+            self._target_home = f"/home/{self._target_user}"
+        else:
+            self._target_user = "root"
+            self._target_home = "/root"
+            # confirm that docker is being used in rootless mode (not required for podman because
+            #   it runs as rootless when run by a non-root user in any case without explicit sudo
+            #   which the ybox tools don't use)
+            if (docker_ctx := subprocess.check_output(
+                    [self._docker_cmd, "context", "show"]).decode("utf-8")).strip() != "rootless":
+                raise NotSupportedError("docker should use the rootless mode (see "
+                                        "https://docs.docker.com/engine/security/rootless/) "
+                                        f"but the current context is '{docker_ctx}'")
+        os.environ["TARGET_HOME"] = self._target_home
+        self._user_base = user_base = site.getuserbase()
+        target_user_base = f"{self._target_home}/.local"
+        self._data_dir = f"{user_base}/share/ybox"
+        self._target_data_dir = f"{target_user_base}/share/ybox"
+        self._xdg_rt_dir = os.environ.get("XDG_RUNTIME_DIR", "")
+        # the container user's one can be different because it is the root user for docker
+        self._target_xdg_rt_dir = f"/run/user/{target_uid}"
+        self._now = datetime.now()
+        os.environ["NOW"] = str(self._now)
+        sys_conf_dir = files("ybox").joinpath("conf")
+        os.environ["YBOX_SYS_CONF_DIR"] = str(sys_conf_dir)
+        self._sys_conf_dirs = [sys_conf_dir]
+        self._root_dir = [Path("/")]
+        self._configuration_dirs: list[PathName] = []
+        # for tests, only the bundled configurations should be tested
+        if os.environ.get("YBOX_TESTING"):
+            print_notice("Running with YBOX_TESTING enabled")
+            self._configuration_dirs = self._sys_conf_dirs
+        else:
+            self._configuration_dirs = [Path(f"{self._home_dir}/.config/ybox"),
+                                        sys_conf_dir]
+        self._user_applications_dir = f"{user_base}/share/applications"
+        self._user_executables_dir = f"{user_base}/bin"
+
+    def search_config_path(self, conf_path: str, only_sys_conf: bool = False,
+                           quiet: bool = False) -> PathName:
+        """
+        Search for given configuration path in user and system configuration directories
+        (in that order). The path may refer to a file or a subdirectory.
+
+        :param conf_path: the configuration file to search (expected to be a relative path)
+        :param only_sys_conf: if True then search only system configuration directory else
+                              search for user configuration directory first then the system one
+        :param quiet: if False then prints an error message on standard output on failure
+        :return: the path of the configuration file as `Path` or resource file from
+                 importlib (i.e. `Traversable`)
+        """
+        if os.path.isabs(conf_path):
+            conf_dirs = self._root_dir
+        else:
+            conf_dirs = self._sys_conf_dirs if only_sys_conf else self._configuration_dirs
+        for config_dir in conf_dirs:
+            path = config_dir.joinpath(conf_path)
+            if os.access(path, os.R_OK):  # type: ignore
+                return path
+        search_dirs = ', '.join([str(file) for file in conf_dirs])
+        if not quiet:
+            print_error(f"Configuration file '{conf_path}' not found in [{search_dirs}]")
+        raise FileNotFoundError(f"Missing configuration file '{conf_path}'")
+
+    @property
+    def home(self) -> str:
+        """home directory of the current user"""
+        return self._home_dir
+
+    @property
+    def docker_cmd(self) -> str:
+        """path of the podman/docker executable to use for all the commands"""
+        return self._docker_cmd
+
+    @property
+    def uses_podman(self) -> bool:
+        """if podman is the container manager being used"""
+        return self._uses_podman
+
+    @property
+    def target_user(self) -> str:
+        """username of the container user (which is the same as the current user for podman
+           and root for docker)"""
+        return self._target_user
+
+    # home directory of the container user (which is $TARGET_HOME=/home/$USER for podman
+    #   and /root for docker)
+    @property
+    def target_home(self) -> str:
+        """home directory of the container user (which is $TARGET_HOME=/home/$USER for podman
+           and /root for docker)"""
+        return self._target_home
+
+    @property
+    def data_dir(self) -> str:
+        """base user directory where runtime data related to all the containers is
+           stored in subdirectories"""
+        return self._data_dir
+
+    @property
+    def target_data_dir(self) -> str:
+        """base user directory of the container user where runtime data related to all
+           the containers is stored"""
+        return self._target_data_dir
+
+    @property
+    def xdg_rt_dir(self) -> str:
+        """value of $XDG_RUNTIME_DIR in the current session"""
+        return self._xdg_rt_dir
+
+    @property
+    def target_xdg_rt_dir(self) -> str:
+        """value of $XDG_RUNTIME_DIR for the user in the container"""
+        return self._target_xdg_rt_dir
+
+    @property
+    def now(self) -> datetime:
+        """current time as captured during Environ object creation"""
+        return self._now
+
+    @property
+    def user_base(self) -> str:
+        """User's local base data directory which is typically ~/.local"""
+        return self._user_base
+
+    @property
+    def user_applications_dir(self) -> str:
+        """User's local applications directory that holds the .desktop files"""
+        return self._user_applications_dir
+
+    @property
+    def user_executables_dir(self) -> str:
+        """User's local executables directory which should be in the $PATH"""
+        return self._user_executables_dir

ybox/filelock.py

@@ -0,0 +1,77 @@
+"""
+Helper class for file locking with timeout support.
+"""
+
+import errno
+import fcntl
+import time
+from datetime import datetime
+from io import IOBase
+from typing import Optional
+
+
+class FileLock:
+    """
+    A simple file locker class that takes an `fcntl()` lock on given file with polling and timeout.
+    The lock file should always be separate from the resource being locked (if the resource
+    is also a file).
+
+    The file is created on first access or truncated if it exists, and never removed thereafter
+    to avoid any complications. Lock files on NFS files may or may not work as expected
+    depending on the NFS server characteristics, so this class can safely be used only
+    with the lock file on the local filesystem.
+
+    Usage:
+        with FileLock("file.lock", timeout_secs=100):
+          <code>
+    """
+
+    def __init__(self, lock_file: str, timeout_secs: float = 300.0, poll_interval: float = 1.0):
+        """
+        Initialize the lock giving a file which should be a separate lock file from the
+        actual resource to be locked. This file is created or truncated on acquisition.
+
+        :param lock_file: the lock file which can be any unique file corresponding to
+                          the resource being locked
+        :param timeout_secs: lock timeout in seconds (use negative for infinite wait)
+        :param poll_interval: polling interval at which to check for lock to be available
+        """
+        self._lock_file = lock_file
+        self._lock_fd: Optional[IOBase] = None
+        self._timeout = timeout_secs
+        self._poll = poll_interval
+
+    def __enter__(self):
+        success = False
+        self._lock_fd = open(self._lock_file, "w+", encoding="utf-8")
+        try:
+            start_time: Optional[datetime] = None
+            remaining_time = self._timeout
+            while remaining_time != 0:
+                try:
+                    fcntl.lockf(self._lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                    success = True
+                    return
+                except OSError as ex:
+                    if ex.errno in (errno.EACCES, errno.EAGAIN):
+                        # start proper timing only after first failure
+                        if not start_time:
+                            start_time = datetime.now()
+                        # wait for poll time, then try again
+                        time.sleep(self._poll)
+                        # treat -ve timeout as infinite where remaining_time will never reach 0
+                        if remaining_time > 0:
+                            remaining_time -= self._poll
+                            remaining_time = max(remaining_time, 0)
+                    else:
+                        raise
+            wait_time = (datetime.now() - start_time).total_seconds() if start_time else 0.0
+            raise TimeoutError(f"Failed to lock '{self._lock_file}' in {wait_time} seconds")
+        finally:
+            if not success:
+                self._lock_fd.close()
+
+    def __exit__(self, ex_type, ex_value, ex_traceback):  # type: ignore
+        if self._lock_fd:
+            fcntl.lockf(self._lock_fd, fcntl.LOCK_UN)
+            self._lock_fd.close()

ybox/migrate/0.9.0-0.9.7:0.9.8.py

@@ -0,0 +1,33 @@
+"""
+Migrate from 0.9.0 upwards to 0.9.7 that requires copying updated scripts to the container.
+
+Invoke this script using `exec` passing the `StaticConfiguration` object as `conf` local variable
+and parsed distribution configuration `ConfigParser` object as `distro_config` local variable.
+"""
+
+import subprocess
+from configparser import ConfigParser
+from pathlib import Path
+from typing import cast
+
+from ybox.config import Consts, StaticConfiguration
+from ybox.util import copy_ybox_scripts_to_container
+
+# the two variables below should be passed as local variables to `exec`
+static_conf = cast(StaticConfiguration, conf)  # type: ignore # noqa: F821
+distro_conf = cast(ConfigParser, distro_config)  # type: ignore # noqa: F821
+copy_ybox_scripts_to_container(static_conf, distro_conf)
+
+# rename PKGMGR_CLEANUP to PKGMGR_CLEAN in pkgmgr.conf
+scripts_dir = static_conf.scripts_dir
+pkgmgr_conf = f"{scripts_dir}/pkgmgr.conf"
+with open(pkgmgr_conf, "r", encoding="utf-8") as pkgmgr_file:
+    pkgmgr_data = pkgmgr_file.read()
+with open(pkgmgr_conf, "w", encoding="utf-8") as pkgmgr_file:
+    pkgmgr_file.write(pkgmgr_data.replace("PKGMGR_CLEANUP", "PKGMGR_CLEAN"))
+# run entrypoint-root.sh again to refresh scripts and configuration
+subprocess.run([static_conf.env.docker_cmd, "exec", "-it", static_conf.box_name, "/usr/bin/sudo",
+                "/bin/bash", f"{static_conf.target_scripts_dir}/entrypoint-root.sh"])
+
+# touch the file to indicate that first run initialization of entrypoint.sh is complete
+Path(f"{scripts_dir}/{Consts.entrypoint_init_done_file()}").touch(mode=0o644)

ybox/pkg/clean.py

@@ -0,0 +1,33 @@
+"""
+Clean package cache and related intermediate files of an active ybox container.
+"""
+
+import argparse
+from configparser import SectionProxy
+
+from ybox.cmd import PkgMgr, build_shell_command, run_command
+from ybox.config import StaticConfiguration
+from ybox.print import print_info
+from ybox.state import RuntimeConfiguration, YboxStateManagement
+
+
+# noinspection PyUnusedLocal
+def clean_cache(args: argparse.Namespace, pkgmgr: SectionProxy, docker_cmd: str,
+                conf: StaticConfiguration, runtime_conf: RuntimeConfiguration,
+                state: YboxStateManagement) -> int:
+    # pylint: disable=unused-argument
+    """
+    Clean package cache and related intermediate files.
+
+    :param args: arguments having `quiet` and all other attributes passed by the user
+    :param pkgmgr: the `[pkgmgr]` section from `distro.ini` configuration file of the distribution
+    :param docker_cmd: the podman/docker executable to use
+    :param conf: the :class:`StaticConfiguration` for the container
+    :param runtime_conf: the `RuntimeConfiguration` of the container
+    :param state: instance of `YboxStateManagement` having the state of all ybox containers
+    :return: integer exit status of clean command where 0 represents success
+    """
+    print_info(f"Cleaning package cache in container '{conf.box_name}'")
+    clean_cmd = pkgmgr[PkgMgr.CLEAN_QUIET.value] if args.quiet else pkgmgr[PkgMgr.CLEAN.value]
+    return int(run_command(build_shell_command(docker_cmd, conf.box_name, clean_cmd),
+                           exit_on_error=False, error_msg="cleaning package cache"))

ybox/pkg/info.py

@@ -0,0 +1,40 @@
+"""
+Show detailed information of installed or repository packages in an active ybox container.
+"""
+
+import argparse
+import sys
+from configparser import SectionProxy
+
+from ybox.cmd import PkgMgr, page_command
+from ybox.config import StaticConfiguration
+from ybox.state import RuntimeConfiguration, YboxStateManagement
+
+
+# noinspection PyUnusedLocal
+def info_packages(args: argparse.Namespace, pkgmgr: SectionProxy, docker_cmd: str,
+                  conf: StaticConfiguration, runtime_conf: RuntimeConfiguration,
+                  state: YboxStateManagement) -> int:
+    # pylint: disable=unused-argument
+    """
+    Show detailed information of an installed or repository package(s).
+
+    :param args: arguments having `packages` and all other attributes passed by the user
+    :param pkgmgr: the `[pkgmgr]` section from `distro.ini` configuration file of the distribution
+    :param docker_cmd: the podman/docker executable to use
+    :param conf: the :class:`StaticConfiguration` for the container
+    :param runtime_conf: the `RuntimeConfiguration` of the container
+    :param state: instance of `YboxStateManagement` having the state of all ybox containers
+    :return: integer exit status of info command where 0 represents success
+    """
+    quiet_flag = pkgmgr[PkgMgr.QUIET_DETAILS_FLAG.value] if args.quiet else ""
+    packages: list[str] = args.packages
+    info_cmd = pkgmgr[PkgMgr.INFO_ALL.value] if args.all else pkgmgr[PkgMgr.INFO.value]
+    info_cmd = info_cmd.format(quiet=quiet_flag, packages=" ".join(packages))
+    docker_args = [docker_cmd, "exec"]
+    if sys.stdout.isatty():  # don't act as a terminal if it is being redirected
+        docker_args.append("-it")
+    docker_args.extend([conf.box_name, "/bin/bash", "-c", info_cmd])
+    # empty pager argument is a valid one and indicates no pagination, hence the `is None` check
+    pager: str = args.pager if args.pager is not None else conf.pager
+    return page_command(docker_args, pager, error_msg="SKIP")