260 lines
7.7 KiB
Python
260 lines
7.7 KiB
Python
"""Docker container lifecycle management for ebook search."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import os
|
|
import subprocess
|
|
from pathlib import Path
|
|
from typing import Annotated
|
|
|
|
import typer
|
|
|
|
from python.common import configure_logger, get_repo_dir
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def get_compose_file() -> Path:
|
|
"""Return the path to the docker-compose.yml file."""
|
|
return Path(__file__).resolve().with_name("docker-compose.yml")
|
|
|
|
|
|
def compose_base_args() -> list[str]:
|
|
"""Return the common docker compose arguments for the ebook search stack."""
|
|
return ["compose", "-f", str(get_compose_file())]
|
|
|
|
|
|
def docker_run(
|
|
arguments: list[str],
|
|
*,
|
|
env: dict[str, str] | None = None,
|
|
capture_output: bool = False,
|
|
) -> subprocess.CompletedProcess[str]:
|
|
"""Run docker with repo-root cwd and consistent error handling."""
|
|
logger.info(f"docker {' '.join(arguments)}")
|
|
return subprocess.run(
|
|
["docker", *arguments],
|
|
cwd=get_repo_dir(),
|
|
env=env,
|
|
text=True,
|
|
check=False,
|
|
capture_output=capture_output,
|
|
)
|
|
|
|
|
|
def compose_env(*, library_path: Path | None = None, port: int | None = None) -> dict[str, str]:
|
|
"""Return environment variables passed to docker compose."""
|
|
env = os.environ.copy()
|
|
if library_path is not None:
|
|
resolved_library = library_path.expanduser().resolve()
|
|
if not resolved_library.exists():
|
|
msg = f"EPUB library path does not exist: {resolved_library}"
|
|
raise FileNotFoundError(msg)
|
|
env["EBOOK_LIBRARY_HOST_PATH"] = str(resolved_library)
|
|
if port is not None:
|
|
env["EBOOK_SEARCH_PORT"] = str(port)
|
|
return env
|
|
|
|
|
|
def ensure_compose_file() -> None:
|
|
"""Raise if the ebook search compose file is missing."""
|
|
if not get_compose_file().is_file():
|
|
msg = f"Compose file not found: {get_compose_file()}"
|
|
raise FileNotFoundError(msg)
|
|
|
|
|
|
def build_image() -> None:
|
|
"""Build the ebook search app image."""
|
|
ensure_compose_file()
|
|
result = docker_run([*compose_base_args(), "build"])
|
|
if result.returncode != 0:
|
|
msg = "Failed to build ebook search image"
|
|
raise RuntimeError(msg)
|
|
|
|
|
|
def build_test_image() -> None:
|
|
"""Build the ebook search test Docker image."""
|
|
dockerfile = Path(__file__).resolve().with_name("Dockerfile")
|
|
result = docker_run(["build", "--file", str(dockerfile), "--target", "test", "--tag", "ebook-search:test", "."])
|
|
if result.returncode != 0:
|
|
msg = "Failed to build ebook search test image"
|
|
raise RuntimeError(msg)
|
|
|
|
|
|
def run_test_image() -> None:
|
|
"""Run the ebook search test suite inside Docker."""
|
|
result = docker_run(["run", "--rm", "ebook-search:test"])
|
|
if result.returncode != 0:
|
|
msg = f"Ebook search tests failed with code {result.returncode}"
|
|
raise RuntimeError(msg)
|
|
|
|
|
|
def start_stack(
|
|
*,
|
|
library_path: Path | None = None,
|
|
port: int | None = None,
|
|
build: bool = False,
|
|
) -> None:
|
|
"""Start the ebook search Docker compose stack."""
|
|
ensure_compose_file()
|
|
env = compose_env(library_path=library_path, port=port)
|
|
if build:
|
|
build_image()
|
|
result = docker_run(
|
|
[*compose_base_args(), "up", "-d"],
|
|
env=env,
|
|
)
|
|
if result.returncode != 0:
|
|
msg = f"Ebook search stack failed to start with code {result.returncode}"
|
|
raise RuntimeError(msg)
|
|
logger.info("Ebook search started.")
|
|
|
|
|
|
def stop_stack(
|
|
*,
|
|
volumes: bool = False,
|
|
) -> None:
|
|
"""Stop and remove ebook search containers."""
|
|
ensure_compose_file()
|
|
command = [*compose_base_args(), "down"]
|
|
if volumes:
|
|
command.append("-v")
|
|
result = docker_run(command)
|
|
if result.returncode != 0:
|
|
msg = f"Ebook search stack failed to stop with code {result.returncode}"
|
|
raise RuntimeError(msg)
|
|
|
|
|
|
def logs_stack(
|
|
*,
|
|
service: str | None = None,
|
|
tail: int = 100,
|
|
follow: bool = False,
|
|
) -> str | None:
|
|
"""Return recent logs from the ebook search stack."""
|
|
ensure_compose_file()
|
|
command = [*compose_base_args(), "logs", "--tail", str(tail)]
|
|
if follow:
|
|
command.append("--follow")
|
|
if service:
|
|
command.append(service)
|
|
result = docker_run(command, capture_output=not follow)
|
|
if result.returncode != 0:
|
|
return None
|
|
if follow:
|
|
return ""
|
|
return result.stdout + result.stderr
|
|
|
|
|
|
def ps_stack() -> str | None:
|
|
"""Return docker compose ps output for the ebook search stack."""
|
|
ensure_compose_file()
|
|
result = docker_run([*compose_base_args(), "ps"], capture_output=True)
|
|
if result.returncode != 0:
|
|
return None
|
|
return result.stdout + result.stderr
|
|
|
|
|
|
app = typer.Typer(help="Ebook search Docker container management.", no_args_is_help=True)
|
|
|
|
|
|
@app.command()
|
|
def build() -> None:
|
|
"""Build the ebook search Docker image."""
|
|
build_image()
|
|
|
|
|
|
@app.command()
|
|
def start(
|
|
library_path: Annotated[Path | None, typer.Option(help="Override host path containing EPUB files.")] = None,
|
|
port: Annotated[int | None, typer.Option(help="Override host port for the web UI.")] = None,
|
|
*,
|
|
build: Annotated[bool, typer.Option("--build", help="Build the image before starting.")] = False,
|
|
log_level: Annotated[str, typer.Option(help="Log level.")] = "INFO",
|
|
) -> None:
|
|
"""Start the ebook search container."""
|
|
configure_logger(log_level)
|
|
start_stack(
|
|
library_path=library_path,
|
|
port=port,
|
|
build=build,
|
|
)
|
|
|
|
|
|
@app.command()
|
|
def stop(
|
|
*,
|
|
volumes: Annotated[bool, typer.Option("--volumes", help="Also remove ebook search data volumes.")] = False,
|
|
log_level: Annotated[str, typer.Option(help="Log level.")] = "INFO",
|
|
) -> None:
|
|
"""Stop and remove ebook search containers."""
|
|
configure_logger(log_level)
|
|
stop_stack(volumes=volumes)
|
|
|
|
|
|
@app.command()
|
|
def restart(
|
|
library_path: Annotated[Path | None, typer.Option(help="Override host path containing EPUB files.")] = None,
|
|
port: Annotated[int | None, typer.Option(help="Override host port for the web UI.")] = None,
|
|
*,
|
|
build: Annotated[bool, typer.Option("--build", help="Build the image before starting.")] = False,
|
|
log_level: Annotated[str, typer.Option(help="Log level.")] = "INFO",
|
|
) -> None:
|
|
"""Restart the ebook search stack."""
|
|
configure_logger(log_level)
|
|
stop_stack()
|
|
start_stack(
|
|
library_path=library_path,
|
|
port=port,
|
|
build=build,
|
|
)
|
|
|
|
|
|
@app.command()
|
|
def logs(
|
|
service: Annotated[str | None, typer.Option(help="Service name, or omit for all services.")] = None,
|
|
tail: Annotated[int, typer.Option(help="Number of recent log lines.")] = 100,
|
|
*,
|
|
follow: Annotated[bool, typer.Option("--follow", "-f", help="Follow logs.")] = False,
|
|
) -> None:
|
|
"""Show recent ebook search container logs."""
|
|
output = logs_stack(service=service, tail=tail, follow=follow)
|
|
if output is None:
|
|
typer.echo("No ebook search containers found.")
|
|
raise typer.Exit(code=1)
|
|
if output:
|
|
typer.echo(output)
|
|
|
|
|
|
@app.command("test")
|
|
def run_tests(
|
|
*,
|
|
build: Annotated[bool, typer.Option("--build/--no-build", help="Build the test image before running.")] = True,
|
|
log_level: Annotated[str, typer.Option(help="Log level.")] = "INFO",
|
|
) -> None:
|
|
"""Run ebook search tests inside the Docker test image."""
|
|
configure_logger(log_level)
|
|
if build:
|
|
build_test_image()
|
|
run_test_image()
|
|
|
|
|
|
@app.command("ps")
|
|
def ps() -> None:
|
|
"""Show ebook search container status."""
|
|
output = ps_stack()
|
|
if output is None:
|
|
typer.echo("No ebook search containers found.")
|
|
raise typer.Exit(code=1)
|
|
typer.echo(output)
|
|
|
|
|
|
def cli() -> None:
|
|
"""Typer entry point."""
|
|
app()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
cli()
|