localargo 0.1.0__py3-none-any.whl

localargo/cli/commands/sync.py

@@ -0,0 +1,291 @@
+# SPDX-FileCopyrightText: 2025-present William Born <william.born.git@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+"""Sync ArgoCD applications and local directories.
+
+This module provides commands for syncing ArgoCD applications with local directories
+and watching for changes to automatically sync.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+try:
+    from watchdog.events import FileSystemEventHandler
+    from watchdog.observers import Observer
+except ImportError:
+    FileSystemEventHandler = None
+    Observer = None
+
+import click
+
+from localargo.core.argocd import ArgoClient
+from localargo.logging import logger
+from localargo.utils.cli import run_subprocess
+
+if TYPE_CHECKING:
+    from watchdog.events import FileSystemEvent
+
+# Constants
+SYNC_DEBOUNCE_SECONDS = 2
+
+
+@click.command()
+@click.option("--watch", "-w", is_flag=True, help="Watch for changes and auto-sync")
+@click.option("--path", "-p", help="Local path to watch (for directory sync)")
+@click.option("--app", "-a", help="Specific ArgoCD application to sync")
+@click.option("--sync-all", is_flag=True, help="Sync all applications")
+@click.option("--force", "-f", is_flag=True, help="Force sync even if no changes")
+def sync_cmd(
+    *, watch: bool, path: str | None, app: str | None, sync_all: bool, force: bool
+) -> None:
+    """Sync ArgoCD applications or local directories."""
+    if not _validate_sync_arguments(path, app, watch=watch, sync_all=sync_all):
+        return
+
+    sync_mode = _determine_sync_mode(path, app, watch=watch, sync_all=sync_all)
+    _execute_sync_mode(sync_mode, path, app, force=force)
+
+
+def _validate_sync_arguments(
+    path: str | None, app: str | None, *, watch: bool, sync_all: bool
+) -> bool:
+    """Validate sync command arguments."""
+    if watch and not path and not app:
+        logger.error("❌ --watch requires --path or --app")
+        return False
+
+    if sync_all and app:
+        logger.error("❌ Cannot specify both --sync-all and --app")
+        return False
+
+    return True
+
+
+def _determine_sync_mode(
+    path: str | None, app: str | None, *, watch: bool, sync_all: bool
+) -> str:
+    """Determine which sync mode to use based on arguments."""
+    if watch:
+        return "watch"
+    if sync_all:
+        return "sync_all"
+    if app:
+        return "sync_app"
+    if path:
+        return "sync_path"
+    return "error"
+
+
+def _execute_sync_mode(
+    sync_mode: str,
+    path: str | None,
+    app: str | None,
+    *,
+    force: bool,
+) -> None:
+    """Execute the appropriate sync mode."""
+    if sync_mode == "watch":
+        _sync_watch(path, app)
+    elif sync_mode == "sync_all":
+        _sync_all_applications(force=force)
+    elif sync_mode == "sync_app":
+        _sync_application(app, force=force)  # type: ignore[arg-type]
+    elif sync_mode == "sync_path":
+        _sync_directory(path)  # type: ignore[arg-type]
+    else:
+        logger.error("❌ Specify what to sync: --app, --sync-all, or --path")
+
+
+def _get_application_list() -> list[str]:
+    """Get list of all ArgoCD applications."""
+    # Ensure we're authenticated before invoking argocd
+    ArgoClient()  # constructor auto-logins if needed
+    try:
+        result = run_subprocess(["argocd", "app", "list", "-o", "name"])
+    except subprocess.CalledProcessError as e:
+        logger.info(
+            "❌ Error listing applications: %s. Try 'localargo cluster password' then re-run.",
+            e,
+        )
+        raise
+    names = [app.strip() for app in result.stdout.strip().split("\n") if app.strip()]
+    if not names:
+        logger.info("i No applications found. Use 'localargo app deploy <app>' to create one.")
+    return names
+
+
+def _sync_multiple_applications(apps: list[str], *, force: bool) -> None:
+    """Sync multiple ArgoCD applications."""
+    for app in apps:
+        _sync_single_application_with_error_handling(app, force=force)
+
+
+def _sync_single_application_with_error_handling(app_name: str, *, force: bool) -> None:
+    """Sync a single application with error handling."""
+    try:
+        _sync_single_application(app_name, force=force)
+        logger.info("✅ '%s' synced", app_name)
+    except subprocess.CalledProcessError as e:
+        logger.info("❌ Error syncing '%s': %s", app_name, e)
+
+
+def _sync_single_application(app_name: str, *, force: bool) -> None:
+    """Sync a single ArgoCD application."""
+    logger.info("Syncing '%s'...", app_name)
+    # Ensure authentication prior to syncing
+    ArgoClient()
+    cmd = ["argocd", "app", "sync", app_name]
+    if force:
+        cmd.append("--force")
+    try:
+        subprocess.run(cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        logger.info(
+            "❌ Error syncing '%s': %s. Try re-authenticating (localargo cluster password).",
+            app_name,
+            e,
+        )
+        raise
+
+
+def _sync_application(app_name: str, *, force: bool = False) -> None:
+    """Sync a specific ArgoCD application."""
+    try:
+        logger.info("Syncing application '%s'...", app_name)
+        ArgoClient()
+        cmd = ["argocd", "app", "sync", app_name]
+        if force:
+            cmd.append("--force")
+
+        subprocess.run(cmd, check=True)
+        logger.info("✅ Application '%s' synced successfully", app_name)
+
+    except FileNotFoundError:
+        logger.error("❌ argocd CLI not found")
+    except subprocess.CalledProcessError as e:
+        logger.info("❌ Error syncing application: %s", e)
+
+
+def _sync_all_applications(*, force: bool = False) -> None:
+    """Sync all ArgoCD applications."""
+    try:
+        logger.info("Syncing all applications...")
+        ArgoClient()
+        apps = _get_application_list()
+        if not apps:
+            logger.info("No applications found")
+            return
+
+        logger.info("Found %d applications: %s", len(apps), ", ".join(apps))
+
+        _sync_multiple_applications(apps, force=force)
+        logger.info("✅ All applications sync completed")
+
+    except FileNotFoundError:
+        logger.error("❌ argocd CLI not found")
+    except subprocess.CalledProcessError as e:
+        logger.info(
+            "❌ Error listing applications: %s. Consider re-authenticating via "
+            "'localargo cluster password'",
+            e,
+        )
+
+
+def _sync_directory(path: str) -> None:
+    """Sync a local directory (placeholder for future GitOps integration)."""
+    path_obj = Path(path)
+
+    if not path_obj.exists():
+        logger.info("❌ Path does not exist: %s", path)
+        return
+
+    if not path_obj.is_dir():
+        logger.info("❌ Path is not a directory: %s", path)
+        return
+
+    logger.info("Directory sync for '%s' not yet implemented", path)
+    logger.info("This would integrate with GitOps workflows in the future")
+
+
+def _sync_watch(path: str | None = None, app: str | None = None) -> None:
+    """Watch for changes and auto-sync."""
+    if path:
+        _watch_directory(path)
+    elif app:
+        _watch_application(app)
+
+
+def _watch_directory(path: str) -> None:
+    """Watch a directory for changes and sync."""
+    if FileSystemEventHandler is None or Observer is None:
+        logger.error(
+            "❌ watchdog package required for watching. Install with: pip install watchdog"
+        )
+        return
+
+    path_obj = Path(path)
+    if not path_obj.exists():
+        logger.info("❌ Path does not exist: %s", path)
+        return
+
+    class ChangeHandler(FileSystemEventHandler):
+        """Handler for file system events during directory watching.
+
+        Initializes the change handler with last sync timestamp.
+        """
+
+        def __init__(self) -> None:
+            self.last_sync = 0.0
+
+        @property
+        def is_ready(self) -> bool:
+            """Check if handler is ready for sync operations."""
+            return time.time() - self.last_sync > SYNC_DEBOUNCE_SECONDS
+
+        def on_any_event(self, event: FileSystemEvent) -> None:
+            """Handle file system events."""
+            # Debounce syncs
+            current_time = time.time()
+            if current_time - self.last_sync > SYNC_DEBOUNCE_SECONDS:
+                logger.info("📁 Change detected: %s", event.src_path)
+                # Here you would trigger a sync
+                logger.info("🔄 Auto-sync not yet implemented")
+                self.last_sync = current_time
+
+    logger.info("👀 Watching directory: %s", path)
+    logger.info("Press Ctrl+C to stop watching")
+
+    observer = Observer()
+    observer.schedule(ChangeHandler(), path, recursive=True)
+    observer.start()
+
+    try:
+        observer.join()
+    except KeyboardInterrupt:
+        observer.stop()
+        logger.info("\n✅ Stopped watching")
+
+
+def _watch_application(app_name: str) -> None:
+    """Watch an ArgoCD application for changes."""
+    try:
+        logger.info("👀 Watching application: %s", app_name)
+        logger.info("Press Ctrl+C to stop watching")
+
+        # Use argocd app wait to watch for changes
+        cmd = ["argocd", "app", "wait", app_name, "--watch-only"]
+
+        try:
+            subprocess.run(cmd, check=True)
+        except KeyboardInterrupt:
+            logger.info("\n✅ Stopped watching application '%s'", app_name)
+
+    except FileNotFoundError:
+        logger.error("❌ argocd CLI not found")
+    except subprocess.CalledProcessError as e:
+        logger.info("❌ Error watching application: %s", e)

localargo/cli/commands/template.py

@@ -0,0 +1,288 @@
+# SPDX-FileCopyrightText: 2025-present William Born <william.born.git@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+"""Template management for ArgoCD applications.
+
+This module provides commands for creating ArgoCD applications from templates.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import click
+import yaml
+
+from localargo.logging import logger
+from localargo.utils.cli import check_cli_availability
+
+
+@dataclass
+class TemplateConfig:  # pylint: disable=too-many-instance-attributes
+    """Configuration for application template generation."""
+
+    name: str
+    app_type: str
+    repo: str
+    path: str
+    namespace: str
+    image: str | None
+    port: int
+    env_vars: tuple[str, ...]
+
+
+@click.group()
+def template() -> None:
+    """Create ArgoCD applications from templates."""
+
+
+@template.command()
+@click.argument("name")
+@click.option(
+    "--app-type",
+    "-t",
+    type=click.Choice(["web-app", "api", "worker", "database"]),
+    default="web-app",
+    help="Application type",
+)
+@click.option("--repo", "-r", help="Git repository URL")
+@click.option("--path", "-p", default=".", help="Path within repository")
+@click.option("--namespace", "-n", default="default", help="Target namespace")
+@click.option("--image", "-i", help="Container image")
+@click.option("--port", type=int, default=80, help="Service port")
+@click.option("--env", multiple=True, help="Environment variables (KEY=VALUE)")
+@click.option("--create-app", is_flag=True, help="Create the ArgoCD application immediately")
+def create(  # pylint: disable=too-many-arguments
+    name: str,
+    app_type: str,
+    *,
+    repo: str | None,
+    path: str,
+    namespace: str,
+    image: str | None,
+    port: int,
+    env: tuple[str, ...],
+    create_app: bool,
+) -> None:
+    """Create an application from a template."""
+    if not repo:
+        logger.error("❌ Repository URL required (--repo)")
+        return
+
+    config = _build_template_config(
+        name=name,
+        app_type=app_type,
+        repo=repo,
+        path=path,
+        namespace=namespace,
+        image=image,
+        port=port,
+        env_vars=env,
+    )
+    app_config = _generate_app_template(config)
+
+    _display_generated_config(app_config)
+
+    if create_app:
+        _create_argocd_app(name, app_config)
+    else:
+        logger.info("\nUse --create-app to create the application immediately")
+
+
+@template.command()
+def list_templates() -> None:
+    """List available application templates."""
+    templates = {
+        "web-app": "Web application with service and ingress",
+        "api": "REST API application",
+        "worker": "Background worker/job application",
+        "database": "Database deployment (PostgreSQL, MySQL, etc.)",
+    }
+
+    logger.info("Available templates:")
+    for name, desc in templates.items():
+        logger.info("  %-12s - %s", name, desc)
+
+
+@template.command()
+@click.argument("template_type")
+def show(template_type: str) -> None:
+    """Show template details."""
+    if template_type not in ["web-app", "api", "worker", "database"]:
+        logger.error("❌ Unknown template type: %s", template_type)
+        return
+
+    # Generate example config
+    example_config = _generate_app_template(
+        TemplateConfig(
+            name=f"example-{template_type}",
+            app_type=template_type,
+            repo="https://github.com/example/example-repo",
+            path=".",
+            namespace="default",
+            image=f"example/{template_type}:latest",
+            port=80,
+            env_vars=(),
+        )
+    )
+
+    logger.info("Template: %s", template_type)
+    logger.info("=" * 30)
+    logger.info(yaml.dump(example_config, default_flow_style=False))
+
+
+def _build_template_config(  # pylint: disable=too-many-arguments
+    name: str,
+    app_type: str,
+    *,
+    repo: str,
+    path: str,
+    namespace: str,
+    image: str | None,
+    port: int,
+    env_vars: tuple[str, ...],
+) -> TemplateConfig:
+    """Build a TemplateConfig object from parameters."""
+    return TemplateConfig(
+        name=name,
+        app_type=app_type,
+        repo=repo,
+        path=path,
+        namespace=namespace,
+        image=image,
+        port=port,
+        env_vars=env_vars,
+    )
+
+
+def _display_generated_config(app_config: dict[str, Any]) -> None:
+    """Display the generated application configuration."""
+    logger.info("Generated ArgoCD Application:")
+    logger.info("=" * 50)
+    logger.info(yaml.dump(app_config, default_flow_style=False))
+
+
+def _create_argocd_app(name: str, app_config: dict[str, Any]) -> None:
+    """Create an ArgoCD application from the configuration."""
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+        yaml.dump(app_config, f)
+        temp_file = f.name
+
+    try:
+        argocd_path = check_cli_availability("argocd")
+        if argocd_path is None:
+            msg = "argocd not found in PATH. Please ensure argocd CLI is installed."
+            raise RuntimeError(msg)
+        subprocess.run([argocd_path, "app", "create", name, "--file", temp_file], check=True)
+        logger.info("✅ ArgoCD application '%s' created", name)
+    except FileNotFoundError:
+        logger.error("❌ argocd CLI not found")
+    except subprocess.CalledProcessError as e:
+        logger.info("❌ Error creating application: %s", e)
+    finally:
+        Path(temp_file).unlink(missing_ok=True)
+
+
+def _generate_app_template(config: TemplateConfig) -> dict[str, Any]:
+    """Generate ArgoCD application configuration from template."""
+    app = _create_base_application(config)
+    _customize_application_for_type(app, config)
+    return app
+
+
+def _create_base_application(config: TemplateConfig) -> dict[str, Any]:
+    """Create the base ArgoCD application structure."""
+    return {
+        "apiVersion": "argoproj.io/v1alpha1",
+        "kind": "Application",
+        "metadata": {"name": config.name, "namespace": "argocd"},
+        "spec": {
+            "project": "default",
+            "source": {"repoURL": config.repo, "path": config.path, "targetRevision": "HEAD"},
+            "destination": {
+                "server": "https://kubernetes.default.svc",
+                "namespace": config.namespace,
+            },
+            "syncPolicy": {"automated": {"prune": True, "selfHeal": True}},
+        },
+    }
+
+
+def _customize_application_for_type(app: dict[str, Any], config: TemplateConfig) -> None:
+    """Customize the application based on its type."""
+    if config.app_type == "web-app":
+        _configure_web_app(app, config)
+    elif config.app_type == "api":
+        _configure_api_app(app, config)
+    elif config.app_type == "worker":
+        _configure_worker_app(app, config)
+    elif config.app_type == "database":
+        _configure_database_app(app, config)
+
+
+def _configure_web_app(app: dict[str, Any], config: TemplateConfig) -> None:
+    """Configure a web application."""
+    app["spec"]["source"]["helm"] = {
+        "parameters": [
+            {"name": "image.repository", "value": config.image or f"{config.name}"},
+            {"name": "image.tag", "value": "latest"},
+            {"name": "service.port", "value": str(config.port)},
+        ]
+    }
+
+    if config.env_vars:
+        env_params = _build_env_parameters(config.env_vars)
+        if "helm" in app["spec"]["source"] and "parameters" in app["spec"]["source"]["helm"]:
+            app["spec"]["source"]["helm"]["parameters"].extend(env_params)
+
+
+def _configure_api_app(app: dict[str, Any], config: TemplateConfig) -> None:
+    """Configure an API application."""
+    app["spec"]["source"]["helm"] = {
+        "parameters": [
+            {"name": "image.repository", "value": config.image or f"{config.name}-api"},
+            {"name": "image.tag", "value": "latest"},
+            {"name": "service.port", "value": str(config.port)},
+            {"name": "ingress.enabled", "value": "true"},
+        ]
+    }
+
+
+def _configure_worker_app(app: dict[str, Any], config: TemplateConfig) -> None:
+    """Configure a worker application."""
+    app["spec"]["source"]["helm"] = {
+        "parameters": [
+            {"name": "image.repository", "value": config.image or f"{config.name}-worker"},
+            {"name": "image.tag", "value": "latest"},
+            {"name": "replicaCount", "value": "2"},
+        ]
+    }
+    # Remove service-related config for workers
+    if "syncPolicy" in app["spec"]:
+        app["spec"]["syncPolicy"] = {"automated": {}}  # Simpler sync policy
+
+
+def _configure_database_app(app: dict[str, Any], config: TemplateConfig) -> None:
+    """Configure a database application."""
+    app["spec"]["source"]["helm"] = {
+        "parameters": [
+            {"name": "image.repository", "value": config.image or "postgres"},
+            {"name": "image.tag", "value": "13"},
+            {"name": "persistence.enabled", "value": "true"},
+            {"name": "persistence.size", "value": "10Gi"},
+        ]
+    }
+
+
+def _build_env_parameters(env_vars: tuple[str, ...]) -> list[dict[str, str]]:
+    """Build environment variable parameters for helm."""
+    env_params = []
+    for env in env_vars:
+        if "=" in env:
+            key, value = env.split("=", 1)
+            env_params.append({"name": f"env.{key}", "value": value})
+    return env_params