Docker-Services-CLI 0.12.2__py3-none-any.whl

docker_services_cli/__init__.py

@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: 2020-2025 CERN.
+# SPDX-FileCopyrightText: 2022 University Münster.
+# SPDX-FileCopyrightText: 2022-2026 TU Wien.
+# SPDX-FileCopyrightText: 2023 Graz University of Technology.
+# SPDX-License-Identifier: MIT
+
+"""Module to ease the creation and management of services.
+
+The specific version for the services can be set through environment variables
+
+.. code-block:: console
+
+    $ export OPENSEARCH_VERSION=2.16.0
+
+It can also use the centrally managed (supported) major version:
+
+.. code-block:: console
+
+    $ export OPENSEARCH_VERSION=OPENSEARCH_2_LATEST
+
+Then it simply needs to boot up the services. Note that if no version was
+exported in the environment, the CLI will use the default values set in
+``env.py``.
+
+.. code-block:: console
+
+    $ docker-services-cli up --search opensearch --db postgresql --cache redis
+
+And turn them of once they are not needed anymore:
+
+.. code-block:: console
+
+    $ docker-services-cli down
+"""
+
+__version__ = "0.12.2"
+
+__all__ = ("__version__",)

docker_services_cli/cli.py

@@ -0,0 +1,196 @@
+# SPDX-FileCopyrightText: 2020 CERN.
+# SPDX-License-Identifier: MIT
+
+"""CLI module."""
+
+from functools import update_wrapper
+from pathlib import Path
+
+import click
+
+from .config import SERVICE_TYPES
+from .env import (
+    normalize_service_name,
+    override_default_env,
+    print_setup_env_config,
+    set_env,
+)
+from .services import services_down, services_up
+
+
+def _get_module_path():
+    """Gets the path in which the module is installed."""
+    parent_path = Path(__file__).parent
+    return str(parent_path)
+
+
+def env_output(env_set_command):
+    """Decorate command to print exportable environment settings."""
+    if env_set_command not in ["export", "unset"]:
+        click.secho("Wrong environment set command.", fg="red")
+        exit(1)
+
+    def print_env_output(func):
+        @click.option(
+            "--env",
+            is_flag=True,
+            default=False,
+            help="Print export statements to set environment.",
+        )
+        def _print_env_output(*args, **kwargs):
+            env = kwargs.pop("env", False)
+            services = kwargs.get("services") or SERVICE_TYPES
+            if env:
+                # comment command output until env export
+                click.echo(": '")
+            click.get_current_context().invoke(func, *args, **kwargs)
+            if env:
+                # end of multiline comment, start of export statements
+                click.echo("'")
+                print_setup_env_config(
+                    services,
+                    click.get_current_context().info_name,
+                    env_set_command=env_set_command,
+                )
+
+        return update_wrapper(_print_env_output, func)
+
+    return print_env_output
+
+
+def services_by_type(func):
+    """Decorate command adding all service types as options.
+
+    :param func: The function that implements the Click command to which the
+        service types options will be added.
+
+    :return: A wrapped function around the passed Click command which exposes
+        all ``config.SERVICES_TYPES`` as Click options. The list of services
+        by type is injected as ``services`` keyword argument.
+    """
+
+    def collect_services_by_type(*args, **kwargs):
+        services = {}
+        for service_type in SERVICE_TYPES:
+            service = kwargs.pop(service_type)
+            if service:
+                services.setdefault(service_type, []).extend(
+                    service if isinstance(service, list) else [service]
+                )
+
+        kwargs["services"] = services
+        click.get_current_context().invoke(func, *args, **kwargs)
+
+    def validate_service_name(ctx, service_type, services_list):
+        available_services = SERVICE_TYPES.get(service_type.name, [])
+        for service in services_list:
+            if not (
+                normalize_service_name(service)
+                or normalize_service_name(service) in available_services
+            ):
+                raise click.BadParameter(
+                    "{service} is not a valid service of type {type}. "
+                    "Try one of: \n{available_services}".format(
+                        service=service,
+                        type=service_type.name,
+                        available_services=available_services,
+                    )
+                )
+        return list(services_list)
+
+    for service_type in SERVICE_TYPES:
+        click.option(
+            "--{}".format(service_type),
+            callback=validate_service_name,
+            multiple=True,
+            help="Specify which service should run as {0}. "
+            "Available {0} services: {1}.".format(
+                service_type, ", ".join(SERVICE_TYPES.get(service_type))
+            ),
+        )(func)
+
+    return update_wrapper(collect_services_by_type, func)
+
+
+class ServicesCtx(object):
+    """Context class for docker services cli."""
+
+    def __init__(self, filepath, verbose):
+        """Constructor."""
+        self.filepath = filepath
+        self.verbose = verbose
+
+
+@click.group()
+@click.version_option()
+@click.option(
+    "--filepath",
+    "-f",
+    required=False,
+    default=f"{_get_module_path()}/docker-services.yml",
+    type=click.Path(exists=True),
+    help="Path to a docker compose file with the desired services definition.",
+)
+@click.option(
+    "--verbose",
+    is_flag=True,
+    default=False,
+    help="Verbose output.",
+)
+@click.pass_context
+def cli(ctx, filepath, verbose):
+    """Initialize CLI context."""
+    set_env()
+    ctx.obj = ServicesCtx(filepath=filepath, verbose=verbose)
+
+
+@cli.command()
+@click.option(
+    "--no-wait",
+    is_flag=True,
+    help="Wait for services to be up (use healthchecks).",
+)
+@click.option(
+    "--retries",
+    default=6,
+    type=int,
+    help="Number of times to retry a service's healthcheck.",
+)
+@services_by_type
+@env_output(env_set_command="export")
+@click.pass_obj
+def up(services_ctx, services, no_wait, retries):
+    r"""Boots up the required services.
+
+    Example:
+        $ docker-services-cli up --db postgresql11
+
+    Note: All services will be boot up if no service is specified.
+    """
+    _services = [s for services_list in services.values() for s in services_list]
+
+    # NOTE: docker compose boots up all if none is provided
+    if len(_services) == 1 and _services[0].lower() == "all":
+        _services = []
+
+    override_default_env(services_to_override=_services)
+    click.secho("Environment setup", fg="green")
+
+    normalized_services = [normalize_service_name(s) for s in _services]
+    services_up(
+        services=normalized_services,
+        filepath=services_ctx.filepath,
+        wait=(not no_wait),
+        retries=retries,
+        verbose=services_ctx.verbose,
+    )
+    click.secho("Services up!", fg="green")
+
+
+@cli.command()
+@env_output(env_set_command="unset")
+@click.pass_obj
+def down(services_ctx):
+    """Shuts down the required services."""
+    services_down(filepath=services_ctx.filepath)
+    click.secho("Services down!", fg="green")

docker_services_cli/config.py

@@ -0,0 +1,171 @@
+# SPDX-FileCopyrightText: 2020-2025 CERN.
+# SPDX-FileCopyrightText: 2024 Graz University of Technology.
+# SPDX-FileCopyrightText: 2025 CESNET z.s.p.o.
+# SPDX-License-Identifier: MIT
+
+"""Configuration module.
+
+Configuration values (e.g. service configuration) need to be set through
+environment variables. However, sane defaults are provided below.
+
+The list of services to be configured is taken from ``SERVICES``. Each one
+should contain a ``<SERVICE_NAME>_VERSION`` variable.
+
+Service's version are treated slightly different:
+
+- If the variable is not found in the environment, it will use the set default.
+- If the variable is set with a version number (e.g. 10, 10.7) it will use
+  said value.
+- If the variable is set with a string point to one of the configured
+  ``latests`` it will load the value of said ``latest`` and use it.
+
+This means that the environment set/load logic will first set the default
+versions before loading a given service's version.
+"""
+
+DOCKER_SERVICES_FILEPATH = "docker-services.yml"
+"""Docker services file default path."""
+
+# Elasticsearch
+ELASTICSEARCH = {
+    "ELASTICSEARCH_VERSION": "ELASTICSEARCH_7_LATEST",
+    "DEFAULT_VERSIONS": {
+        "ELASTICSEARCH_7_LATEST": "7.10.2",  # the last of the OSS versions (https://github.com/elastic/elasticsearch/issues/58303)
+    },
+    "CONTAINER_CONNECTION_ENVIRONMENT_VARIABLES": {
+        "search": {
+            "SEARCH_HOSTS": "\"[{'host': 'localhost', 'port': 9200}]\"",
+        }
+    },
+}
+"""Elasticsearch service configuration."""
+
+# Opensearch
+OPENSEARCH = {
+    "OPENSEARCH_VERSION": "OPENSEARCH_2_LATEST",
+    "DEFAULT_VERSIONS": {
+        "OPENSEARCH_1_LATEST": "1.3.18",
+        "OPENSEARCH_2_LATEST": "2.16.0",
+    },
+    "CONTAINER_CONNECTION_ENVIRONMENT_VARIABLES": {
+        "search": {
+            "SEARCH_HOSTS": "\"[{'host': 'localhost', 'port': 9200}]\"",
+        }
+    },
+}
+"""Opensearch service configuration."""
+
+# PostgreSQL
+POSTGRESQL = {
+    "POSTGRESQL_VERSION": "POSTGRESQL_16_LATEST",
+    "DEFAULT_VERSIONS": {
+        "POSTGRESQL_14_LATEST": "14.9",
+        "POSTGRESQL_15_LATEST": "15.4",
+        "POSTGRESQL_16_LATEST": "16.2",
+    },
+    "CONTAINER_CONFIG_ENVIRONMENT_VARIABLES": {
+        "POSTGRESQL_USER": "invenio",
+        "POSTGRESQL_PASSWORD": "invenio",
+        "POSTGRESQL_DB": "invenio",
+    },
+    "CONTAINER_CONNECTION_ENVIRONMENT_VARIABLES": {
+        "db": {
+            "SQLALCHEMY_DATABASE_URI": "postgresql+psycopg2://invenio:invenio@localhost:5432/invenio"
+        }
+    },
+}
+"""Postgresql service configuration."""
+
+# MySQL
+MYSQL = {
+    "MYSQL_VERSION": "MYSQL_8_LATEST",
+    "DEFAULT_VERSIONS": {"MYSQL_8_LATEST": "8.3"},
+    "CONTAINER_CONFIG_ENVIRONMENT_VARIABLES": {
+        "MYSQL_USER": "invenio",
+        "MYSQL_PASSWORD": "invenio",
+        "MYSQL_DB": "invenio",
+        "MYSQL_ROOT_PASSWORD": "invenio",
+    },
+    "CONTAINER_CONNECTION_ENVIRONMENT_VARIABLES": {
+        "db": {
+            "SQLALCHEMY_DATABASE_URI": "mysql+pymysql://invenio:invenio@localhost:3306/invenio"
+        }
+    },
+}
+"""MySQL service configuration."""
+
+REDIS = {
+    "REDIS_VERSION": "REDIS_7_LATEST",
+    "DEFAULT_VERSIONS": {
+        "REDIS_6_LATEST": "6",
+        "REDIS_7_LATEST": "7",
+    },
+    "CONTAINER_CONNECTION_ENVIRONMENT_VARIABLES": {
+        "mq": {"BROKER_URL": "redis://localhost:6379/0"},
+        "cache": {"CACHE_TYPE": "redis"},
+    },
+}
+"""Redis service configuration."""
+
+RABBITMQ = {
+    "RABBITMQ_VERSION": "RABBITMQ_3_LATEST",
+    "DEFAULT_VERSIONS": {"RABBITMQ_3_LATEST": "3"},
+    "CONTAINER_CONNECTION_ENVIRONMENT_VARIABLES": {
+        "mq": {"BROKER_URL": "amqp://localhost:5672//"}
+    },
+}
+"""RabbitMQ service configuration."""
+
+MINIO = {
+    "MINIO_VERSION": "MINIO_2025_LATEST",
+    # note: minio does not do semantic versioning, so we use the latest version
+    # the release at the time of writing this is RELEASE.2025-02-28T09-55-16Z
+    "DEFAULT_VERSIONS": {"MINIO_2025_LATEST": "latest"},
+    "CONTAINER_CONFIG_ENVIRONMENT_VARIABLES": {
+        "S3_ACCESS_KEY_ID": "invenio",
+        # minio needs at least 8 characters for the secret
+        "S3_SECRET_ACCESS_KEY": "invenio8",
+    },
+    "CONTAINER_CONNECTION_ENVIRONMENT_VARIABLES": {
+        "s3": {
+            "S3_ENDPOINT_URL": "http://localhost:9000",
+            "S3_ACCESS_KEY_ID": "invenio",
+            # minio needs at least 8 characters for the secret
+            "S3_SECRET_ACCESS_KEY": "invenio8",
+        }
+    },
+}
+"""MINIO service configuration."""
+
+SERVICES = {
+    "elasticsearch": ELASTICSEARCH,
+    "opensearch": OPENSEARCH,
+    "postgresql": POSTGRESQL,
+    "mysql": MYSQL,
+    "redis": REDIS,
+    "rabbitmq": RABBITMQ,
+    "minio": MINIO,
+}
+"""List of services to configure."""
+
+SERVICES_ALL_DEFAULT_VERSIONS = {
+    **ELASTICSEARCH.get("DEFAULT_VERSIONS", {}),
+    **OPENSEARCH.get("DEFAULT_VERSIONS", {}),
+    **POSTGRESQL.get("DEFAULT_VERSIONS", {}),
+    **REDIS.get("DEFAULT_VERSIONS", {}),
+    **MYSQL.get("DEFAULT_VERSIONS", {}),
+    **RABBITMQ.get("DEFAULT_VERSIONS", {}),
+    **MINIO.get("DEFAULT_VERSIONS", {}),
+}
+"""Services default latest versions."""
+
+SERVICE_TYPES = {
+    "search": ["opensearch", "elasticsearch"],
+    "db": ["mysql", "postgresql"],
+    "cache": [
+        "redis",
+    ],
+    "mq": ["rabbitmq", "redis"],
+    "s3": ["minio"],
+}
+"""Types of offered services."""

docker_services_cli/docker-services.yml

@@ -0,0 +1,86 @@
+# SPDX-FileCopyrightText: 2020-2025 CERN.
+# SPDX-FileCopyrightText: 2024 KTH Royal Institute of Technology.
+# SPDX-FileCopyrightText: 2025 CESNET z.s.p.o.
+# SPDX-License-Identifier: MIT
+
+services:
+  redis:
+    image: redis:${REDIS_VERSION}
+    restart: "unless-stopped"
+    read_only: true
+    ports:
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:6379:6379"
+  mysql:
+    image: mysql:${MYSQL_VERSION}
+    restart: "unless-stopped"
+    environment:
+      - "MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}"
+      - "MYSQL_DATABASE=${MYSQL_DB}"
+      - "MYSQL_USER=${MYSQL_USER}"
+      - "MYSQL_PASSWORD=${MYSQL_PASSWORD}"
+    ports:
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:3306:3306"
+  postgresql:
+    image: postgres:${POSTGRESQL_VERSION}
+    restart: "unless-stopped"
+    environment:
+      - "POSTGRES_USER=${POSTGRESQL_USER}"
+      - "POSTGRES_PASSWORD=${POSTGRESQL_PASSWORD}"
+      - "POSTGRES_DB=${POSTGRESQL_DB}"
+    ports:
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:5432:5432"
+  elasticsearch:
+    image: docker.elastic.co/elasticsearch/elasticsearch-oss:${ELASTICSEARCH_VERSION}
+    restart: "unless-stopped"
+    environment:
+      - bootstrap.memory_lock=true
+      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
+      - discovery.type=single-node
+    ulimits:
+      memlock:
+        soft: -1
+        hard: -1
+    mem_limit: 2g
+    ports:
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:9200:9200"
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:9300:9300"
+  opensearch:
+    image: opensearchproject/opensearch:${OPENSEARCH_VERSION}
+    restart: "unless-stopped"
+    environment:
+      - bootstrap.memory_lock=true
+      - "OPENSEARCH_JAVA_OPTS=-Xms512m -Xmx512m"
+      - "OPENSEARCH_INITIAL_ADMIN_PASSWORD=guekxe3mvqieke1!%&ieIADE"
+      - discovery.type=single-node
+      - plugins.security.disabled=true
+    ulimits:
+      memlock:
+        soft: -1
+        hard: -1
+      nofile:
+        soft: 65536
+        hard: 65536
+    mem_limit: 2g
+    ports:
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:9200:9200"
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:9300:9300"
+  rabbitmq:
+    image: rabbitmq:${RABBITMQ_VERSION}-management
+    restart: "unless-stopped"
+    ports:
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:15672:15672"
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:5672:5672"
+  minio:
+    image: minio/minio:${MINIO_VERSION}
+    restart: "unless-stopped"
+    environment:
+      MINIO_ROOT_USER: ${S3_ACCESS_KEY_ID}
+      MINIO_ROOT_PASSWORD: ${S3_SECRET_ACCESS_KEY}
+    entrypoint: >
+      /bin/sh -c "
+      mkdir -p /data/default;
+      /usr/bin/docker-entrypoint.sh server /data --console-address :9001
+      "
+    ports:
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:9000:9000"
+      - "${DOCKER_SERVICES_IP_BIND:-127.0.0.1}:9001:9001"

docker_services_cli/env.py

@@ -0,0 +1,194 @@
+# SPDX-FileCopyrightText: 2020 CERN.
+# SPDX-FileCopyrightText: 2024 Graz University of Technology.
+# SPDX-FileCopyrightText: 2025 CESNET z.s.p.o.
+# SPDX-License-Identifier: MIT
+
+"""Environment module."""
+
+import logging
+import os
+import sys
+from distutils.version import StrictVersion
+
+import click
+
+from .config import SERVICE_TYPES, SERVICES, SERVICES_ALL_DEFAULT_VERSIONS
+
+
+def normalize_service_name(service_with_version):
+    """Return the name of the passed service without version number."""
+    service_name = None
+    if service_with_version in SERVICES:
+        service_name = service_with_version
+    else:
+        for name in SERVICES:
+            if name in service_with_version:
+                service_name = name
+                break
+
+    return service_name
+
+
+def _set_default_env(services_version, default_version):
+    """Set environmental variable value if it does not exist."""
+    os.environ[services_version] = os.environ.get(services_version, default_version)
+
+
+def _is_version(version):
+    """Checks if a string is a version of the format `x.y.z`.
+
+    NOTE: It is not mandatory to be up to patch level. The following would be
+    accepted:
+    - 10.1
+    - 9
+    - 15.0.1a2
+    """
+    try:
+        # StrictVersion fails on plain numbers (e.g. "10")
+        if version.isnumeric():
+            return True
+        StrictVersion(version)
+        return True
+    except Exception:
+        return False
+
+
+def _load_or_set_env(services_version, default_version):
+    """Set a specific service version from the environment.
+
+    It parses the value to distinguish between a version and a defined latest.
+    NOTE: It requires that all variables for latest versions have been set up.
+    """
+    version_from_env = os.environ.get(services_version, default_version)
+    # e.g. the ES_7_LATEST string from env, need a second get.
+    major_version_from_env = os.environ.get(version_from_env)
+
+    if not version_from_env:
+        os.environ[services_version] = default_version
+
+    elif (
+        _is_version(version_from_env)
+        # for example for minio, where we do not have a semantic version
+        or version_from_env == "latest"
+    ):
+        os.environ[services_version] = version_from_env
+
+    elif major_version_from_env and (
+        _is_version(major_version_from_env)
+        # for example for minio, where we do not have a semantic version
+        or major_version_from_env == "latest"
+    ):
+        os.environ[services_version] = major_version_from_env
+
+    else:
+        click.secho(
+            f"Environment variable for version {version_from_env} not set \
+            or set to a non-compliant format (dot separated numbers).",
+            fg="red",
+        )
+        sys.exit(1)
+
+
+def override_default_env(services_to_override=None):
+    """Override default environment according to list of services with version.
+
+    :param services_to_override: List of service name strings including
+        service version without any separator e.g. ``postgresql11``.
+    """
+    services_to_override = set(services_to_override or []).difference(SERVICES.keys())
+    if services_to_override:
+        num_services_to_override = len(services_to_override)
+        for service_name in SERVICES:
+            for service_override in services_to_override:
+                if service_name in service_override:
+                    service_override_version = service_override.replace(
+                        service_name, ""
+                    )
+                    env_var_with_version = (
+                        f"{service_name.upper()}_{service_override_version}_LATEST"
+                    )
+                    if SERVICES_ALL_DEFAULT_VERSIONS.get(env_var_with_version):
+                        os.environ[f"{service_name.upper()}_VERSION"] = (
+                            SERVICES_ALL_DEFAULT_VERSIONS.get(env_var_with_version)
+                        )
+                    else:
+                        available_major_versions = [
+                            v.split(".")[0]
+                            for v in SERVICES[service_name]["DEFAULT_VERSIONS"].values()
+                        ]
+                        click.secho(
+                            f"No major version {service_override_version} "
+                            f"for {service_name}. "
+                            "Please use one of the available "
+                            f"ones: {available_major_versions}",
+                            fg="red",
+                        )
+                        exit(1)
+                    num_services_to_override -= 1
+                    if not num_services_to_override:
+                        return
+
+
+def set_env():
+    """Export the environment variables for services and versions."""
+    for key, value in SERVICES_ALL_DEFAULT_VERSIONS.items():
+        _set_default_env(key, value)
+
+    for service in SERVICES.values():
+        for key, value in service.items():
+            if key.endswith("_VERSION"):
+                _load_or_set_env(key, value)
+            elif key == "CONTAINER_CONFIG_ENVIRONMENT_VARIABLES":
+                for envvar_name, envvar_value in value.items():
+                    _set_default_env(envvar_name, envvar_value)
+
+
+def print_setup_env_config(services, called_from, env_set_command="export"):
+    """Prints setup environment instructions."""
+    should_print_instructions = False
+    for service_type, services_list in services.items():
+        if called_from == "up" and len(services_list) > 1:
+            logging.warning(
+                "Multiple %s services %s are being configured. "
+                "Note that only %s will be accessible.",
+                service_type,
+                services_list,
+                services_list[-1],
+            )
+
+        for key, value in get_service_env_vars(service_type, services_list):
+            command = f"{env_set_command} {key}"
+            if env_set_command == "export":
+                command += f"={value}"
+            click.echo(command)
+            should_print_instructions = True
+
+    if should_print_instructions:
+        click.secho("# Configure your environment running:", fg="yellow")
+        instructions = f'# eval "$(docker-services-cli {called_from}'
+        if called_from == "up" and services != SERVICE_TYPES:
+            instructions += " " + " ".join(
+                [
+                    "--{0} {1}".format(service_type, service)
+                    for service_type, services_list in services.items()
+                    for service in services_list
+                ]
+            )
+        instructions += ' --env)"'
+        click.secho(instructions, fg="yellow")
+
+
+def get_service_env_vars(service_type, services_list):
+    """Get all or a subset of service environment variables."""
+    envvars = []
+    for service in services_list:
+        service_envvars_by_type = (
+            SERVICES.get(normalize_service_name(service))
+            .get("CONTAINER_CONNECTION_ENVIRONMENT_VARIABLES", {})
+            .get(service_type, {})
+            .items()
+        )
+        for key, value in service_envvars_by_type:
+            envvars.append((key, value))
+
+    return envvars

docker_services_cli/services.py

@@ -0,0 +1,228 @@
+# SPDX-FileCopyrightText: 2020 CERN.
+# SPDX-FileCopyrightText: 2024 Graz University of Technology.
+# SPDX-FileCopyrightText: 2025 CESNET z.s.p.o.
+# SPDX-License-Identifier: MIT
+
+"""Services module."""
+
+import time
+from os import path
+from subprocess import PIPE, Popen, check_call
+
+import click
+
+from .config import DOCKER_SERVICES_FILEPATH, MYSQL, SERVICE_TYPES
+
+
+def _run_healthcheck_command(command, verbose=False):
+    """Runs a given command, returns True if it succeeds, False otherwise."""
+    p = Popen(command, stdout=PIPE, stderr=PIPE)
+    output, error = p.communicate()
+    output = output.decode("utf-8")
+    error = error.decode("utf-8")
+    if p.returncode == 0:
+        if verbose:
+            click.secho(output, fg="green")
+        return True
+    if p.returncode != 0:
+        if verbose:
+            click.secho(
+                f"Healthcheck failed.\nOutput: {output}\nError:{error}", fg="red"
+            )
+        return False
+
+
+def search_healthcheck(*args, **kwargs):
+    """{Elastic,Open}Search healthcheck."""
+    verbose = kwargs["verbose"]
+
+    return _run_healthcheck_command(
+        ["curl", "-f", "localhost:9200/_cluster/health?wait_for_status=green"], verbose
+    )
+
+
+def postgresql_healthcheck(*args, **kwargs):
+    """Postgresql healthcheck."""
+    filepath = kwargs["filepath"]
+    verbose = kwargs["verbose"]
+
+    return _run_healthcheck_command(
+        [
+            "docker",
+            "compose",
+            "--file",
+            filepath,
+            "exec",
+            "-T",
+            "postgresql",
+            "bash",
+            "-c",
+            "pg_isready",
+        ],
+        verbose,
+    )
+
+
+def mysql_healthcheck(*args, **kwargs):
+    """Mysql healthcheck."""
+    filepath = kwargs["filepath"]
+    verbose = kwargs["verbose"]
+    password = MYSQL["CONTAINER_CONFIG_ENVIRONMENT_VARIABLES"]["MYSQL_ROOT_PASSWORD"]
+
+    return _run_healthcheck_command(
+        [
+            "docker",
+            "compose",
+            "--file",
+            filepath,
+            "exec",
+            "-T",
+            "mysql",
+            "bash",
+            "-c",
+            f'mysql -p{password} -e "select Version();"',
+        ],
+        verbose,
+    )
+
+
+def rabbitmq_healthcheck(*args, **kwargs):
+    """Rabbitmq healthcheck."""
+    filepath = kwargs["filepath"]
+    verbose = kwargs["verbose"]
+
+    return _run_healthcheck_command(
+        [
+            "docker",
+            "compose",
+            "--file",
+            filepath,
+            "exec",
+            "-T",
+            "rabbitmq",
+            "bash",
+            "-c",
+            "rabbitmq-diagnostics check_running",
+        ],
+        verbose,
+    )
+
+
+def redis_healthcheck(*args, **kwargs):
+    """Redis healthcheck."""
+    filepath = kwargs["filepath"]
+    verbose = kwargs["verbose"]
+
+    return _run_healthcheck_command(
+        [
+            "docker",
+            "compose",
+            "--file",
+            filepath,
+            "exec",
+            "-T",
+            "redis",
+            "bash",
+            "-c",
+            "redis-cli ping",
+            "|",
+            "grep 'PONG'",
+            "&>/dev/null;",
+        ],
+        verbose,
+    )
+
+
+def minio_healthcheck(*args, **kwargs):
+    """Minio healthcheck."""
+    verbose = kwargs["verbose"]
+
+    return _run_healthcheck_command(
+        ["curl", "-f", "http://localhost:9000/minio/health/live"], verbose
+    )
+
+
+HEALTHCHECKS = {
+    "elasticsearch": search_healthcheck,
+    "opensearch": search_healthcheck,
+    "postgresql": postgresql_healthcheck,
+    "mysql": mysql_healthcheck,
+    "rabbitmq": rabbitmq_healthcheck,
+    "redis": redis_healthcheck,
+    "minio": minio_healthcheck,
+}
+"""Health check functions module path, as string."""
+
+
+def wait_for_services(
+    services, filepath=DOCKER_SERVICES_FILEPATH, max_retries=6, verbose=False
+):
+    """Wait for services to be up.
+
+    It performs configured healthchecks in a serial fashion, following the
+    order given in the ``up`` command. If the services is an empty list, to be
+    compliant with `docker compose` it will perform the healthchecks of all the
+    services.
+    """
+    if len(services) == 0:
+        services = HEALTHCHECKS.keys()
+
+    for service in services:
+        exp_backoff_time = 2
+        try_ = 1
+        # Using plain __import__ to avoid depending on invenio-base
+        check = HEALTHCHECKS[service]
+        ready = check(filepath=filepath, verbose=verbose)
+        while not ready and try_ < max_retries:
+            click.secho(
+                f"{service} not ready at {try_} retries, waiting {exp_backoff_time}s",
+                fg="yellow",
+            )
+            try_ += 1
+            time.sleep(exp_backoff_time)
+            exp_backoff_time *= 2
+            ready = check(filepath=filepath, verbose=verbose)
+
+        if not ready:
+            click.secho(f"Unable to boot up {service}", fg="red")
+            exit(1)
+        else:
+            click.secho(f"{service} up and running!", fg="green")
+
+
+def services_up(
+    services, filepath=DOCKER_SERVICES_FILEPATH, wait=True, retries=6, verbose=False
+):
+    """Start the given services up.
+
+    docker compose is smart about not rebuilding an image if
+    there is no need to, so --build is not a slow default. In addition
+    ``--detach`` is not supported in 1.17.0 or previous.
+    """
+    services = services or [
+        service for _, services in SERVICE_TYPES.items() for service in services
+    ]
+    if not path.exists(filepath):
+        click.secho(
+            f"Filepath {filepath} for docker-services.yml file does not exist.",
+            fg="red",
+        )
+        exit(1)
+
+    command = ["docker", "compose", "--file", filepath, "up", "-d"]
+    command.extend(services)
+
+    check_call(command)
+    if wait:
+        wait_for_services(services, filepath, max_retries=retries, verbose=verbose)
+
+
+def services_down(filepath=DOCKER_SERVICES_FILEPATH):
+    """Stops the given services.
+
+    It does not requries the services. It stops containers and removes
+    containers, networks, volumes, and images created by ``up``.
+    """
+    command = ["docker", "compose", "--file", filepath, "down", "--volumes"]
+
+    check_call(command)

docker_services_cli-0.12.2.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: Docker-Services-CLI
+Version: 0.12.2
+Summary: Python module to ease the creation and management of external services.
+Project-URL: Repository, https://github.com/inveniosoftware/docker-services-cli
+Author-email: CERN <info@inveniosoftware.org>
+License-Expression: MIT
+License-File: AUTHORS.rst
+License-File: LICENSE
+Keywords: cli,docker,services
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.8
+Requires-Dist: check-manifest>=0.42
+Requires-Dist: click>=7.0
+Provides-Extra: tests
+Requires-Dist: pytest-black>=0.6.0; extra == 'tests'
+Requires-Dist: pytest-cov>=3.0.0; extra == 'tests'
+Requires-Dist: pytest-isort>=3.0.0; extra == 'tests'
+Requires-Dist: pytest-pycodestyle>=2.2.0; extra == 'tests'
+Requires-Dist: pytest-pydocstyle>=2.2.3; extra == 'tests'
+Requires-Dist: pytest<9,>=6; extra == 'tests'
+Requires-Dist: sphinx>=4.5; extra == 'tests'
+Description-Content-Type: text/x-rst
+
+..
+    SPDX-FileCopyrightText: 2020 CERN.
+    SPDX-License-Identifier: MIT
+
+===================
+Docker-Services-CLI
+===================
+
+.. image:: https://github.com/inveniosoftware/docker-services-cli/workflows/CI/badge.svg
+        :target: https://github.com/inveniosoftware/docker-services-cli/actions?query=workflow%3ACI
+
+
+Python module to start external services needed to tests Invenio modules and applications.

docker_services_cli-0.12.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+docker_services_cli/__init__.py,sha256=BaX_kDwfAhN4OT57WySTapi4mYceFrC6MJOGEzkcBP4,1010
+docker_services_cli/cli.py,sha256=CXC59Vqy2IRVb0sbOVbIfcHx-FW9tfnWzOIAbiNxxT4,5957
+docker_services_cli/config.py,sha256=YK4y8gAsNKwylwlxbAl7KRjfs_B1tMq-s0A9fBsSsVc,5327
+docker_services_cli/docker-services.yml,sha256=w2bmFxB73BrTUyBAHUJ-M0AG1BPRhyfY9vo9g9KNTKg,2757
+docker_services_cli/env.py,sha256=7ILguYJ-3eOqO8_vyKjEfEyVRGlr-I1gsU83hyqzKM8,7137
+docker_services_cli/services.py,sha256=TTRqlOASTM-gDgLjfd2nKsChv5BhRrQV4G8HfrjNveg,6170
+docker_services_cli-0.12.2.dist-info/METADATA,sha256=mK5noipC-wSj3GJS6BHLHzhYGceB1qHXNH3mI2wvdf4,1346
+docker_services_cli-0.12.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+docker_services_cli-0.12.2.dist-info/entry_points.txt,sha256=KB-GjGrrAvFWMQ-GRsO_a-INQeO7yPh2_GkPlj80tFQ,68
+docker_services_cli-0.12.2.dist-info/licenses/AUTHORS.rst,sha256=j2PS73v5ajTs3mjQ1zQLxnP7H1-Eq8WcbIF0cAhm86w,130
+docker_services_cli-0.12.2.dist-info/licenses/LICENSE,sha256=ZiCjjVShFiNyAecBnVjHFO3Wzfrp86N8j_pffcCZpE8,1061
+docker_services_cli-0.12.2.dist-info/RECORD,,

docker_services_cli-0.12.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

docker_services_cli-0.12.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+docker-services-cli = docker_services_cli.cli:cli

docker_services_cli-0.12.2.dist-info/licenses/AUTHORS.rst

@@ -0,0 +1,9 @@
+..
+    SPDX-FileCopyrightText: 2020 CERN.
+    SPDX-License-Identifier: MIT
+
+Authors
+=======
+
+- Konstantina Stoikou
+- Pablo Panero

docker_services_cli-0.12.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 CERN
+
+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.