redfish-python-sdk 1.0.0__py3-none-any.whl

redfish_sdk/managers/managers.py

@@ -0,0 +1,120 @@
+"""
+Managers manager — manages BMC (Baseboard Management Controller) resources.
+
+Provides access to:
+- Manager info (BMC firmware version, model, etc.)
+- Log services and log entries
+- Network protocol configuration
+- Ethernet interfaces
+- Host interfaces
+
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, List, Optional
+
+from ..models.logs import Log, LogEntry
+from ..models.managers import EthernetInterface, HostInterface, Manager, NetworkProtocol
+
+if TYPE_CHECKING:
+    from ..client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+
+class ManagersManager:
+    """
+    Manages Redfish Manager resources (BMC).
+
+
+    """
+
+    def __init__(self, client: RedfishClient):
+        self._client = client
+        self._http = client._http_client
+
+    def get(self, manager_id: str = "1") -> Manager:
+        """
+        Get a manager (BMC) resource by ID.
+
+
+
+        Args:
+            manager_id: Manager ID (default "1")
+
+        Returns:
+            Manager resource
+        """
+        managers_odata_id = self._client._get_managers_collection_odata_id()
+        return self._http.get(
+            f"{managers_odata_id}/{manager_id}", Manager
+        )
+
+    def log_services(self, manager_id: str = "1") -> List[Log]:
+        """
+        Get the list of log services for a manager (BMC).
+
+
+        """
+        from ._log_helpers import require_log_services_link
+
+        manager = self.get(manager_id)
+        odata_id = require_log_services_link(manager, f"Manager {manager.id!r}")
+        return self._client._get_collection(odata_id, Log)
+
+    def log_entries(
+        self,
+        log_id: Optional[str] = None,
+        manager_id: str = "1",
+    ) -> List[LogEntry]:
+        """
+        Get log entries for a manager (BMC) log service.
+
+        Dynamic Entries link discovery + per-entry GET fallback;
+        ``log_id`` is optional. See
+        :meth:`SystemsManager.log_entries` for the full behaviour contract.
+        """
+        from ._log_helpers import (
+            fetch_log_entries,
+            require_log_services_link,
+            resolve_log_service,
+        )
+
+        manager = self.get(manager_id)
+        odata_id = require_log_services_link(manager, f"Manager {manager.id!r}")
+        log = resolve_log_service(self._client, odata_id, log_id)
+        return fetch_log_entries(self._client, log)
+
+    def network_protocol(self, manager_id: str = "1") -> NetworkProtocol:
+        """
+        Get network protocol configuration for a manager.
+
+
+        """
+        manager = self.get(manager_id)
+        return self._http.get(
+            f"{manager.odata_id}/NetworkProtocol", NetworkProtocol
+        )
+
+    def ethernet_interfaces(self, manager_id: str = "1") -> List[EthernetInterface]:
+        """
+        Get the list of Ethernet interfaces for a manager (BMC).
+
+
+        """
+        manager = self.get(manager_id)
+        return self._client._get_collection(
+            manager.ethernet_interfaces.odata_id, EthernetInterface
+        )
+
+    def host_interfaces(self, manager_id: str = "1") -> List[HostInterface]:
+        """
+        Get the list of host interfaces for a manager.
+
+
+        """
+        manager = self.get(manager_id)
+        return self._client._get_collection(
+            manager.host_interfaces.odata_id, HostInterface
+        )

redfish_sdk/managers/registries.py

@@ -0,0 +1,48 @@
+"""
+Registries manager — manages Redfish message registries.
+
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, List
+
+from ..models.registry import Registry
+
+if TYPE_CHECKING:
+    from ..client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+
+class RegistriesManager:
+    """
+    Manages Redfish message registries.
+
+
+    """
+
+    def __init__(self, client: RedfishClient):
+        self._client = client
+        self._http = client._http_client
+
+    def registries(self) -> List[Registry]:
+        """
+        Get the list of message registries.
+
+
+        """
+        return self._client._get_registries_collection()
+
+    def get(self, registry_id: str) -> Registry:
+        """
+        Get a specific message registry by ID.
+
+        Args:
+            registry_id: Registry ID (e.g., "Base.1.15.0")
+
+        Returns:
+            Registry resource
+        """
+        registries_odata_id = self._client._get_registries_collection_odata_id()
+        return self._http.get(f"{registries_odata_id}/{registry_id}", Registry)

redfish_sdk/managers/session.py

@@ -0,0 +1,130 @@
+"""
+Session service manager — manages active BMC sessions.
+
+Provides:
+- List sessions
+- Get session
+- Create session (login)
+- Delete session (logout)
+
+Session creation returns an X-Auth-Token in the response header.
+The SDK can optionally switch to token-based auth after login.
+
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, List
+
+from ..models.session import Session
+
+if TYPE_CHECKING:
+    from ..client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+
+class SessionServiceManager:
+    """
+    Manages Redfish Session resources.
+
+
+    """
+
+    def __init__(self, client: RedfishClient):
+        self._client = client
+        self._http = client._http_client
+
+    def sessions(self) -> List[Session]:
+        """
+        Get the list of active sessions.
+
+
+        """
+        session_service = self._client._get_session_service()
+        return self._client._get_collection(session_service.sessions.odata_id, Session)
+
+    def get(self, session_id: str) -> Session:
+        """
+        Get a specific session by ID.
+
+
+        """
+        session_service = self._client._get_session_service()
+        path = f"{session_service.sessions.odata_id}/{session_id}"
+        return self._http.get(path, Session)
+
+    def create(
+        self,
+        username: str,
+        password: str,
+        switch_to_token_auth: bool = False,
+    ) -> Session:
+        """
+        Create a new session (login to the BMC).
+
+        The Redfish spec requires posting to the Sessions collection directly
+        (not via SessionService), which may be at /redfish/v1/SessionService/Sessions
+        or /redfish/v1/Sessions.
+
+        After creation, the X-Auth-Token is returned in the response header.
+        If switch_to_token_auth=True, the SDK client will use this token
+        for subsequent requests instead of Basic Auth.
+
+
+
+        Args:
+            username: BMC username
+            password: BMC password
+            switch_to_token_auth: If True, switch client to token-based auth
+
+        Returns:
+            Session resource with x_auth_token populated
+        """
+        # Use the Sessions link from the root service links (direct sessions endpoint)
+        root = self._client._get_root()
+        sessions_url = None
+
+        if root.links and root.links.sessions:
+            sessions_url = root.links.sessions.odata_id
+        else:
+            # Fallback to session service
+            session_service = self._client._get_session_service()
+            sessions_url = session_service.sessions.odata_id
+
+        body = {"UserName": username, "Password": password}
+
+        response = self._http.post_raw(sessions_url, body=body)
+
+        # Parse the session from response body
+        session_data = response.json()
+        session = Session.model_validate(session_data)
+
+        # Extract X-Auth-Token from response headers
+        token = response.headers.get("X-Auth-Token") or response.headers.get("x-auth-token")
+        if token:
+            session.x_auth_token = token
+            logger.info("Session created successfully, token acquired")
+
+            if switch_to_token_auth:
+                self._http.set_auth_token(token)
+
+        return session
+
+    def delete(self, session_id: str) -> str:
+        """
+        Delete a session (logout).
+
+
+
+        Args:
+            session_id: Session ID to delete
+
+        Returns:
+            Response body (usually empty)
+        """
+        session_service = self._client._get_session_service()
+        path = f"{session_service.sessions.odata_id}/{session_id}"
+        result = self._http.delete(path)
+        logger.info("Session %s deleted", session_id)
+        return result