katalon-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{katalon_cli-0.1.2 → katalon_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: katalon-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: Installer & Updater CLI für Katalon Production-Instanzen
 Author: Karl Krägelin
 Author-email: Karl Krägelin <karlkraegelin@gmail.com>
@@ -66,7 +66,13 @@ uv run pytest
 
 - `core/state.py` — `installation.json`, Single Source of Truth für laufende Version.
 - `core/release.py` — GitHub-Release-Metadaten (`katalon-release.json` Asset), 1h Cache.
-- `core/compose_gen.py` + `templates/compose.yaml.j2` — rendert `compose.yaml` aus Version + TLS-Modus.
+- `core/compose_gen.py` + `templates/compose.yaml.j2` + `templates/nginx.conf.j2` — rendert `compose.yaml`
+  + `nginx.conf` aus Version + TLS-Modus; erzeugt bei `tls_mode=standalone` ein selbstsigniertes
+  Zertifikat unter `<dir>/certs/` (eigenes Zertifikat dort ablegen, um es zu ersetzen).
+  `install` fragt zusätzlich `MEDIA_ROOT` ab und legt `<dir>/compose.override.yaml.example` an
+  (instanzspezifische Overrides — umbenennen zu `compose.override.yaml`, wird automatisch eingebunden
+  und bei Updates nicht angefasst). Optionale Env-Vars (Admin-Login, SMTP, Geonames, …) landet
+  auskommentiert in `.env`.
 - `core/backup.py` — `pg_dump` vor jedem Update; Rollback restauriert Dump statt `alembic downgrade`.
 - `core/docker.py` — dünner `docker compose`-Subprocess-Wrapper.
 - `main.py` — Typer-Commands, interaktive Teile über `rich.prompt`/`rich.progress`.

{katalon_cli-0.1.2 → katalon_cli-0.1.4}/README.md

@@ -52,7 +52,13 @@ uv run pytest
 
 - `core/state.py` — `installation.json`, Single Source of Truth für laufende Version.
 - `core/release.py` — GitHub-Release-Metadaten (`katalon-release.json` Asset), 1h Cache.
-- `core/compose_gen.py` + `templates/compose.yaml.j2` — rendert `compose.yaml` aus Version + TLS-Modus.
+- `core/compose_gen.py` + `templates/compose.yaml.j2` + `templates/nginx.conf.j2` — rendert `compose.yaml`
+  + `nginx.conf` aus Version + TLS-Modus; erzeugt bei `tls_mode=standalone` ein selbstsigniertes
+  Zertifikat unter `<dir>/certs/` (eigenes Zertifikat dort ablegen, um es zu ersetzen).
+  `install` fragt zusätzlich `MEDIA_ROOT` ab und legt `<dir>/compose.override.yaml.example` an
+  (instanzspezifische Overrides — umbenennen zu `compose.override.yaml`, wird automatisch eingebunden
+  und bei Updates nicht angefasst). Optionale Env-Vars (Admin-Login, SMTP, Geonames, …) landet
+  auskommentiert in `.env`.
 - `core/backup.py` — `pg_dump` vor jedem Update; Rollback restauriert Dump statt `alembic downgrade`.
 - `core/docker.py` — dünner `docker compose`-Subprocess-Wrapper.
 - `main.py` — Typer-Commands, interaktive Teile über `rich.prompt`/`rich.progress`.

{katalon_cli-0.1.2 → katalon_cli-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "katalon-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "Installer & Updater CLI für Katalon Production-Instanzen"
 readme = "README.md"
 requires-python = ">=3.12"

{katalon_cli-0.1.2 → katalon_cli-0.1.4}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "katalon-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "Installer & Updater CLI für Katalon Production-Instanzen"
 readme = "README.md"
 authors = [

{katalon_cli-0.1.2 → katalon_cli-0.1.4}/src/katalon_cli/core/backup.py

@@ -49,7 +49,7 @@ def restore_backup(instance_dir: Path, backup_dir: Path) -> None:
     docker.compose(instance_dir, "exec", "-T", "db", "dropdb", "-U", "katalon", "katalon")
     docker.compose(instance_dir, "exec", "-T", "db", "createdb", "-U", "katalon", "katalon")
     subprocess.run(
-        [*docker.compose_command(), "-f", str(instance_dir / "compose.yaml"),
+        [*docker.compose_command(), *docker.compose_files(instance_dir),
          "exec", "-T", "db", "psql", "-U", "katalon", "katalon"],
         input=dump_file.read_text(),
         cwd=instance_dir,

{katalon_cli-0.1.2 → katalon_cli-0.1.4}/src/katalon_cli/core/checks.py

@@ -42,20 +42,31 @@ def check_disk_space(path: Path, min_gb: int = MIN_FREE_DISK_GB) -> CheckResult:
         "Diskspace", ok, f"{free_gb:.1f} GB frei (min. {min_gb} GB) in {path}"
     )
 
+def check_openssl() -> CheckResult:
+    if not shutil.which("openssl"):
+        return CheckResult("OpenSSL", False, "nicht gefunden — für TLS-Modus 'standalone' erforderlich")
+    return CheckResult("OpenSSL", True, "gefunden")
+
+
+def is_port_in_use(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.settimeout(0.5)
+        return s.connect_ex(("127.0.0.1", port)) == 0
+
+
 def check_ports(ports: list[int]) -> CheckResult:
-    busy = []
-    for port in ports:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            s.settimeout(0.5)
-            if s.connect_ex(("127.0.0.1", port)) == 0:
-                busy.append(port)
+    busy = [port for port in ports if is_port_in_use(port)]
     if busy:
         return CheckResult("Ports", False, f"belegt: {', '.join(map(str, busy))}")
     return CheckResult("Ports", True, f"frei: {', '.join(map(str, ports))}")
 
 
-def run_all(instance_dir: Path, ports: list[int] | None = None) -> list[CheckResult]:
+def run_all(
+    instance_dir: Path, ports: list[int] | None = None, need_openssl: bool = False
+) -> list[CheckResult]:
     results = [check_docker(), check_compose(), check_disk_space(instance_dir)]
     if ports:
         results.append(check_ports(ports))
+    if need_openssl:
+        results.append(check_openssl())
     return results

katalon_cli-0.1.4/src/katalon_cli/core/compose_gen.py

@@ -0,0 +1,85 @@
+"""Rendert compose.yaml + nginx.conf aus Template + Release-Version + TLS-Modus."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from jinja2 import Environment, PackageLoader, select_autoescape
+
+_env = Environment(
+    loader=PackageLoader("katalon_cli", "templates"),
+    autoescape=select_autoescape(disabled_extensions=(".yaml", ".j2", ".conf")),
+    trim_blocks=True,
+    lstrip_blocks=True,
+)
+
+
+def render_compose(
+    *,
+    version: str,
+    base_url: str,
+    tls_mode: str,
+    registry: str = "ghcr.io/katalon-collections/katalon",
+) -> str:
+    from urllib.parse import urlparse
+
+    parsed_port = urlparse(base_url).port
+    template = _env.get_template("compose.yaml.j2")
+    return template.render(
+        version=version,
+        base_url=base_url,
+        tls_mode=tls_mode,
+        registry=registry,
+        port=parsed_port,
+    )
+
+def render_nginx_conf(*, tls_mode: str) -> str:
+    template = _env.get_template("nginx.conf.j2")
+    return template.render(tls_mode=tls_mode)
+
+
+def write_compose(instance_dir: Path, **kwargs) -> Path:
+    content = render_compose(**kwargs)
+    path = instance_dir / "compose.yaml"
+    path.write_text(content)
+
+    nginx_path = instance_dir / "nginx.conf"
+    nginx_path.write_text(render_nginx_conf(tls_mode=kwargs["tls_mode"]))
+
+    if kwargs["tls_mode"] == "standalone":
+        ensure_self_signed_cert(instance_dir, host=_host_of(kwargs["base_url"]))
+
+    return path
+
+
+def ensure_self_signed_cert(instance_dir: Path, *, host: str) -> None:
+    """Legt ein selbstsigniertes Zertifikat an, falls keins vorhanden ist.
+
+    Für echtes TLS eigenes Zertifikat (z.B. Let's Encrypt) unter
+    <instance_dir>/certs/fullchain.pem + privkey.pem ablegen — wird nicht überschrieben.
+    """
+    certs_dir = instance_dir / "certs"
+    fullchain = certs_dir / "fullchain.pem"
+    privkey = certs_dir / "privkey.pem"
+    if fullchain.exists() and privkey.exists():
+        return
+
+    certs_dir.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        [
+            "openssl", "req", "-x509", "-nodes", "-newkey", "rsa:2048",
+            "-days", "825",
+            "-keyout", str(privkey),
+            "-out", str(fullchain),
+            "-subj", f"/CN={host}",
+        ],
+        check=True,
+        capture_output=True,
+    )
+
+
+def _host_of(base_url: str) -> str:
+    from urllib.parse import urlparse
+
+    return urlparse(base_url).hostname or "localhost"

{katalon_cli-0.1.2 → katalon_cli-0.1.4}/src/katalon_cli/core/docker.py

@@ -4,9 +4,9 @@ from __future__ import annotations
 
 import shutil
 import subprocess
+import time
 from pathlib import Path
 
-
 class DockerError(RuntimeError):
     pass
 
@@ -24,10 +24,18 @@ def compose_command() -> list[str]:
     raise DockerError("Docker Compose ist nicht installiert.")
 
 
+def compose_files(instance_dir: Path) -> list[str]:
+    files = ["-f", str(instance_dir / "compose.yaml")]
+    override = instance_dir / "compose.override.yaml"
+    if override.exists():
+        files += ["-f", str(override)]
+    return files
+
+
 def compose(
     instance_dir: Path, *args: str, check: bool = True, capture: bool = False
 ) -> subprocess.CompletedProcess:
-    cmd = [*compose_command(), "-f", str(instance_dir / "compose.yaml"), *args]
+    cmd = [*compose_command(), *compose_files(instance_dir), *args]
     return subprocess.run(
         cmd,
         cwd=instance_dir,
@@ -42,3 +50,27 @@ def is_healthy(instance_dir: Path, service: str = "api") -> bool:
         instance_dir, "ps", "--format", "json", service, check=False, capture=True
     )
     return result.returncode == 0 and '"Health":"healthy"' in (result.stdout or "")
+
+
+def is_running(instance_dir: Path, service: str = "db") -> bool:
+    result = compose(
+        instance_dir, "ps", "--status", "running", "-q", service, check=False, capture=True
+    )
+    return result.returncode == 0 and bool(result.stdout.strip())
+
+
+def wait_for_db(instance_dir: Path, timeout: int = 30) -> bool:
+    for _ in range(timeout):
+        result = compose(
+            instance_dir,
+            "exec",
+            "-T",
+            "db",
+            "pg_isready",
+            check=False,
+            capture=True,
+        )
+        if result.returncode == 0:
+            return True
+        time.sleep(1)
+    return False