mantatech-sdk 0.5b0.dev65__py3-none-any.whl

manta/cli/utils/__init__.py

@@ -0,0 +1,27 @@
+"""CLI utility functions and helpers."""
+
+from .converters import (
+    enum_to_string,
+    timestamp_to_string,
+    bytes_to_gb,
+    extract_platform_type,
+    extract_node_resources,
+    NODE_STATUS_MAP,
+    SWARM_STATUS_MAP,
+    CLUSTER_STATUS_MAP,
+    TASK_STATUS_MAP,
+    LOG_SEVERITY_MAP,
+)
+
+__all__ = [
+    "enum_to_string",
+    "timestamp_to_string",
+    "bytes_to_gb",
+    "extract_platform_type",
+    "extract_node_resources",
+    "NODE_STATUS_MAP",
+    "SWARM_STATUS_MAP",
+    "CLUSTER_STATUS_MAP",
+    "TASK_STATUS_MAP",
+    "LOG_SEVERITY_MAP",
+]

manta/cli/utils/converters.py

@@ -0,0 +1,140 @@
+"""Utility functions for CLI data conversion and formatting."""
+
+from datetime import datetime
+from typing import Any, Dict, Optional, Union
+
+
+def enum_to_string(value: Union[int, str], enum_map: Dict[int, str]) -> str:
+    """Convert enum value to string representation.
+
+    Args:
+        value: Enum value (int) or string
+        enum_map: Dictionary mapping enum int values to string names
+
+    Returns:
+        String representation of the enum value
+    """
+    if isinstance(value, int):
+        return enum_map.get(value, "UNKNOWN")
+    return str(value)
+
+
+def timestamp_to_string(
+    timestamp: Union[Dict[str, Any], str, int, float, None],
+    format: str = "%Y-%m-%d %H:%M:%S",
+) -> str:
+    """Convert various timestamp formats to string.
+
+    Args:
+        timestamp: Timestamp in various formats (dict with seconds, string, int/float, or None)
+        format: Output format string
+
+    Returns:
+        Formatted timestamp string or 'Unknown' if invalid
+    """
+    if not timestamp:
+        return "Unknown"
+
+    if isinstance(timestamp, dict):
+        if "seconds" in timestamp:
+            return datetime.fromtimestamp(timestamp["seconds"]).strftime(format)
+    elif isinstance(timestamp, str):
+        return timestamp
+    elif isinstance(timestamp, (int, float)):
+        return datetime.fromtimestamp(timestamp).strftime(format)
+
+    return "Unknown"
+
+
+def bytes_to_gb(bytes_value: Union[int, float, None]) -> float:
+    """Convert bytes to gigabytes.
+
+    Args:
+        bytes_value: Value in bytes
+
+    Returns:
+        Value in GB rounded to 2 decimal places
+    """
+    if bytes_value is None:
+        return 0.0
+    return round(bytes_value / (1024**3), 2)
+
+
+def extract_platform_type(platform_info: Optional[Dict[str, Any]]) -> str:
+    """Extract platform type from platform_info structure.
+
+    Args:
+        platform_info: Platform information dictionary
+
+    Returns:
+        Platform/OS type string
+    """
+    if not platform_info:
+        return "Unknown"
+
+    # Try different possible field names
+    for field in ["system", "platform", "os"]:
+        if field in platform_info:
+            return platform_info[field]
+
+    return "Unknown"
+
+
+def extract_node_resources(
+    metrics_snapshot: Optional[Dict[str, Any]],
+) -> Dict[str, Any]:
+    """Extract resource information from metrics snapshot.
+
+    Args:
+        metrics_snapshot: Metrics snapshot dictionary
+
+    Returns:
+        Dictionary with cpu_count and memory_gb
+    """
+    resources = {"cpu_count": "Unknown", "memory_gb": "Unknown"}
+
+    if not metrics_snapshot:
+        return resources
+
+    # Extract CPU info
+    if "cpu" in metrics_snapshot and metrics_snapshot["cpu"]:
+        cpu_info = metrics_snapshot["cpu"]
+        if "count" in cpu_info:
+            resources["cpu_count"] = cpu_info["count"]
+        elif "cores" in cpu_info:
+            resources["cpu_count"] = cpu_info["cores"]
+
+    # Extract memory info
+    if "memory" in metrics_snapshot and metrics_snapshot["memory"]:
+        memory_info = metrics_snapshot["memory"]
+        if "total_bytes" in memory_info:
+            resources["memory_gb"] = bytes_to_gb(memory_info["total_bytes"])
+        elif "total" in memory_info:
+            resources["memory_gb"] = bytes_to_gb(memory_info["total"])
+
+    return resources
+
+
+# Enum mappings for various status fields
+NODE_STATUS_MAP = {0: "UNKNOWN", 1: "CONNECTED", 2: "DISCONNECTED"}
+
+SWARM_STATUS_MAP = {
+    0: "PENDING",
+    1: "ACTIVE",
+    2: "PAUSED",
+    3: "STOPPED",
+    4: "COMPLETED",
+    5: "FAILED",
+}
+
+CLUSTER_STATUS_MAP = {0: "CREATED", 1: "RUNNING", 2: "STOPPED", 3: "ERROR"}
+
+TASK_STATUS_MAP = {
+    0: "PENDING",
+    1: "RUNNING",
+    2: "COMPLETED",
+    3: "FAILED",
+    4: "CANCELLED",
+}
+
+LOG_SEVERITY_MAP = {0: "DEBUG", 1: "INFO", 2: "WARNING", 3: "ERROR", 4: "CRITICAL"}

manta/clients/cluster_management_client.py

@@ -0,0 +1,486 @@
+"""
+Cluster Management Client implementation.
+
+This module provides the ClusterManagementClient class for interacting with the ClusterManagement service.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from logging import Logger
+from pathlib import Path
+from typing import Any, AsyncIterator, Dict, Optional, Type, TypeVar
+
+from manta_common.base_client import GrpcClientBase, MetadataDict
+from manta_common.build.common.cluster import Cluster
+from manta_common.build.common.informations import MetricsSnapshot, Node
+from manta_common.build.common.system import (
+    CollectionIds,
+    Empty,
+    Error,
+    Response,
+    StrId,
+)
+from manta_common.build.core.user_services import (  # Request/Response messages; Service stub
+    ClusterManagementStub,
+    CreateClusterRequest,
+    ErrorsRequest,
+    NodeRequest,
+    TaskResponse,
+)
+from manta_common.retry import RetryPolicy
+
+T = TypeVar("T")
+
+
+class ClusterManagementClient(GrpcClientBase):
+    """
+    Client for interacting with the ClusterManagement Service.
+
+    This client provides a high-level interface for making gRPC calls to the ClusterManagement service,
+    handling cluster lifecycle and node management operations.
+    """
+
+    __slots__ = ("_secure", "cafile", "certfile", "keyfile")
+
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        jwt_token: str,
+        secure: bool = False,
+        cafile: Optional[str] = None,
+        certfile: Optional[str] = None,
+        keyfile: Optional[str] = None,
+        channel_options: Optional[Dict[str, Any]] = None,
+        logger: Optional[Logger] = None,
+        retry_policy: Optional[RetryPolicy] = None,
+        streaming_retry_policy: Optional[RetryPolicy] = None,
+    ):
+        """
+        Initialize the ClusterManagementClient.
+
+        Parameters
+        ----------
+        host : str
+            The host of the ClusterManagement service
+        port : int
+            The port of the ClusterManagement service
+        jwt_token : str
+            JWT token for authentication
+        secure : bool
+            Whether to use a secure connection
+        cafile : Optional[str]
+            Path to the CA certificate file for verifying the server
+        certfile : Optional[str]
+            Path to the client certificate file
+        keyfile : Optional[str]
+            Path to the client private key file
+        channel_options : Optional[Dict[str, Any]]
+            The channel options
+        logger : Optional[Logger]
+            The logger
+        retry_policy : Optional[RetryPolicy]
+            The retry policy
+        streaming_retry_policy : Optional[RetryPolicy]
+            The streaming retry policy
+        """
+        super().__init__(
+            host=host,
+            port=port,
+            secure=secure,
+            channel_options=channel_options,
+            tracer=logger,
+            retry_policy=retry_policy,
+            streaming_retry_policy=streaming_retry_policy,
+        )
+        self.jwt_token = jwt_token
+        self._secure = secure
+        self.cafile = Path(cafile) if cafile is not None else None
+        self.certfile = Path(certfile) if certfile is not None else None
+        self.keyfile = Path(keyfile) if keyfile is not None else None
+
+    def _get_stub_class(self) -> Type[ClusterManagementStub]:
+        """Get the stub class for the ClusterManagement service."""
+        return ClusterManagementStub
+
+    @property
+    def metadata(self) -> MetadataDict:
+        return {"authorization": self.jwt_token}
+
+    async def is_available(self) -> Response:
+        """
+        Check if the ClusterManagement service is available.
+
+        Returns
+        -------
+        Response
+            Service availability status
+        """
+        return await self.call_service_method(
+            "is_available",
+            Empty(),
+        )
+
+    async def create_cluster(self, name: Optional[str] = None) -> StrId:
+        """
+        Create a new cluster.
+
+        Parameters
+        ----------
+        name : Optional[str]
+            Name for the cluster
+
+        Returns
+        -------
+        StrId
+            Cluster ID
+        """
+        request = CreateClusterRequest()
+        if name:
+            request.name = name
+        return await self.call_service_method(
+            "create_cluster",
+            request,
+        )
+
+    async def start_cluster(self, cluster_id: str) -> Cluster:
+        """
+        Start cluster services.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster to start
+
+        Returns
+        -------
+        Cluster
+            Cluster details
+        """
+        return await self.call_service_method(
+            "start_cluster",
+            StrId(id=cluster_id),
+        )
+
+    async def stop_cluster(self, cluster_id: str) -> Response:
+        """
+        Stop cluster services.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster to stop
+
+        Returns
+        -------
+        Response
+            Stop operation response
+        """
+        return await self.call_service_method(
+            "stop_cluster",
+            StrId(id=cluster_id),
+        )
+
+    async def delete_cluster(self, cluster_id: str) -> Response:
+        """
+        Delete a cluster.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster to delete
+
+        Returns
+        -------
+        Response
+            Deletion confirmation response
+        """
+        return await self.call_service_method(
+            "delete_cluster",
+            StrId(id=cluster_id),
+        )
+
+    async def list_cluster_ids(self) -> CollectionIds:
+        """
+        List all cluster IDs for the authenticated user.
+
+        Returns
+        -------
+        CollectionIds
+            Collection of cluster IDs
+        """
+        return await self.call_service_method(
+            "list_cluster_ids",
+            Empty(),
+        )
+
+    async def stream_clusters(self) -> AsyncIterator[Cluster]:
+        """
+        Stream all clusters for the authenticated user.
+
+        Yields
+        ------
+        Cluster
+            Cluster details
+        """
+        async for cluster in self.stream_service_method(
+            "stream_clusters",
+            Empty(),
+        ):
+            yield cluster
+
+    async def get_cluster(self, cluster_id: str) -> Cluster:
+        """
+        Get a cluster by its ID.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+
+        Returns
+        -------
+        Cluster
+            Cluster details
+        """
+        return await self.call_service_method(
+            "get_cluster",
+            StrId(id=cluster_id),
+        )
+
+    async def list_node_ids(self, cluster_id: str) -> CollectionIds:
+        """
+        List node IDs in a cluster.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+
+        Returns
+        -------
+        CollectionIds
+            Collection of node IDs
+        """
+        return await self.call_service_method(
+            "list_node_ids",
+            StrId(id=cluster_id),
+        )
+
+    async def stream_nodes(self, cluster_id: str) -> AsyncIterator[Node]:
+        """
+        Stream all nodes in a cluster.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+
+        Yields
+        ------
+        Node
+            Node information
+        """
+        async for node in self.stream_service_method(
+            "stream_nodes",
+            StrId(id=cluster_id),
+        ):
+            yield node
+
+    async def stop_node(self, cluster_id: str, node_id: str) -> Response:
+        """
+        Stop a specific node.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+        node_id : str
+            ID of the node to stop
+
+        Returns
+        -------
+        Response
+            Stop operation response
+        """
+        return await self.call_service_method(
+            "stop_node",
+            NodeRequest(cluster_id=cluster_id, node_id=node_id),
+        )
+
+    async def remove_node(self, cluster_id: str, node_id: str) -> Response:
+        """
+        Remove a node from the cluster.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+        node_id : str
+            ID of the node to remove
+
+        Returns
+        -------
+        Response
+            Removal confirmation response
+        """
+        return await self.call_service_method(
+            "remove_node",
+            NodeRequest(cluster_id=cluster_id, node_id=node_id),
+        )
+
+    async def get_node(self, cluster_id: str, node_id: str) -> Node:
+        """
+        Get a node by its ID.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+        node_id : str
+            ID of the node
+
+        Returns
+        -------
+        Node
+            Node information
+        """
+        return await self.call_service_method(
+            "get_node",
+            NodeRequest(cluster_id=cluster_id, node_id=node_id),
+        )
+
+    async def get_node_resources(
+        self, cluster_id: str, node_id: str
+    ) -> MetricsSnapshot:
+        """
+        Get node resources for a specific node.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+        node_id : str
+            ID of the node
+
+        Returns
+        -------
+        MetricsSnapshot
+            Node resource metrics
+        """
+        return await self.call_service_method(
+            "get_node_resources",
+            NodeRequest(cluster_id=cluster_id, node_id=node_id),
+        )
+
+    async def stream_node_resources(
+        self, cluster_id: str, node_id: str
+    ) -> AsyncIterator[MetricsSnapshot]:
+        """
+        Stream node resources for a specific node.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+        node_id : str
+            ID of the node
+
+        Yields
+        ------
+        MetricsSnapshot
+            Stream of node resource metrics
+        """
+        async for resource in self.stream_service_method(
+            "stream_node_resources",
+            NodeRequest(cluster_id=cluster_id, node_id=node_id),
+        ):
+            yield resource
+
+    async def list_available_node_ids(self, cluster_id: str) -> CollectionIds:
+        """
+        List available node IDs in a cluster.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+
+        Returns
+        -------
+        CollectionIds
+            Collection of available node IDs
+        """
+        return await self.call_service_method(
+            "list_available_node_ids",
+            StrId(id=cluster_id),
+        )
+
+    async def collect_errors(
+        self,
+        cluster_id: str,
+        start_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+        limit: Optional[int] = None,
+        sort_order: Optional[str] = None,
+    ) -> AsyncIterator[Error]:
+        """
+        Collect errors from a cluster.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+        start_time : Optional[datetime]
+            Start time for filtering errors
+        end_time : Optional[datetime]
+            End time for filtering errors
+        limit : Optional[int]
+            Maximum number of errors to return
+        sort_order : Optional[str]
+            Sort order for results
+
+        Yields
+        ------
+        Error
+            Stream of errors
+        """
+        request = ErrorsRequest(cluster_id=cluster_id)
+        if start_time:
+            request.start_time = start_time
+        if end_time:
+            request.end_time = end_time
+        if limit:
+            request.limit = limit
+        if sort_order:
+            request.sort_order = sort_order
+        async for error in self.stream_service_method(
+            "collect_errors",
+            request,
+        ):
+            yield error
+
+    async def select_tasks(
+        self, cluster_id: str, node_id: str
+    ) -> AsyncIterator[TaskResponse]:
+        """
+        Select tasks for a specific node.
+
+        Parameters
+        ----------
+        cluster_id : str
+            ID of the cluster
+        node_id : str
+            ID of the node
+
+        Yields
+        ------
+        TaskResponse
+            Stream of task information
+        """
+        async for task in self.stream_service_method(
+            "select_tasks",
+            NodeRequest(cluster_id=cluster_id, node_id=node_id),
+        ):
+            yield task