cloud-dock-cli 0.1.0__py3-none-any.whl

clouddock/cli.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+import typer
+
+from .prompts import collect_configuration, render_summary
+
+TERRAFORM_REPO_URL = "https://github.com/DGclasher/cloud-dock"
+CLOUDDOCK_HOME = Path.home() / ".clouddock"
+TERRAFORM_DIRECTORY = CLOUDDOCK_HOME / "terraform"
+
+
+class CloudDockPlanError(RuntimeError):
+    """Raised when plan orchestration fails."""
+
+
+def check_prerequisites() -> dict[str, dict[str, bool | str | None]]:
+    status: dict[str, dict[str, bool | str | None]] = {
+        "git": {"installed": False, "version": None},
+        "terraform": {"installed": False, "version": None},
+        "aws": {"installed": False, "configured": False, "version": None},
+    }
+
+    git_path = shutil.which("git")
+    if git_path:
+        status["git"]["installed"] = True
+        result = subprocess.run(
+            ["git", "--version"],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            status["git"]["version"] = result.stdout.strip()
+
+    terraform_path = shutil.which("terraform")
+    if terraform_path:
+        status["terraform"]["installed"] = True
+        result = subprocess.run(
+            ["terraform", "version"],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            first_line = result.stdout.strip().splitlines(
+            )[0] if result.stdout.strip() else "Terraform"
+            status["terraform"]["version"] = first_line
+
+    aws_path = shutil.which("aws")
+    if aws_path:
+        status["aws"]["installed"] = True
+        result = subprocess.run(
+            ["aws", "sts", "get-caller-identity"],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        status["aws"]["configured"] = result.returncode == 0
+
+    return status
+
+
+def ensure_config_or_init(
+    config_path: Path,
+    *,
+    prompt_func=None,
+    init_runner=None,
+) -> Path:
+    if config_path.exists():
+        return config_path
+
+    if prompt_func is None:
+        prompt_func = lambda *_args, **_kwargs: typer.confirm(
+            "Would you like to run `clouddock init` now? [Y/n]",
+            default=False,
+        )
+    if init_runner is None:
+        init_runner = init
+
+    typer.echo("CloudDock configuration not found.")
+    typer.echo("")
+    if not prompt_func("Would you like to run `clouddock init` now? [Y/n]", default=False):
+        raise CloudDockPlanError(
+            "CloudDock configuration not found.\nRun `clouddock init` to create clouddock.yaml."
+        )
+
+    typer.echo("Running CloudDock init...")
+    init_runner()
+    if not config_path.exists():
+        raise CloudDockPlanError(
+            "CloudDock init did not produce a valid clouddock.yaml configuration."
+        )
+    return config_path
+
+
+def ensure_terraform_repo(terraform_dir: Path) -> Path:
+    if terraform_dir.exists() and (terraform_dir / ".git").exists():
+        return terraform_dir
+
+    terraform_dir.parent.mkdir(parents=True, exist_ok=True)
+    if terraform_dir.exists() and not (terraform_dir / ".git").exists():
+        raise CloudDockPlanError(
+            f"Terraform directory exists but is not a valid Git checkout: {terraform_dir}"
+        )
+
+    result = subprocess.run(
+        ["git", "clone", TERRAFORM_REPO_URL, str(terraform_dir)],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise CloudDockPlanError(
+            f"Failed to clone Terraform repository: {TERRAFORM_REPO_URL}"
+        )
+    return terraform_dir
+
+
+def copy_clouddock_config(source_path: Path, terraform_dir: Path) -> Path:
+    terraform_dir.mkdir(parents=True, exist_ok=True)
+    destination = terraform_dir / source_path.name
+    shutil.copy2(source_path, destination)
+    return destination
+
+
+def run_terraform_command(args: list[str], working_directory: Path) -> subprocess.CompletedProcess[str]:
+    result = subprocess.run(args, cwd=str(
+        working_directory), check=False, text=True)
+    if result.stdout:
+        typer.echo(result.stdout, nl=False)
+    if result.stderr:
+        typer.echo(result.stderr, err=True, nl=False)
+    if result.returncode != 0:
+        command_name = " ".join(args)
+        combined_output = "\n".join(
+            chunk for chunk in [result.stdout.strip(), result.stderr.strip()] if chunk
+        )
+        lock_match = re.search(r"ID:\s*([A-Za-z0-9-]+)", combined_output)
+        lock_id = lock_match.group(1) if lock_match else "<lock-id>"
+        if "Error acquiring the state lock" in combined_output or "state lock" in combined_output.lower():
+            raise CloudDockPlanError(
+                f"{command_name} failed because Terraform state is locked. "
+                f"Stop the active Terraform process or run `terraform force-unlock -force {lock_id}` in "
+                f"{working_directory} to clear the stale lock."
+            )
+        raise CloudDockPlanError(
+            f"{command_name} failed in {working_directory}.")
+    return result
+
+
+app = typer.Typer(help="CloudDock configuration generator")
+
+
+@app.callback()
+def callback() -> None:
+    """CloudDock CLI."""
+
+
+@app.command()
+def init() -> None:
+    """Interactively collect deployment requirements and generate a CloudDock configuration."""
+    config = collect_configuration()
+    typer.echo(render_summary(config))
+
+    save = typer.confirm("Save configuration?",
+                         default=True, show_default=True)
+    if not save:
+        typer.echo("Configuration not saved.")
+        raise typer.Exit()
+
+    output_path = Path("clouddock.yaml")
+    if output_path.exists():
+        replace = typer.confirm(
+            "Configuration file already exists. Replace it?", default=False
+        )
+        if not replace:
+            typer.echo("Configuration not saved.")
+            raise typer.Exit()
+        output_path.unlink()
+
+    config.save_yaml(output_path)
+    typer.echo(f"Configuration saved to {output_path}")
+
+
+@app.command()
+def plan() -> None:
+    """Check prerequisites, prepare the Terraform repo, and run terraform plan."""
+    typer.echo("CloudDock deployment planner")
+    typer.echo("")
+    typer.echo("Checking prerequisites...")
+
+    status = check_prerequisites()
+    missing = []
+    labels = {
+        "git": "Git",
+        "terraform": "Terraform",
+        "aws": "AWS CLI",
+    }
+
+    for name in ("git", "terraform", "aws"):
+        info = status[name]
+        if not info.get("installed"):
+            missing.append(name)
+            typer.echo(f"✗ {labels[name]} not found")
+            continue
+
+        version = info.get("version")
+        if version:
+            typer.echo(f"✓ {labels[name]} {version}")
+        else:
+            typer.echo(f"✓ {labels[name]}")
+
+        if name == "aws" and not info.get("configured"):
+            typer.echo(
+                "✗ AWS CLI credentials/configuration could not be verified.")
+            typer.echo("Please configure AWS credentials and try again.")
+            missing.append("aws_config")
+
+    if missing:
+        raise typer.Exit(code=1)
+
+    typer.echo("")
+    typer.echo("Checking configuration...")
+    config_path = ensure_config_or_init(Path("clouddock.yaml"))
+    typer.echo(f"✓ clouddock.yaml found at {config_path}")
+
+    typer.echo("")
+    typer.echo("Preparing Terraform configuration...")
+    ensure_terraform_repo(TERRAFORM_DIRECTORY)
+    typer.echo(f"✓ Terraform repository ready: {TERRAFORM_DIRECTORY}")
+    copied_path = copy_clouddock_config(config_path, TERRAFORM_DIRECTORY)
+    typer.echo(f"✓ clouddock.yaml copied to {copied_path}")
+
+    typer.echo("")
+    typer.echo("Initializing Terraform...")
+    try:
+        run_terraform_command(["terraform", "init"], TERRAFORM_DIRECTORY)
+    except CloudDockPlanError as exc:
+        typer.echo("Terraform initialization failed.")
+        typer.echo("")
+        typer.echo("CloudDock stopped before running `terraform plan`.")
+        raise typer.Exit(code=1) from exc
+
+    typer.echo("")
+    typer.echo("Running Terraform plan...")
+    try:
+        run_terraform_command(["terraform", "plan"], TERRAFORM_DIRECTORY)
+    except CloudDockPlanError as exc:
+        typer.echo("Terraform plan failed.")
+        typer.echo("")
+        typer.echo(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    typer.echo("")
+    typer.echo("Terraform plan completed.")
+
+
+@app.command()
+def deploy() -> None:
+    """Placeholder for future deployment support."""
+    typer.echo("CloudDock deploy is not implemented yet.")
+
+
+if __name__ == "__main__":
+    app()

clouddock/config.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+APP_NAME_PATTERN = r"^[A-Za-z0-9][A-Za-z0-9._-]*$"
+VALID_DATABASE_TYPES = {"postgres": "postgres", "mysql": "mysql"}
+VALID_CACHE_TYPES = {"redis": "redis", "memcached": "memcached"}
+
+
+def validate_application_name(value: str) -> str:
+    cleaned = value.strip()
+    if not cleaned:
+        raise ValueError("Application name is required.")
+    if len(cleaned) > 63:
+        raise ValueError("Application name must be 63 characters or fewer.")
+    if not cleaned.replace("-", "").replace("_", "").replace(".", "").isalnum():
+        raise ValueError(
+            "Application name may only contain letters, numbers, dots, underscores, and hyphens."
+        )
+    if not cleaned[0].isalnum():
+        raise ValueError(
+            "Application name must start with a letter or number.")
+    return cleaned
+
+
+def validate_image(value: str) -> str:
+    cleaned = value.strip()
+    if not cleaned:
+        raise ValueError("Docker image is required.")
+    return cleaned
+
+
+def validate_container_port(value: int | str) -> int:
+    try:
+        port = int(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError("Container port must be a valid integer.") from exc
+
+    if not 1 <= port <= 65535:
+        raise ValueError("Container port must be between 1 and 65535.")
+    return port
+
+
+def validate_regions(value: list[str]) -> list[str]:
+    regions = [region.strip() for region in value]
+    if not regions or not any(region for region in regions):
+        raise ValueError("At least one AWS region is required.")
+    cleaned = [region for region in regions if region]
+    if not cleaned:
+        raise ValueError("At least one AWS region is required.")
+    return cleaned
+
+
+def validate_desired_count(value: int | str) -> int:
+    try:
+        count = int(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            "Desired instance count must be a valid integer.") from exc
+
+    if count < 1:
+        raise ValueError("Desired instance count must be at least 1.")
+    return count
+
+
+def validate_positive_int(value: int | str, field_name: str) -> int:
+    try:
+        number = int(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"{field_name} must be a valid integer.") from exc
+
+    if number <= 0:
+        raise ValueError(f"{field_name} must be greater than 0.")
+    return number
+
+
+def normalize_database_type(value: str) -> str:
+    normalized = value.strip().lower()
+    if normalized not in VALID_DATABASE_TYPES:
+        raise ValueError("Database type must be one of: PostgreSQL, MySQL.")
+    return VALID_DATABASE_TYPES[normalized]
+
+
+def normalize_cache_type(value: str) -> str:
+    normalized = value.strip().lower()
+    if normalized not in VALID_CACHE_TYPES:
+        raise ValueError("Cache type must be one of: Redis, Memcached.")
+    return VALID_CACHE_TYPES[normalized]
+
+
+@dataclass
+class DatabaseConfig:
+    enabled: bool = False
+    type: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.enabled and not self.type:
+            raise ValueError(
+                "Database type is required when database is enabled.")
+        if self.type is not None:
+            self.type = normalize_database_type(self.type)
+
+    def to_dict(self) -> dict[str, Any]:
+        if not self.enabled:
+            return {"enabled": False}
+        return {"enabled": True, "type": self.type}
+
+
+@dataclass
+class CacheConfig:
+    enabled: bool = False
+    type: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.enabled and not self.type:
+            raise ValueError("Cache type is required when caching is enabled.")
+        if self.type is not None:
+            self.type = normalize_cache_type(self.type)
+
+    def to_dict(self) -> dict[str, Any]:
+        if not self.enabled:
+            return {"enabled": False}
+        return {"enabled": True, "type": self.type}
+
+
+@dataclass
+class ComputeConfig:
+    type: str
+    desired_count: int = 1
+    cpu: int = 256
+    memory: int = 512
+
+    def __post_init__(self) -> None:
+        self.type = self.type.strip().lower()
+        if self.type not in {"ecs"}:
+            raise ValueError("Compute type must be 'ecs'.")
+        self.desired_count = validate_desired_count(self.desired_count)
+        self.cpu = validate_positive_int(self.cpu, "CPU")
+        self.memory = validate_positive_int(self.memory, "Memory")
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "type": self.type,
+            "desired_count": self.desired_count,
+            "cpu": self.cpu,
+            "memory": self.memory,
+        }
+
+
+@dataclass
+class EnvironmentVariables:
+    values: dict[str, str] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        cleaned: dict[str, str] = {}
+        for key, value in self.values.items():
+            final_key = str(key).strip()
+            if not final_key:
+                raise ValueError("Environment variable keys cannot be empty.")
+            cleaned[final_key] = str(value)
+        self.values = cleaned
+
+    def as_dict(self) -> dict[str, str]:
+        return dict(self.values)
+
+    def to_dict(self) -> dict[str, str]:
+        return self.as_dict()
+
+
+@dataclass
+class CloudDockConfig:
+    application_name: str
+    image: str
+    container_port: int
+    regions: list[str]
+    compute: ComputeConfig
+    database: DatabaseConfig | None = None
+    cache: CacheConfig | None = None
+    environment_variables: EnvironmentVariables | None = None
+
+    def __post_init__(self) -> None:
+        self.application_name = validate_application_name(
+            self.application_name)
+        self.image = validate_image(self.image)
+        self.container_port = validate_container_port(self.container_port)
+        self.regions = validate_regions(self.regions)
+        if self.database is None:
+            self.database = DatabaseConfig(enabled=False)
+        if self.cache is None:
+            self.cache = CacheConfig(enabled=False)
+        if self.environment_variables is None:
+            self.environment_variables = EnvironmentVariables({})
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "application": {
+                "name": self.application_name,
+                "image": self.image,
+                "container_port": self.container_port,
+            },
+            "regions": self.regions,
+            "compute": self.compute.to_dict(),
+            "database": self.database.to_dict(),
+            "cache": self.cache.to_dict(),
+            "environment_variables": self.environment_variables.to_dict(),
+        }
+
+    def save_yaml(self, path: str | Path) -> Path:
+        target = Path(path)
+        if target.exists():
+            raise FileExistsError(
+                f"Configuration file already exists: {target}")
+
+        document = self.to_dict()
+        target.write_text(yaml.safe_dump(
+            document, sort_keys=False), encoding="utf-8")
+        return target