redock-vps 0.1.1__py3-none-any.whl

redock/application/add_catalog_item.py

@@ -0,0 +1,26 @@
+from redock.application.catalog_commands import AddCatalogItemCommand
+from redock.application.exceptions import CatalogItemAlreadyExists
+from redock.domain.catalog_item import CatalogItem
+from redock.domain.ports import CatalogRepository
+
+
+class AddCatalogItemUseCase:
+    def __init__(self, repo: CatalogRepository) -> None:
+        self._repo = repo
+
+    def execute(self, cmd: AddCatalogItemCommand) -> CatalogItem:
+        item = CatalogItem.from_image(
+            cmd.image,
+            port=cmd.port,
+            volume_mount=cmd.volume_mount,
+            entrypoint=cmd.entrypoint,
+            user=cmd.user,
+            user_id=cmd.user_id,
+            hub_link=cmd.hub_link,
+            project_link=cmd.project_link,
+            env=cmd.env,
+        )
+        if self._repo.get(item.id) is not None:
+            raise CatalogItemAlreadyExists(item.id)
+        self._repo.add(item)
+        return item

redock/application/catalog_commands.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class AddCatalogItemCommand:
+    image: str
+    port: int | None = None
+    volume_mount: str | None = None
+    entrypoint: str | None = None
+    user: str | None = None
+    user_id: int | None = None
+    hub_link: str | None = None
+    project_link: str | None = None
+    env: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class GetCatalogItemCommand:
+    id: str
+
+
+@dataclass(frozen=True)
+class ListCatalogItemsCommand:
+    checked_only: bool = False
+
+
+@dataclass(frozen=True)
+class UpdateCatalogItemCommand:
+    id: str
+    image: str | None = None
+    port: int | None = None
+    volume_mount: str | None = None
+    entrypoint: str | None = None
+    user: str | None = None
+    user_id: int | None = None
+    hub_link: str | None = None
+    project_link: str | None = None
+    env: dict[str, str] | None = None
+    unset_env: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class DeleteCatalogItemCommand:
+    id: str
+
+
+@dataclass(frozen=True)
+class CheckCatalogItemCommand:
+    id: str
+    checked: bool = True
+
+
+@dataclass(frozen=True)
+class SearchDockerHubCommand:
+    query: str
+    page_size: int = 25
+
+
+@dataclass(frozen=True)
+class EnrichCatalogItemCommand:
+    image: str
+
+
+@dataclass(frozen=True)
+class ScanCatalogItemCommand:
+    id: str
+    dry_run: bool = False

redock/application/check_catalog_item.py

@@ -0,0 +1,20 @@
+from datetime import datetime, timezone
+
+from redock.application.catalog_commands import CheckCatalogItemCommand
+from redock.application.exceptions import CatalogItemNotFound
+from redock.domain.catalog_item import CatalogItem
+from redock.domain.ports import CatalogRepository
+
+
+class CheckCatalogItemUseCase:
+    def __init__(self, repo: CatalogRepository) -> None:
+        self._repo = repo
+
+    def execute(self, cmd: CheckCatalogItemCommand) -> CatalogItem:
+        item = self._repo.get(cmd.id)
+        if item is None:
+            raise CatalogItemNotFound(cmd.id)
+        item.checked = cmd.checked
+        item.updated_at = datetime.now(tz=timezone.utc)
+        self._repo.update(item)
+        return item

redock/application/clean_dns.py

@@ -0,0 +1,10 @@
+from redock.application.commands import CleanDnsCommand
+from redock.domain.ports import DnsProvider
+
+
+class CleanDnsUseCase:
+    def __init__(self, provider: DnsProvider) -> None:
+        self._provider = provider
+
+    def execute(self, cmd: CleanDnsCommand) -> None:
+        self._provider.delete_records(cmd.subdomain)

redock/application/commands.py

@@ -0,0 +1,60 @@
+from dataclasses import dataclass, field
+
+from redock.domain.value_objects import IPv4, Slug, Subdomain
+from redock.domain.vps import Vps
+
+
+@dataclass(frozen=True)
+class EnsureVpsCommand:
+    region: str
+    server_type: str
+    ssh_key_name: str
+    label: str = "redock=true"
+
+
+@dataclass(frozen=True)
+class PrepareHostCommand:
+    vps: Vps
+    base_domain: str
+    acme_email: str
+
+
+@dataclass(frozen=True)
+class EnsureDnsCommand:
+    subdomain: Subdomain
+    target_ip: IPv4
+
+
+@dataclass(frozen=True)
+class DeployAppCommand:
+    template_id: str
+    slug: Slug
+    subdomain: Subdomain
+    vps: Vps
+    env: dict[str, str] = field(default_factory=dict)
+    upgrade: bool = False
+
+
+@dataclass(frozen=True)
+class StopAppCommand:
+    slug: Slug
+    purge: bool = False
+
+
+@dataclass(frozen=True)
+class CleanDnsCommand:
+    subdomain: Subdomain
+
+
+@dataclass(frozen=True)
+class UpCommand:
+    template_id: str
+    slug: Slug
+    base_domain: str
+    acme_email: str
+    region: str
+    server_type: str
+    ssh_key_name: str
+    label: str = "redock=true"
+    env: dict[str, str] = field(default_factory=dict)
+    upgrade: bool = False

redock/application/delete_catalog_item.py

@@ -0,0 +1,13 @@
+from redock.application.catalog_commands import DeleteCatalogItemCommand
+from redock.application.exceptions import CatalogItemNotFound
+from redock.domain.ports import CatalogRepository
+
+
+class DeleteCatalogItemUseCase:
+    def __init__(self, repo: CatalogRepository) -> None:
+        self._repo = repo
+
+    def execute(self, cmd: DeleteCatalogItemCommand) -> None:
+        if self._repo.get(cmd.id) is None:
+            raise CatalogItemNotFound(cmd.id)
+        self._repo.delete(cmd.id)

redock/application/deploy_app.py

@@ -0,0 +1,91 @@
+import os
+from datetime import datetime, timezone
+
+from redock.application.commands import DeployAppCommand
+from redock.application.exceptions import DeploymentFailed, MissingPort, UnknownTemplate, UnapprovedTemplate
+from redock.domain.deployment import Deployment, DeploymentStatus
+from redock.domain.ports import CatalogRepository, ContainerRuntime, ContainerSpec, DeploymentRepository, ProxyRouter
+from redock.domain.value_objects import ContainerName, VolumeName
+
+
+def _resolve_env(env: dict[str, str]) -> dict[str, str]:
+    resolved: dict[str, str] = {}
+    for k, v in env.items():
+        if v.startswith("$"):
+            var = v[1:]
+            if var not in os.environ:
+                raise DeploymentFailed(
+                    f"env var ${var} referenced in catalog but not set on this host"
+                )
+            resolved[k] = os.environ[var]
+        else:
+            resolved[k] = v
+    return resolved
+
+
+class DeployAppUseCase:
+    def __init__(
+        self,
+        runtime: ContainerRuntime,
+        router: ProxyRouter,
+        repo: DeploymentRepository,
+        catalog: CatalogRepository,
+    ) -> None:
+        self._runtime = runtime
+        self._router = router
+        self._repo = repo
+        self._catalog = catalog
+
+    def execute(self, cmd: DeployAppCommand) -> Deployment:
+        item = self._catalog.get(cmd.template_id)
+        if item is None:
+            raise UnknownTemplate(cmd.template_id)
+        if not item.checked:
+            raise UnapprovedTemplate(cmd.template_id)
+        if item.port is None:
+            raise MissingPort(cmd.template_id)
+
+        existing = self._repo.get(cmd.slug)
+        if existing is not None and existing.status == DeploymentStatus.RUNNING:
+            if self._runtime.is_running(cmd.vps, existing.container_name):
+                if not cmd.upgrade:
+                    return existing
+                self._runtime.stop(cmd.vps, existing.container_name)
+                self._runtime.remove(cmd.vps, existing.container_name, remove_volume=False)
+
+        container_name = ContainerName.for_slug(cmd.slug)
+        volume_name = VolumeName.for_slug(cmd.slug) if item.volume_mount else None
+        labels = self._router.labels_for(cmd.subdomain, item.port)
+
+        spec = ContainerSpec(
+            image=item.image,
+            container_name=str(container_name),
+            volume_name=str(volume_name) if volume_name else None,
+            volume_mount=item.volume_mount,
+            labels=labels,
+            internal_port=item.port,
+            env=_resolve_env({**item.env, **cmd.env}),
+        )
+
+        deployment = Deployment(
+            slug=cmd.slug,
+            template_id=cmd.template_id,
+            subdomain=cmd.subdomain,
+            container_name=container_name,
+            volume_name=volume_name,
+            vps_id=cmd.vps.id,
+            status=DeploymentStatus.PENDING,
+            created_at=datetime.now(tz=timezone.utc),
+        )
+        self._repo.save(deployment)
+
+        try:
+            self._runtime.run(cmd.vps, spec)
+        except Exception as exc:
+            deployment.mark_failed(str(exc))
+            self._repo.save(deployment)
+            raise DeploymentFailed(str(exc)) from exc
+
+        deployment.mark_running()
+        self._repo.save(deployment)
+        return deployment

redock/application/enrich_catalog_item.py

@@ -0,0 +1,28 @@
+from redock.application.catalog_commands import EnrichCatalogItemCommand
+from redock.domain.catalog_suggestion import CatalogSuggestion
+from redock.domain.ports import ImageDetailsFetcher, MetadataEnricher
+
+
+class EnrichCatalogItemUseCase:
+    def __init__(self, fetcher: ImageDetailsFetcher, enricher: MetadataEnricher) -> None:
+        self._fetcher = fetcher
+        self._enricher = enricher
+
+    def execute(self, cmd: EnrichCatalogItemCommand) -> CatalogSuggestion:
+        details = self._fetcher.fetch(cmd.image)
+        readme = details.full_description if details else ""
+        ai = self._enricher.enrich(cmd.image, readme)
+        registry_user = details.user if details else None
+        registry_user_id = details.user_id if details else None
+        # If the registry gave a named user but no numeric uid, the AI cannot
+        # know the uid either — suppress its guess rather than store a wrong value.
+        ai_user_id = ai.user_id if registry_user is None else None
+        return CatalogSuggestion(
+            port=ai.port,
+            volume_mount=ai.volume_mount,
+            entrypoint=ai.entrypoint,
+            user=registry_user if registry_user is not None else ai.user,
+            user_id=registry_user_id if registry_user_id is not None else ai_user_id,
+            hub_link=details.hub_link if details else None,
+            project_link=ai.project_link,
+        )

redock/application/ensure_dns.py

@@ -0,0 +1,17 @@
+from redock.application.commands import EnsureDnsCommand
+from redock.application.exceptions import ApplicationError
+from redock.domain.ports import DnsProvider
+
+
+class EnsureDnsUseCase:
+    def __init__(self, dns_provider: DnsProvider) -> None:
+        self._dns_provider = dns_provider
+
+    def execute(self, cmd: EnsureDnsCommand) -> None:
+        records = self._dns_provider.required_records(cmd.subdomain, cmd.target_ip)
+        try:
+            self._dns_provider.ensure(records)
+        except ApplicationError:
+            raise
+        except Exception as exc:
+            raise ApplicationError(f"DNS setup failed: {exc}") from exc

redock/application/ensure_vps.py

@@ -0,0 +1,26 @@
+from redock.application.commands import EnsureVpsCommand
+from redock.application.exceptions import VpsCreationFailed
+from redock.domain.ports import VpsProvisioner
+from redock.domain.vps import Vps
+
+
+class EnsureVpsUseCase:
+    def __init__(self, provisioner: VpsProvisioner) -> None:
+        self._provisioner = provisioner
+
+    def execute(self, cmd: EnsureVpsCommand) -> Vps:
+        existing = self._provisioner.find_existing(cmd.label)
+        if existing is not None:
+            return existing
+
+        try:
+            vps = self._provisioner.create(
+                region=cmd.region,
+                server_type=cmd.server_type,
+                ssh_key_name=cmd.ssh_key_name,
+                label=cmd.label,
+            )
+            self._provisioner.wait_until_ssh_ready(vps)
+            return vps
+        except Exception as exc:
+            raise VpsCreationFailed(str(exc)) from exc

redock/application/exceptions.py

@@ -0,0 +1,78 @@
+class ApplicationError(Exception):
+    """Base for all application-layer errors."""
+
+
+class VpsCreationFailed(ApplicationError):
+    pass
+
+
+class HostPreparationFailed(ApplicationError):
+    pass
+
+
+class DnsTimeout(ApplicationError):
+    def __init__(self, hostname: str) -> None:
+        super().__init__(f"DNS did not resolve for {hostname!r} within the timeout")
+        self.hostname = hostname
+
+
+class DeploymentFailed(ApplicationError):
+    pass
+
+
+class UnknownTemplate(ApplicationError):
+    def __init__(self, template_id: str) -> None:
+        super().__init__(f"Unknown template: {template_id!r}. Check `redock catalog`.")
+        self.template_id = template_id
+
+
+class AlreadyDeployed(ApplicationError):
+    def __init__(self, slug: str) -> None:
+        super().__init__(f"Deployment {slug!r} is already running.")
+        self.slug = slug
+
+
+class HttpsTimeout(ApplicationError):
+    def __init__(self, url: str) -> None:
+        super().__init__(f"HTTPS endpoint {url!r} did not become available within the timeout")
+        self.url = url
+
+
+class CatalogItemNotFound(ApplicationError):
+    def __init__(self, item_id: str) -> None:
+        super().__init__(f"Catalog item {item_id!r} not found.")
+        self.item_id = item_id
+
+
+class CatalogItemAlreadyExists(ApplicationError):
+    def __init__(self, item_id: str) -> None:
+        super().__init__(
+            f"Catalog item {item_id!r} already exists. Use `redock catalog update` to modify it."
+        )
+        self.item_id = item_id
+
+
+class UnapprovedTemplate(ApplicationError):
+    def __init__(self, item_id: str) -> None:
+        super().__init__(f"{item_id!r} is not checked. Run: redock catalog check {item_id}")
+        self.item_id = item_id
+
+
+class MissingPort(ApplicationError):
+    def __init__(self, item_id: str) -> None:
+        super().__init__(
+            f"{item_id!r} has no port set. Run: redock catalog update {item_id} --port 80"
+        )
+        self.item_id = item_id
+
+
+class EnrichmentError(ApplicationError):
+    pass
+
+
+class ScannerNotAvailableError(ApplicationError):
+    pass
+
+
+class ScanError(ApplicationError):
+    pass

redock/application/get_catalog_item.py

@@ -0,0 +1,15 @@
+from redock.application.catalog_commands import GetCatalogItemCommand
+from redock.application.exceptions import CatalogItemNotFound
+from redock.domain.catalog_item import CatalogItem
+from redock.domain.ports import CatalogRepository
+
+
+class GetCatalogItemUseCase:
+    def __init__(self, repo: CatalogRepository) -> None:
+        self._repo = repo
+
+    def execute(self, cmd: GetCatalogItemCommand) -> CatalogItem:
+        item = self._repo.get(cmd.id)
+        if item is None:
+            raise CatalogItemNotFound(cmd.id)
+        return item

redock/application/list_apps.py

@@ -0,0 +1,10 @@
+from redock.domain.deployment import Deployment
+from redock.domain.ports import DeploymentRepository
+
+
+class ListAppsUseCase:
+    def __init__(self, repo: DeploymentRepository) -> None:
+        self._repo = repo
+
+    def execute(self) -> list[Deployment]:
+        return self._repo.list_all()

redock/application/list_catalog_items.py

@@ -0,0 +1,14 @@
+from redock.application.catalog_commands import ListCatalogItemsCommand
+from redock.domain.catalog_item import CatalogItem
+from redock.domain.ports import CatalogRepository
+
+
+class ListCatalogItemsUseCase:
+    def __init__(self, repo: CatalogRepository) -> None:
+        self._repo = repo
+
+    def execute(self, cmd: ListCatalogItemsCommand) -> list[CatalogItem]:
+        items = self._repo.list_all()
+        if cmd.checked_only:
+            items = [i for i in items if i.checked]
+        return items

redock/application/prepare_host.py

@@ -0,0 +1,21 @@
+from redock.application.commands import PrepareHostCommand
+from redock.application.exceptions import HostPreparationFailed
+from redock.domain.ports import HostPreparer
+
+
+class PrepareHostUseCase:
+    def __init__(self, preparer: HostPreparer) -> None:
+        self._preparer = preparer
+
+    def execute(self, cmd: PrepareHostCommand) -> None:
+        try:
+            if self._preparer.is_prepared(cmd.vps):
+                return
+            self._preparer.prepare(cmd.vps, cmd.base_domain, cmd.acme_email)
+        except FileNotFoundError as exc:
+            raise HostPreparationFailed(
+                f"SSH key file not found: {exc.filename!r} — "
+                "set REDOCK_SSH_KEY_PATH to your private key path"
+            ) from exc
+        except Exception as exc:
+            raise HostPreparationFailed(str(exc)) from exc

redock/application/scan_catalog_item.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+from datetime import datetime, timezone
+
+from redock.application.catalog_commands import ScanCatalogItemCommand
+from redock.application.exceptions import CatalogItemNotFound, ScannerNotAvailableError
+from redock.domain.ports import CatalogRepository, ImageScanner
+from redock.domain.scan_result import ScanSummary, Vulnerability
+from redock.domain.vuln_scorer import VulnScorer
+
+
+class ScanCatalogItemUseCase:
+    def __init__(
+        self,
+        repo: CatalogRepository,
+        scanners: list[ImageScanner],
+        scorer: VulnScorer,
+    ) -> None:
+        self._repo = repo
+        self._scanners = scanners
+        self._scorer = scorer
+
+    def execute(self, cmd: ScanCatalogItemCommand) -> ScanSummary:
+        item = self._repo.get(cmd.id)
+        if item is None:
+            raise CatalogItemNotFound(cmd.id)
+
+        reports = []
+        errors: list[Exception] = []
+        for scanner in self._scanners:
+            try:
+                reports.append(scanner.scan(item.image))
+            except ScannerNotAvailableError as e:
+                errors.append(e)
+
+        if not reports:
+            raise ScannerNotAvailableError(
+                f"No scanners available. Errors: {'; '.join(str(e) for e in errors)}"
+            )
+
+        summary = self._scorer.score(reports)
+
+        if not cmd.dry_run:
+            item.score = summary.score
+            item.scan_result = _to_dict(summary)
+            item.updated_at = datetime.now(tz=timezone.utc)
+            self._repo.update(item)
+
+        return summary
+
+
+def _to_dict(summary: ScanSummary) -> dict:
+    def _counts(vulns: list[Vulnerability]) -> dict:
+        c: dict[str, int] = {"critical": 0, "high": 0, "medium": 0, "low": 0}
+        for v in vulns:
+            key = v.severity.lower() if v.severity.lower() in c else "low"
+            c[key] += 1
+        return c
+
+    return {
+        "scanned_at": datetime.now(tz=timezone.utc).isoformat(),
+        "scanners": {
+            r.scanner: {
+                "vuln_count": len(r.vulnerabilities),
+                **_counts(r.vulnerabilities),
+                "score": summary.per_scanner_scores[r.scanner],
+            }
+            for r in summary.reports
+        },
+        "merged": {
+            "vuln_count": len(summary.merged),
+            **_counts(summary.merged),
+        },
+        "score": summary.score,
+    }

redock/application/search_docker_hub.py

@@ -0,0 +1,11 @@
+from redock.application.catalog_commands import SearchDockerHubCommand
+from redock.domain.docker_hub import DockerHubResult
+from redock.domain.ports import DockerHubSearch
+
+
+class SearchDockerHubUseCase:
+    def __init__(self, hub: DockerHubSearch) -> None:
+        self._hub = hub
+
+    def execute(self, cmd: SearchDockerHubCommand) -> list[DockerHubResult]:
+        return self._hub.search(cmd.query, cmd.page_size)

redock/application/stop_app.py

@@ -0,0 +1,30 @@
+from redock.application.commands import StopAppCommand
+from redock.application.exceptions import ApplicationError
+from redock.domain.ports import ContainerRuntime, DeploymentRepository
+from redock.domain.vps import Vps
+
+
+class StopAppUseCase:
+    def __init__(self, runtime: ContainerRuntime, repo: DeploymentRepository) -> None:
+        self._runtime = runtime
+        self._repo = repo
+
+    def execute(self, cmd: StopAppCommand, vps: Vps) -> None:
+        deployment = self._repo.get(cmd.slug)
+        if deployment is None:
+            raise ApplicationError(f"No deployment found for slug {cmd.slug!r}")
+
+        try:
+            if self._runtime.is_running(vps, deployment.container_name):
+                self._runtime.stop(vps, deployment.container_name)
+
+            if cmd.purge:
+                self._runtime.remove(vps, deployment.container_name, remove_volume=True)
+                self._repo.delete(cmd.slug)
+            else:
+                deployment.mark_stopped()
+                self._repo.save(deployment)
+        except ApplicationError:
+            raise
+        except Exception as exc:
+            raise ApplicationError(f"Failed to stop deployment {cmd.slug!r}: {exc}") from exc