easyrunner-cli 0.0.8.dev126__tar.gz → 0.0.8.dev128__tar.gz

{easyrunner_cli-0.0.8.dev126 → easyrunner_cli-0.0.8.dev128}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyrunner_cli
-Version: 0.0.8.dev126
+Version: 0.0.8.dev128
 Summary: EasyRunner CLI.
 License: Proprietary
 Author: Janaka Abeywardhana

easyrunner_cli-0.0.8.dev128/easyrunner/source/services/__init__.py

@@ -0,0 +1,28 @@
+"""Service layer for business logic orchestration.
+
+Services are the bridge between interfaces (CLI, Web API, Web UI) and core logic.
+They encapsulate business rules, validation, and orchestration without being
+tied to any specific interface.
+
+Key principles:
+- Pure business logic (testable without I/O)
+- Return structured results (not UI formatting)
+- Can be consumed by CLI, Web API, and Web UI equally
+- No presentation logic (no Rich tables, JSON formatting, etc.)
+"""
+
+from .app_service import AppService
+from .deployment_service import DeploymentService
+from .license_service import LicenseService
+from .server_service import ServerService
+from .service_result import (
+    ServiceResult,
+)
+
+__all__ = [
+    "ServerService",
+    "AppService",
+    "DeploymentService",
+    "LicenseService",
+    "ServiceResult",
+]

easyrunner_cli-0.0.8.dev128/easyrunner/source/services/app_service.py

@@ -0,0 +1,168 @@
+"""AppService: Business logic for application management operations.
+
+Handles:
+- App validation and persistence
+- App deployment orchestration
+- App status checks
+"""
+
+import logging
+from typing import List
+
+from ..store import EasyRunnerStore
+from ..store.data_models.app import App
+from .service_result import ServiceResult
+
+logger = logging.getLogger(__name__)
+
+
+class AppService:
+    """Service for app management business logic."""
+
+    def __init__(self, store: EasyRunnerStore):
+        """Initialize service with store dependency.
+
+        Args:
+            store: EasyRunnerStore instance for persistence
+        """
+        self.store = store
+
+    def get_app(self, server_name: str, app_name: str) -> ServiceResult[App]:
+        """Get an app from a server.
+
+        Args:
+            server_name: Name of the server
+            app_name: Name of the app
+
+        Returns:
+            ServiceResult with App on success, or error if not found
+        """
+        try:
+            # Get server
+            server = self.store.get_server_by_name(name=server_name)
+            if not server:
+                logger.debug(f"Server not found: {server_name}")
+                return ServiceResult.error(
+                    message=f"Server '{server_name}' not found",
+                    error_code="SERVER_NOT_FOUND",
+                )
+
+            # Get app from server
+            app = next((a for a in server.apps if a.name == app_name), None)
+            if not app:
+                logger.debug(f"App not found: {app_name} on {server_name}")
+                return ServiceResult.error(
+                    message=f"App '{app_name}' not found on server '{server_name}'",
+                    error_code="APP_NOT_FOUND",
+                )
+
+            return ServiceResult.ok(
+                message=f"App '{app_name}' retrieved",
+                data=app,
+            )
+
+        except Exception as e:
+            logger.error(f"Error getting app: {str(e)}", exc_info=True)
+            return ServiceResult.error(
+                message=f"Failed to get app: {str(e)}",
+                error_code="INTERNAL_ERROR",
+            )
+
+    def list_apps(self, server_name: str) -> ServiceResult[List[App]]:
+        """List all apps on a server.
+
+        Args:
+            server_name: Name of the server
+
+        Returns:
+            ServiceResult with list of apps
+        """
+        try:
+            # Get server
+            server = self.store.get_server_by_name(name=server_name)
+            if not server:
+                logger.debug(f"Server not found: {server_name}")
+                return ServiceResult.error(
+                    message=f"Server '{server_name}' not found",
+                    error_code="SERVER_NOT_FOUND",
+                )
+
+            apps = server.apps if server.apps else []
+            return ServiceResult.ok(
+                message=f"Retrieved {len(apps)} app(s)",
+                data=apps,
+            )
+
+        except Exception as e:
+            logger.error(f"Error listing apps: {str(e)}", exc_info=True)
+            return ServiceResult.error(
+                message=f"Failed to list apps: {str(e)}",
+                error_code="INTERNAL_ERROR",
+            )
+
+    def validate_app_for_deployment(
+        self, server_name: str, app_name: str
+    ) -> ServiceResult[App]:
+        """Validate that an app is ready for deployment.
+
+        Business validation:
+        - App exists
+        - Server exists
+        - App has custom domain set (required for deployment)
+        - App has repo URL set
+
+        Args:
+            server_name: Name of the server
+            app_name: Name of the app
+
+        Returns:
+            ServiceResult with App if valid, error otherwise
+        """
+        try:
+            # Get the app (also validates server exists)
+            app_result = self.get_app(server_name=server_name, app_name=app_name)
+            if not app_result.success:
+                return app_result
+
+            app = app_result.data
+            if not app:
+                # Should not happen if app_result.success is True, but guard anyway
+                return ServiceResult.error(
+                    message=f"App '{app_name}' data is missing",
+                    error_code="APP_DATA_MISSING",
+                )
+
+            # Business rule: custom domain required
+            if not app.custom_domain:
+                logger.warning(
+                    f"App validation failed - no custom domain: {app_name} on {server_name}"
+                )
+                return ServiceResult.error(
+                    message=f"App '{app_name}' must have a custom domain set before deployment",
+                    error_code="MISSING_CUSTOM_DOMAIN",
+                    details={"app_name": app_name, "server_name": server_name},
+                )
+
+            # Business rule: repo URL required
+            if not app.repo_url or str(app.repo_url).strip() == "":
+                logger.warning(
+                    f"App validation failed - no repo URL: {app_name} on {server_name}"
+                )
+                return ServiceResult.error(
+                    message=f"App '{app_name}' must have a repository URL set before deployment",
+                    error_code="MISSING_REPO_URL",
+                    details={"app_name": app_name, "server_name": server_name},
+                )
+
+            logger.info(f"App validation passed: {app_name} on {server_name}")
+            return ServiceResult.ok(
+                message=f"App '{app_name}' is ready for deployment",
+                data=app,
+            )
+
+        except Exception as e:
+            logger.error(f"Error validating app: {str(e)}", exc_info=True)
+            return ServiceResult.error(
+                message=f"Failed to validate app: {str(e)}",
+                error_code="INTERNAL_ERROR",
+            )

easyrunner_cli-0.0.8.dev128/easyrunner/source/services/deployment_service.py

@@ -0,0 +1,170 @@
+"""DeploymentService: Orchestrates multi-step app deployment flows.
+
+Handles:
+- Deployment validation and prerequisites
+- SSH connection setup
+- Coordinating resource operations
+- Error handling and rollback
+"""
+
+import logging
+from typing import Optional
+
+from ..command_executor import CommandExecutor
+from ..integrations.github import GitHubTokenManager
+from ..resources.os_resources import HostServerUbuntu
+from ..ssh import Ssh
+from ..store import EasyRunnerStore, SecretStore
+from .app_service import AppService
+from .service_result import ServiceResult
+
+logger = logging.getLogger(__name__)
+
+
+class DeploymentService:
+    """Service for orchestrating app deployments."""
+
+    def __init__(self, store: EasyRunnerStore, secret_store: SecretStore):
+        """Initialize service with store and secret store dependencies.
+
+        Args:
+            store: EasyRunnerStore instance for persistence
+            secret_store: SecretStore instance for secure token storage
+        """
+        self.store = store
+        self.secret_store = secret_store
+        self.app_service = AppService(store=store)
+        self.token_manager = GitHubTokenManager(secret_store=secret_store)
+
+    def deploy_app(
+        self,
+        server_name: str,
+        app_name: str,
+        ssh_username: str,
+        ssh_key_path: str,
+        github_token: Optional[str] = None,
+        debug: bool = False,
+        silent: bool = False,
+    ) -> ServiceResult[dict]:
+        """Deploy an app to a server.
+
+        This is the main orchestration method. It:
+        1. Validates the app is ready for deployment
+        2. Retrieves GitHub token if needed
+        3. Establishes SSH connection
+        4. Delegates to HostServerUbuntu resource for actual deployment
+        5. Handles errors and provides feedback
+
+        Args:
+            server_name: Name of the server to deploy to
+            app_name: Name of the app to deploy
+            ssh_username: SSH username for connection
+            ssh_key_path: Path to SSH private key
+            github_token: Optional GitHub token (retrieved from store if not provided)
+            debug: Enable debug logging
+            silent: Suppress non-error output
+
+        Returns:
+            ServiceResult with deployment details on success, or error information
+        """
+        try:
+            # Step 1: Validate app is ready for deployment
+            validation_result = self.app_service.validate_app_for_deployment(
+                server_name=server_name, app_name=app_name
+            )
+            if not validation_result.success:
+                logger.warning(f"App validation failed: {validation_result.message}")
+                return ServiceResult.error(
+                    message=validation_result.message,
+                    error_code=validation_result.error_code,
+                )
+
+            app = validation_result.data
+            if not app:
+                # Should not happen if validation_result.success is True, but guard anyway
+                return ServiceResult.error(
+                    message=f"App '{app_name}' data is missing",
+                    error_code="APP_DATA_MISSING",
+                )
+
+            # Step 2: Get GitHub token if not provided
+            if github_token is None:
+                try:
+                    github_token = self.token_manager.get_token()
+                except Exception as e:
+                    logger.error(f"Failed to retrieve GitHub token: {str(e)}")
+                    return ServiceResult.error(
+                        message="GitHub token not found. Authenticate with GitHub first using 'er link github'.",
+                        error_code="GITHUB_TOKEN_NOT_FOUND",
+                    )
+
+            if not github_token:
+                logger.error("No GitHub token available")
+                return ServiceResult.error(
+                    message="No GitHub token configured. Please authenticate with GitHub.",
+                    error_code="GITHUB_TOKEN_NOT_CONFIGURED",
+                )
+
+            # Step 3: Get server info to get hostname/IP
+            server_result = self.app_service.get_app(
+                server_name=server_name, app_name=app_name
+            )
+            if not server_result.success:
+                logger.error(f"Server not found: {server_name}")
+                return ServiceResult.error(
+                    message=f"Server '{server_name}' not found",
+                    error_code="SERVER_NOT_FOUND",
+                )
+
+            server = self.store.get_server_by_name(name=server_name)
+            if not server:
+                logger.error(f"Server '{server_name}' is missing.")
+                return ServiceResult.error(
+                    message=f"Server '{server_name}' is missing.",
+                    error_code="SERVER_NOT_FOUND",
+                )
+
+            # Step 4: Establish SSH connection and deploy
+            logger.info(
+                f"Starting deployment: {app_name} to {server_name} via SSH as {ssh_username}"
+            )
+
+            with Ssh(
+                hostname_or_ipv4=server.hostname_or_ip,
+                username=ssh_username,
+                key_filename=ssh_key_path,
+            ) as ssh_client:
+                executor = CommandExecutor(ssh_client=ssh_client)
+                host_server = HostServerUbuntu(
+                    easyrunner_username=ssh_username,
+                    executor=executor,
+                    debug=debug,
+                    silent=silent,
+                )
+
+                # Delegate to resource for actual deployment
+                logger.info(f"Executing deployment flow for {app_name}")
+                host_server.deploy_app_flow_a(
+                    repo_url=app.repo_url,  # type: ignore
+                    custom_app_domain_name=app.custom_domain,  # type: ignore
+                    github_access_token=github_token,
+                )
+
+            logger.info(f"Deployment completed: {app_name} on {server_name}")
+            return ServiceResult.ok(
+                message=f"App '{app_name}' deployed successfully to '{server_name}'",
+                data={
+                    "app_name": app_name,
+                    "server_name": server_name,
+                    "custom_domain": app.custom_domain,
+                },
+            )
+
+        except Exception as e:
+            error_msg = f"Deployment failed: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return ServiceResult.error(
+                message=error_msg,
+                error_code="DEPLOYMENT_FAILED",
+                details={"exception_type": type(e).__name__},
+            )

easyrunner_cli-0.0.8.dev128/easyrunner/source/services/license_service.py

@@ -0,0 +1,76 @@
+"""LicenseService: Business logic for license checks and quota enforcement.
+
+Handles:
+- Server limit enforcement
+- App limit enforcement
+- License expiration checks
+"""
+
+import logging
+
+from ..store import EasyRunnerStore
+from .service_result import ServiceResult
+
+logger = logging.getLogger(__name__)
+
+
+class LicenseService:
+    """Service for license-related business logic."""
+
+    def __init__(self, store: EasyRunnerStore):
+        """Initialize service with store dependency.
+
+        Args:
+            store: EasyRunnerStore instance for persistence
+        """
+        self.store = store
+
+    def can_add_server(self) -> ServiceResult[None]:
+        """Check if a new server can be added based on license limits.
+
+        Returns:
+            ServiceResult indicating if server can be added
+        """
+        try:
+            # TODO: Integrate with actual LicenseManager when it's refactored to core
+            # For now, just return True (no license checks)
+            logger.debug("License check: can_add_server - not yet integrated")
+            return ServiceResult.ok(
+                message="Server can be added (TODO: integrate with LicenseManager)",
+            )
+
+        except Exception as e:
+            logger.error(f"Error checking server quota: {str(e)}", exc_info=True)
+            # Be permissive on errors (don't block operations)
+            return ServiceResult.ok(
+                message="Server can be added (error in license check, permissive mode)",
+            )
+
+    def can_add_app(self, server_name: str) -> ServiceResult[None]:
+        """Check if a new app can be added to a server based on license limits.
+
+        Args:
+            server_name: Name of the server
+
+        Returns:
+            ServiceResult indicating if app can be added
+        """
+        try:
+            server = self.store.get_server_by_name(name=server_name)
+            if not server:
+                return ServiceResult.error(
+                    message=f"Server '{server_name}' not found",
+                    error_code="SERVER_NOT_FOUND",
+                )
+
+            # TODO: Check license limits for apps per server
+            logger.debug(f"License check: can_add_app on {server_name}")
+            return ServiceResult.ok(
+                message="App can be added (TODO: check license limits)",
+            )
+
+        except Exception as e:
+            logger.error(f"Error checking app quota: {str(e)}", exc_info=True)
+            return ServiceResult.ok(
+                message="App can be added (error in license check, permissive mode)",
+            )

easyrunner_cli-0.0.8.dev128/easyrunner/source/services/server_service.py

@@ -0,0 +1,172 @@
+"""ServerService: Business logic for server management operations.
+
+Handles:
+- Server addition with validation (uniqueness, etc.)
+- Server retrieval and listing
+- Server deletion
+- Server setup verification
+"""
+
+import logging
+from typing import List
+
+from ..store import EasyRunnerStore
+from ..store.data_models.server import Server
+from .service_result import ServiceResult
+
+logger = logging.getLogger(__name__)
+
+
+class ServerService:
+    """Service for server management business logic."""
+
+    def __init__(self, store: EasyRunnerStore):
+        """Initialize service with store dependency.
+
+        Args:
+            store: EasyRunnerStore instance for persistence
+        """
+        self.store = store
+
+    def add_server(
+        self, name: str, hostname_or_ip: str
+    ) -> ServiceResult[Server]:
+        """Add a server to the store with validation.
+
+        Business validation:
+        - Server name must be unique
+        - Hostname/IP must be unique
+
+        Args:
+            name: Friendly name for the server
+            hostname_or_ip: Hostname or IP address
+
+        Returns:
+            ServiceResult with created Server on success, or error message on failure
+        """
+        try:
+            # Validation: check name uniqueness
+            existing_by_name = self.store.get_server_by_name(name=name)
+            if existing_by_name:
+                logger.warning(f"Attempt to add server with duplicate name: {name}")
+                return ServiceResult.error(
+                    message=f"Server with name '{name}' already exists",
+                    error_code="DUPLICATE_NAME",
+                    details={"existing_server": existing_by_name.name},
+                )
+
+            # Validation: check hostname/IP uniqueness
+            existing_by_addr = self.store.get_server_by_hostname_or_ip(
+                hostname_or_ip=hostname_or_ip
+            )
+            if existing_by_addr:
+                logger.warning(
+                    f"Attempt to add server with duplicate address: {hostname_or_ip}"
+                )
+                return ServiceResult.error(
+                    message=f"Server with address '{hostname_or_ip}' already exists",
+                    error_code="DUPLICATE_ADDRESS",
+                    details={"existing_server": existing_by_addr.name},
+                )
+
+            # Create and persist server
+            server = Server(name=name, hostname_or_ip=hostname_or_ip)
+            self.store.add_server(server=server)
+
+            logger.info(f"Server added: {name} ({hostname_or_ip})")
+            return ServiceResult.ok(
+                message=f"Server '{name}' added successfully",
+                data=server,
+            )
+
+        except Exception as e:
+            logger.error(f"Error adding server: {str(e)}", exc_info=True)
+            return ServiceResult.error(
+                message=f"Failed to add server: {str(e)}",
+                error_code="INTERNAL_ERROR",
+            )
+
+    def get_server(self, name: str) -> ServiceResult[Server]:
+        """Get a server by name.
+
+        Args:
+            name: Server name
+
+        Returns:
+            ServiceResult with Server on success, or error if not found
+        """
+        try:
+            server = self.store.get_server_by_name(name=name)
+            if not server:
+                logger.debug(f"Server not found: {name}")
+                return ServiceResult.error(
+                    message=f"Server '{name}' not found",
+                    error_code="NOT_FOUND",
+                )
+
+            return ServiceResult.ok(
+                message=f"Server '{name}' retrieved",
+                data=server,
+            )
+
+        except Exception as e:
+            logger.error(f"Error getting server: {str(e)}", exc_info=True)
+            return ServiceResult.error(
+                message=f"Failed to get server: {str(e)}",
+                error_code="INTERNAL_ERROR",
+            )
+
+    def list_servers(self) -> ServiceResult[List[Server]]:
+        """List all servers.
+
+        Returns:
+            ServiceResult with list of servers
+        """
+        try:
+            servers = self.store.list_servers()
+            return ServiceResult.ok(
+                message=f"Retrieved {len(servers)} server(s)",
+                data=servers,
+            )
+
+        except Exception as e:
+            logger.error(f"Error listing servers: {str(e)}", exc_info=True)
+            return ServiceResult.error(
+                message=f"Failed to list servers: {str(e)}",
+                error_code="INTERNAL_ERROR",
+            )
+
+    def delete_server(self, name: str) -> ServiceResult[None]:
+        """Delete a server by name.
+
+        Args:
+            name: Server name
+
+        Returns:
+            ServiceResult indicating success or failure
+        """
+        try:
+            # Get the server first to validate it exists
+            server_result = self.get_server(name)
+            if not server_result.success:
+                return ServiceResult.error(
+                    message=server_result.message,
+                    error_code=server_result.error_code,
+                )
+
+            # Delete from store using server id
+            server = server_result.data
+            if server:
+                self.store.remove_server(server_id=server.id)
+
+            logger.info(f"Server deleted: {name}")
+            return ServiceResult.ok(
+                message=f"Server '{name}' deleted successfully",
+            )
+
+        except Exception as e:
+            logger.error(f"Error deleting server: {str(e)}", exc_info=True)
+            return ServiceResult.error(
+                message=f"Failed to delete server: {str(e)}",
+                error_code="INTERNAL_ERROR",
+            )

easyrunner_cli-0.0.8.dev128/easyrunner/source/services/service_result.py

@@ -0,0 +1,48 @@
+"""Service result types for structured error/success handling.
+
+Services return result objects instead of raising exceptions or returning raw values.
+This enables callers (CLI, Web API, etc.) to handle success and failure uniformly.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Generic, Optional, TypeVar
+
+T = TypeVar("T")
+
+
+@dataclass
+class ServiceResult(Generic[T]):
+    """Base result type for all service operations."""
+
+    success: bool
+    message: str
+    data: Optional[T] = None
+    error_code: Optional[str] = None
+    details: Optional[dict[str, Any]] = None
+
+    @classmethod
+    def ok(cls, message: str = "Operation successful", data: Optional[T] = None, details: Optional[dict] = None) -> "ServiceResult[T]":
+        """Create a successful result."""
+        return cls(
+            success=True,
+            message=message,
+            data=data,
+            details=details,
+        )
+
+    @classmethod
+    def error(cls, message: str, error_code: Optional[str] = None, details: Optional[dict] = None) -> "ServiceResult[T]":
+        """Create an error result."""
+        return cls(
+            success=False,
+            message=message,
+            error_code=error_code,
+            details=details,
+        )
+
+
+# Use ServiceResult[T] directly for server add, app deploy, and license check operations.
+# Example:
+# result: ServiceResult[Server]
+# result: ServiceResult[AppDeployment]
+# result: ServiceResult[LicenseInfo]