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

clouddock/prompts.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from .config import (
+    CacheConfig,
+    CloudDockConfig,
+    ComputeConfig,
+    DatabaseConfig,
+    EnvironmentVariables,
+    validate_application_name,
+    validate_container_port,
+    validate_desired_count,
+    validate_image,
+    validate_positive_int,
+    validate_regions,
+)
+
+
+def prompt(
+    message: str,
+    default: str | None = None,
+    *,
+    validate: Callable[[str], str] | None = None,
+) -> str:
+    suffix = f" [{default}]" if default is not None else ""
+    while True:
+        value = input(f"{message}{suffix}: ")
+        if value == "" and default is not None:
+            return default
+        if value == "":
+            if validate is None:
+                return ""
+            try:
+                validate(value)
+            except ValueError as exc:
+                print(f"Error: {exc}")
+                continue
+            return value
+        if validate is not None:
+            try:
+                value = validate(value)
+                return value
+            except ValueError as exc:
+                print(f"Error: {exc}")
+                continue
+        return value
+
+
+def prompt_yes_no(prompt_text: str) -> bool:
+    while True:
+        answer = input(f"{prompt_text} [Y/n]: ").strip().lower()
+        if answer in {"", "y", "yes"}:
+            return True
+        if answer in {"n", "no"}:
+            return False
+        print("Please answer yes or no.")
+
+
+def prompt_regions() -> list[str]:
+    regions: list[str] = []
+    print("AWS regions:")
+    while True:
+        region = input("> ").strip()
+        if not region:
+            if regions:
+                break
+            print("Error: At least one region is required.")
+            continue
+        try:
+            regions.append(validate_regions([region])[0])
+        except ValueError as exc:
+            print(f"Error: {exc}")
+            continue
+        print(f"Added region: {region}")
+    return validate_regions(regions)
+
+
+def prompt_compute_type() -> str:
+    while True:
+        print("Where do you want to run the application?")
+        print("> ECS Fargate")
+        print("> EKS")
+        choice = input("Choice: ").strip().lower()
+        if choice in {"ecs", "fargate", "ecs fargate"}:
+            return "ecs"
+        if choice in {"eks", "e k s"}:
+            return "eks"
+        print("Please choose ECS Fargate or EKS.")
+
+
+def prompt_environment_variables() -> dict[str, str]:
+    values: dict[str, str] = {}
+    print("Environment variables")
+    print("Press Enter without a key to finish.")
+    while True:
+        key = input("Key: ").strip()
+        if not key:
+            break
+        value = input("Value: ").strip()
+        if not value:
+            value = ""
+        if not key:
+            raise ValueError("Environment variable keys cannot be empty.")
+        values[key] = value
+    return values
+
+
+def collect_configuration() -> CloudDockConfig:
+    name = prompt("Application name:", validate=validate_application_name)
+    image = prompt("Docker image:", validate=validate_image)
+    port_input = prompt(
+        "Container port:",
+        default="8080",
+        validate=lambda value: str(validate_container_port(value)),
+    )
+    port = validate_container_port(port_input)
+
+    regions = prompt_regions()
+
+    compute_type = prompt_compute_type()
+    desired_count = prompt(
+        "Number of application instances:",
+        default="2",
+        validate=lambda value: str(validate_desired_count(value)),
+    )
+    cpu = prompt(
+        "CPU:",
+        default="256",
+        validate=lambda value: str(validate_positive_int(value, "CPU")),
+    )
+    memory = prompt(
+        "Memory (MB):",
+        default="512",
+        validate=lambda value: str(validate_positive_int(value, "Memory")),
+    )
+
+    database_enabled = prompt_yes_no("Do you need a database?")
+    database_type = None
+    if database_enabled:
+        while True:
+            db_choice = input(
+                "Database type [PostgreSQL/MySQL]: ").strip().lower()
+            if db_choice in {"postgres", "postgresql"}:
+                database_type = "postgres"
+                break
+            if db_choice in {"mysql"}:
+                database_type = "mysql"
+                break
+            print("Please choose PostgreSQL or MySQL.")
+
+    cache_enabled = prompt_yes_no("Do you need caching?")
+    cache_type = None
+    if cache_enabled:
+        while True:
+            cache_choice = input(
+                "Cache type [Redis/Memcached]: ").strip().lower()
+            if cache_choice in {"redis"}:
+                cache_type = "redis"
+                break
+            if cache_choice in {"memcached"}:
+                cache_type = "memcached"
+                break
+            print("Please choose Redis or Memcached.")
+
+    environment_variables = prompt_environment_variables()
+
+    return CloudDockConfig(
+        application_name=name,
+        image=image,
+        container_port=port,
+        regions=regions,
+        compute=ComputeConfig(
+            type=compute_type,
+            desired_count=int(desired_count),
+            cpu=int(cpu),
+            memory=int(memory),
+        ),
+        database=DatabaseConfig(enabled=database_enabled, type=database_type),
+        cache=CacheConfig(enabled=cache_enabled, type=cache_type),
+        environment_variables=EnvironmentVariables(environment_variables),
+    )
+
+
+def display_name_for_compute(compute_type: str) -> str:
+    return "ECS Fargate" if compute_type == "ecs" else "EKS"
+
+
+def display_name_for_database(database_type: str | None) -> str:
+    if database_type == "postgres":
+        return "PostgreSQL"
+    if database_type == "mysql":
+        return "MySQL"
+    return "Disabled"
+
+
+def display_name_for_cache(cache_type: str | None) -> str:
+    if cache_type == "redis":
+        return "Redis"
+    if cache_type == "memcached":
+        return "Memcached"
+    return "Disabled"
+
+
+def render_summary(config: CloudDockConfig) -> str:
+    lines = [
+        "CloudDock configuration",
+        "",
+        f"Application: {config.application_name}",
+        f"Image: {config.image}",
+        f"Port: {config.container_port}",
+        "",
+        "Regions:",
+    ]
+    for region in config.regions:
+        lines.append(f"  - {region}")
+
+    lines.extend(
+        [
+            "",
+            "Compute:",
+            f"  {display_name_for_compute(config.compute.type)}",
+            f"  Instances: {config.compute.desired_count}",
+            f"  CPU: {config.compute.cpu}",
+            f"  Memory: {config.compute.memory} MB",
+            "",
+            "Database:",
+            f"  {display_name_for_database(config.database.type) if config.database and config.database.enabled else 'Disabled'}",
+            "",
+            "Cache:",
+            f"  {display_name_for_cache(config.cache.type) if config.cache and config.cache.enabled else 'Disabled'}",
+            "",
+            "Environment variables:",
+            f"  {len(config.environment_variables.values)} configured",
+        ]
+    )
+    return "\n".join(lines)