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

redfish_sdk/managers/task.py

@@ -0,0 +1,89 @@
+"""
+Task service manager — manages asynchronous tasks.
+
+"""
+from __future__ import annotations
+
+import logging
+import time
+from typing import TYPE_CHECKING, List
+
+from ..models.task import Task
+
+if TYPE_CHECKING:
+    from ..client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+
+class TaskServiceManager:
+    """
+    Manages Redfish Task resources.
+
+
+    """
+
+    def __init__(self, client: RedfishClient):
+        self._client = client
+        self._http = client._http_client
+
+    def tasks(self) -> List[Task]:
+        """
+        Get the list of all tasks.
+        """
+        task_service = self._client._get_task_service()
+        return self._client._get_collection(task_service.tasks.odata_id, Task)
+
+    def get(self, task_id: str) -> Task:
+        """
+        Get a specific task by ID.
+
+        Args:
+            task_id: Task ID
+
+        Returns:
+            Task resource
+        """
+        task_service = self._client._get_task_service()
+        return self._http.get(f"{task_service.tasks.odata_id}/{task_id}", Task)
+
+    def wait_for_task(
+        self,
+        task_id: str,
+        poll_interval: int = 5,
+        timeout: int = 600,
+    ) -> Task:
+        """
+        Poll a task until it completes or times out.
+
+        Useful for monitoring long-running firmware update tasks.
+
+        Args:
+            task_id: Task ID to monitor
+            poll_interval: Seconds between polls (default 5)
+            timeout: Maximum wait time in seconds (default 600)
+
+        Returns:
+            Completed Task resource
+
+        Raises:
+            TimeoutError: If task does not complete within timeout
+        """
+        elapsed = 0
+        while elapsed < timeout:
+            task = self.get(task_id)
+            state = task.task_state or ""
+            logger.info(
+                "Task %s: state=%s, percent=%s%%",
+                task_id, state, task.percent_complete
+            )
+
+            if state in ("Completed", "Exception", "Killed", "Cancelled"):
+                return task
+
+            time.sleep(poll_interval)
+            elapsed += poll_interval
+
+        raise TimeoutError(
+            f"Task {task_id} did not complete within {timeout} seconds"
+        )

redfish_sdk/managers/update.py

@@ -0,0 +1,99 @@
+"""
+Update service manager — manages firmware updates.
+
+Provides:
+- Firmware inventory listing
+- Client certificate listing
+- Firmware update (SimpleUpdate) with multi-vendor strategy support
+
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, List, Optional
+
+from ..models.common import RedfishResponse
+from ..models.update import ClientCertificate, FirmwareInventory
+from .update_strategies import UpdateStrategyRegistry, VendorDetector
+
+if TYPE_CHECKING:
+    from ..client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+
+class UpdateServiceManager:
+    """
+    Manages Redfish Update service resources.
+
+    SimpleUpdate automatically detects the server vendor and applies
+    the appropriate request body format. Users can override the vendor
+    detection by passing the ``vendor`` parameter.
+    """
+
+    def __init__(self, client: RedfishClient):
+        self._client = client
+        self._http = client._http_client
+
+    def firmware_inventory(self) -> List[FirmwareInventory]:
+        """
+        Get the list of firmware inventory entries.
+
+        """
+        update_service = self._client._get_update_service()
+        return self._client._get_collection(
+            update_service.firmware_inventory.odata_id, FirmwareInventory
+        )
+
+    def client_certificates(self) -> List[ClientCertificate]:
+        """
+        Get the list of client certificates for firmware update authentication.
+
+        """
+        update_service = self._client._get_update_service()
+        return self._client._get_collection(
+            update_service.client_certificates.odata_id, ClientCertificate
+        )
+
+    def simple_update(
+        self,
+        image_uri: str,
+        transfer_protocol: str = "HTTP",
+        targets: Optional[list] = None,
+        vendor: Optional[str] = None,
+        **kwargs: Any,
+    ) -> RedfishResponse:
+        """
+        Trigger a firmware update via a remote image URI (e.g., NFS, HTTP).
+
+        Automatically detects the server vendor and uses the appropriate
+        request body format. The vendor can be manually overridden.
+
+        Args:
+            image_uri: URI of the firmware image (e.g., "http://nas/fw/bmc.bin")
+            transfer_protocol: Transfer protocol (e.g., "HTTP", "NFS", "TFTP")
+            targets: Optional list of firmware target paths
+                     (e.g., ["/redfish/v1/Managers/1"] or ["ActiveBMC"])
+            vendor: Optional vendor override (e.g., "inspur", "lenovo").
+                    If not set, the vendor is auto-detected.
+            **kwargs: Vendor-specific parameters. Common ones include:
+                - username (str): File server username (Inspur, Lenovo, H3C)
+                - password (str): File server password (Inspur, Lenovo, H3C)
+                - preserve_config (bool): Preserve configuration during update
+
+        Returns:
+            RedfishResponse (may contain a task reference for async update)
+        """
+        detected_vendor = vendor or VendorDetector.detect(self._client)
+        strategy = UpdateStrategyRegistry.get(detected_vendor)
+
+        logger.info(
+            "SimpleUpdate: vendor=%s, strategy=%s, ImageURI=%s",
+            detected_vendor,
+            type(strategy).__name__,
+            image_uri,
+        )
+
+        return strategy.execute(
+            self._client, image_uri, transfer_protocol, targets, **kwargs
+        )

redfish_sdk/managers/update_strategies/__init__.py

@@ -0,0 +1,51 @@
+"""
+Update strategies for multi-vendor firmware update support.
+
+This package implements the Strategy Pattern for SimpleUpdate, allowing
+each server vendor to have its own body-construction logic while keeping
+a single entry point in UpdateServiceManager.simple_update().
+
+Architecture:
+    BaseUpdateStrategy (ABC)
+      ├── GenericUpdateStrategy   — standard Redfish fallback
+      ├── InspurUpdateStrategy    — Inspur (浪潮)
+      ├── ZteUpdateStrategy       — ZTE (中兴)
+      ├── H3cUpdateStrategy       — H3C (新华三)
+      ├── NettrixUpdateStrategy   — Nettrix (宁畅)
+      ├── XFusionUpdateStrategy   — xFusion (超聚变)
+      └── LenovoUpdateStrategy    — Lenovo (联想)
+
+All strategies are auto-registered when this package is imported.
+"""
+
+from .base import BaseUpdateStrategy, GenericUpdateStrategy
+from .h3c import H3cUpdateStrategy
+from .inspur import InspurUpdateStrategy
+from .lenovo import LenovoUpdateStrategy
+from .nettrix import NettrixUpdateStrategy
+from .registry import UpdateStrategyRegistry
+from .vendor_detect import VendorDetector
+from .xfusion import XFusionUpdateStrategy
+from .zte import ZteUpdateStrategy
+
+# --- Auto-register all vendor strategies ---
+UpdateStrategyRegistry.register("generic", GenericUpdateStrategy())
+UpdateStrategyRegistry.register("inspur", InspurUpdateStrategy())
+UpdateStrategyRegistry.register("zte", ZteUpdateStrategy())
+UpdateStrategyRegistry.register("h3c", H3cUpdateStrategy())
+UpdateStrategyRegistry.register("nettrix", NettrixUpdateStrategy())
+UpdateStrategyRegistry.register("xfusion", XFusionUpdateStrategy())
+UpdateStrategyRegistry.register("lenovo", LenovoUpdateStrategy())
+
+__all__ = [
+    "BaseUpdateStrategy",
+    "GenericUpdateStrategy",
+    "InspurUpdateStrategy",
+    "ZteUpdateStrategy",
+    "H3cUpdateStrategy",
+    "NettrixUpdateStrategy",
+    "XFusionUpdateStrategy",
+    "LenovoUpdateStrategy",
+    "UpdateStrategyRegistry",
+    "VendorDetector",
+]

redfish_sdk/managers/update_strategies/base.py

@@ -0,0 +1,101 @@
+"""
+Base update strategy and generic (standard Redfish) fallback implementation.
+
+All vendor-specific strategies inherit from BaseUpdateStrategy and override
+the execute() method to build the vendor-appropriate request body.
+"""
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from ...models.common import RedfishResponse
+
+if TYPE_CHECKING:
+    from ...client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+
+class BaseUpdateStrategy(ABC):
+    """
+    Abstract base class for firmware update strategies.
+
+    Subclasses must implement execute() to construct the vendor-specific
+    request body and POST it to the SimpleUpdate action target.
+    """
+
+    def _discover_action_target(self, client: RedfishClient) -> str:
+        """
+        Discover the SimpleUpdate action target URL from the UpdateService.
+
+        Falls back to the standard path if the target is not found in Actions.
+        """
+        update_service = client._get_update_service()
+        raw = client._http_client.get_raw(update_service.odata_id)
+        actions = raw.get("Actions", {})
+        simple_update_action = actions.get("#UpdateService.SimpleUpdate", {})
+        target = simple_update_action.get("target")
+
+        if not target:
+            target = f"{update_service.odata_id}/Actions/UpdateService.SimpleUpdate"
+
+        return target
+
+    @abstractmethod
+    def execute(
+        self,
+        client: RedfishClient,
+        image_uri: str,
+        transfer_protocol: str = "HTTP",
+        targets: Optional[list] = None,
+        **kwargs: Any,
+    ) -> RedfishResponse:
+        """
+        Execute the firmware update.
+
+        Args:
+            client: RedfishClient instance (provides HTTP access)
+            image_uri: URI of the firmware image
+            transfer_protocol: Transfer protocol (HTTP, NFS, TFTP, etc.)
+            targets: Optional list of firmware target paths
+            **kwargs: Vendor-specific parameters
+
+        Returns:
+            RedfishResponse (may contain a task reference for async update)
+        """
+        ...
+
+
+class GenericUpdateStrategy(BaseUpdateStrategy):
+    """
+    Standard Redfish SimpleUpdate strategy (fallback).
+
+    Sends the standard body with ImageURI, TransferProtocol, and optional
+    Targets. This is equivalent to the original simple_update implementation
+    and is used when the vendor is not recognized.
+    """
+
+    def execute(
+        self,
+        client: RedfishClient,
+        image_uri: str,
+        transfer_protocol: str = "HTTP",
+        targets: Optional[list] = None,
+        **kwargs: Any,
+    ) -> RedfishResponse:
+        target = self._discover_action_target(client)
+
+        body: Dict[str, Any] = {
+            "ImageURI": image_uri,
+            "TransferProtocol": transfer_protocol,
+        }
+        if targets:
+            body["Targets"] = targets
+
+        logger.info(
+            "GenericUpdateStrategy: triggering SimpleUpdate with ImageURI=%s",
+            image_uri,
+        )
+        return client._http_client.post(target, RedfishResponse, raw_body=body)

redfish_sdk/managers/update_strategies/h3c.py

@@ -0,0 +1,140 @@
+"""
+H3C (新华三) firmware update strategy.
+
+H3C BMCs do NOT send a separate TransferProtocol field; the protocol is
+embedded in the ImageURI. For SFTP/CIFS, credentials are also embedded
+in the URI (e.g., sftp://user:pwd@host/path).
+
+Reference: UpdateService固件刷新接口 — 新华三
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Optional
+from urllib.parse import urlparse, urlunparse
+
+from ...models.common import RedfishResponse
+from .base import BaseUpdateStrategy
+
+if TYPE_CHECKING:
+    from ...client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+
+class H3cUpdateStrategy(BaseUpdateStrategy):
+    """
+    Firmware update strategy for H3C (新华三) servers.
+
+    Supported kwargs:
+        username (str): File server username -> embedded in ImageURI
+        password (str): File server password -> embedded in ImageURI
+        preserve_config (bool): True -> "Retain", False -> "Restore"
+                                Maps to Oem.Public.Preserve
+        restore_mode (str): Retain/Restore/ForceRestore -> Oem.Public.Preserve
+                            (overrides preserve_config if both are set)
+        reboot_mode (str): Auto/Manual -> Oem.Public.RebootMode
+        backup (str): Backup option -> Oem.Public.Backup
+        bios_flash (str): Flash1/Flash2/Both -> Oem.Public.BiosFlash
+        image_md5_uri (str): MD5 checksum URI -> Oem.Public.ImageMd5URI
+        delay (str): Delay duration -> Oem.Public.Date
+        upgrade_type (str): all/bios/me/microcode -> Oem.Public.UpgradeType
+    """
+
+    def execute(
+        self,
+        client: RedfishClient,
+        image_uri: str,
+        transfer_protocol: str = "HTTP",
+        targets: Optional[list] = None,
+        **kwargs: Any,
+    ) -> RedfishResponse:
+        target = self._discover_action_target(client)
+
+        # H3C embeds credentials in the URI for SFTP/CIFS
+        final_uri = self._build_uri_with_credentials(
+            image_uri,
+            transfer_protocol,
+            kwargs.get("username"),
+            kwargs.get("password"),
+        )
+
+        # H3C does NOT send TransferProtocol as a separate field
+        body: Dict[str, Any] = {
+            "ImageURI": final_uri,
+        }
+
+        # Build OEM extension
+        oem_public: Dict[str, Any] = {}
+
+        # Preserve config: restore_mode takes precedence
+        if kwargs.get("restore_mode"):
+            oem_public["Preserve"] = kwargs["restore_mode"]
+        elif "preserve_config" in kwargs:
+            oem_public["Preserve"] = "Retain" if kwargs["preserve_config"] else "Restore"
+
+        if kwargs.get("reboot_mode"):
+            oem_public["RebootMode"] = kwargs["reboot_mode"]
+        if kwargs.get("backup"):
+            oem_public["Backup"] = kwargs["backup"]
+        if kwargs.get("bios_flash"):
+            oem_public["BiosFlash"] = kwargs["bios_flash"]
+        if kwargs.get("image_md5_uri"):
+            oem_public["ImageMd5URI"] = kwargs["image_md5_uri"]
+        if kwargs.get("delay"):
+            oem_public["Date"] = kwargs["delay"]
+        if kwargs.get("upgrade_type"):
+            oem_public["UpgradeType"] = kwargs["upgrade_type"]
+
+        if oem_public:
+            body["Oem"] = {"Public": oem_public}
+
+        logger.info(
+            "H3cUpdateStrategy: triggering SimpleUpdate with ImageURI=%s",
+            final_uri,
+        )
+        return client._http_client.post(target, RedfishResponse, raw_body=body)
+
+    @staticmethod
+    def _build_uri_with_credentials(
+        image_uri: str,
+        transfer_protocol: str,
+        username: Optional[str],
+        password: Optional[str],
+    ) -> str:
+        """
+        Embed credentials into the URI for protocols that require it.
+
+        For SFTP/CIFS, H3C expects: sftp://user:pwd@host/path
+        For HTTP/TFTP/NFS, credentials are not embedded.
+        """
+        if not username:
+            return image_uri
+
+        proto_lower = transfer_protocol.lower()
+        if proto_lower not in ("sftp", "cifs"):
+            return image_uri
+
+        parsed = urlparse(image_uri)
+
+        # If credentials are already in the URI, don't override
+        if parsed.username:
+            return image_uri
+
+        # Build netloc with credentials
+        credentials = username
+        if password:
+            credentials = f"{username}:{password}"
+
+        new_netloc = f"{credentials}@{parsed.hostname}"
+        if parsed.port:
+            new_netloc = f"{new_netloc}:{parsed.port}"
+
+        return urlunparse((
+            parsed.scheme or proto_lower,
+            new_netloc,
+            parsed.path,
+            parsed.params,
+            parsed.query,
+            parsed.fragment,
+        ))

redfish_sdk/managers/update_strategies/inspur.py

@@ -0,0 +1,89 @@
+"""
+Inspur (浪潮) firmware update strategy.
+
+Inspur BMCs use heavy OEM extensions under Oem.Public, including
+FlashItem selection, BIOS update type, PFR options, and file server
+credentials in the request body.
+
+Reference: UpdateService固件刷新接口 — 浪潮
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from ...models.common import RedfishResponse
+from .base import BaseUpdateStrategy
+
+if TYPE_CHECKING:
+    from ...client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+
+class InspurUpdateStrategy(BaseUpdateStrategy):
+    """
+    Firmware update strategy for Inspur (浪潮) servers.
+
+    Supported kwargs:
+        username (str): File server username -> body.Username
+        password (str): File server password -> body.Password
+        preserve_config (bool): Preserve config -> Oem.Public.PreserveConf
+        flash_item (str): BMC/BIOS/CPLD -> Oem.Public.FlashItem
+        bios_update_type (str): FullBIOS/SeamlessBIOS -> Oem.Public.BIOSUpdateType
+        bios_flash (str): Flash1/Flash2/Both -> Oem.Public.BiosFlash
+        pfr_type (bool): PFR update toggle -> Oem.Public.PFRType
+        pfr_region (str): PFR region -> Oem.Public.PFRRegion
+        pfr_update_dynamic (bool): PFR dynamic update -> Oem.Public.PFRUpdateDynamic
+        seamless_module (str): BIOS_ONLY/ME/MICROCODE -> Oem.Public.SeamlessModule
+    """
+
+    def execute(
+        self,
+        client: RedfishClient,
+        image_uri: str,
+        transfer_protocol: str = "HTTPS",
+        targets: Optional[list] = None,
+        **kwargs: Any,
+    ) -> RedfishResponse:
+        target = self._discover_action_target(client)
+
+        body: Dict[str, Any] = {
+            "ImageURI": image_uri,
+            "TransferProtocol": transfer_protocol,
+        }
+
+        # File server credentials
+        if kwargs.get("username"):
+            body["Username"] = kwargs["username"]
+        if kwargs.get("password"):
+            body["Password"] = kwargs["password"]
+
+        # Build OEM extension
+        oem_public: Dict[str, Any] = {}
+
+        if kwargs.get("flash_item"):
+            oem_public["FlashItem"] = kwargs["flash_item"]
+        if "preserve_config" in kwargs:
+            oem_public["PreserveConf"] = bool(kwargs["preserve_config"])
+        if kwargs.get("bios_update_type"):
+            oem_public["BIOSUpdateType"] = kwargs["bios_update_type"]
+        if kwargs.get("bios_flash"):
+            oem_public["BiosFlash"] = kwargs["bios_flash"]
+        if "pfr_type" in kwargs:
+            oem_public["PFRType"] = bool(kwargs["pfr_type"])
+        if kwargs.get("pfr_region"):
+            oem_public["PFRRegion"] = kwargs["pfr_region"]
+        if "pfr_update_dynamic" in kwargs:
+            oem_public["PFRUpdateDynamic"] = bool(kwargs["pfr_update_dynamic"])
+        if kwargs.get("seamless_module"):
+            oem_public["SeamlessModule"] = kwargs["seamless_module"]
+
+        if oem_public:
+            body["Oem"] = {"Public": oem_public}
+
+        logger.info(
+            "InspurUpdateStrategy: triggering SimpleUpdate with ImageURI=%s",
+            image_uri,
+        )
+        return client._http_client.post(target, RedfishResponse, raw_body=body)

redfish_sdk/managers/update_strategies/lenovo.py

@@ -0,0 +1,59 @@
+"""
+Lenovo (联想) firmware update strategy.
+
+Lenovo BMCs are closest to standard Redfish with no OEM extensions.
+The only addition is optional Username/Password for file server auth.
+
+Reference: UpdateService固件刷新接口 — 联想
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from ...models.common import RedfishResponse
+from .base import BaseUpdateStrategy
+
+if TYPE_CHECKING:
+    from ...client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+
+class LenovoUpdateStrategy(BaseUpdateStrategy):
+    """
+    Firmware update strategy for Lenovo (联想) servers.
+
+    Supported kwargs:
+        username (str): File server username -> body.Username
+        password (str): File server password -> body.Password
+    """
+
+    def execute(
+        self,
+        client: RedfishClient,
+        image_uri: str,
+        transfer_protocol: str = "HTTPS",
+        targets: Optional[list] = None,
+        **kwargs: Any,
+    ) -> RedfishResponse:
+        target = self._discover_action_target(client)
+
+        body: Dict[str, Any] = {
+            "ImageURI": image_uri,
+            "TransferProtocol": transfer_protocol,
+        }
+        if targets:
+            body["Targets"] = targets
+
+        # Lenovo supports file server credentials
+        if kwargs.get("username"):
+            body["Username"] = kwargs["username"]
+        if kwargs.get("password"):
+            body["Password"] = kwargs["password"]
+
+        logger.info(
+            "LenovoUpdateStrategy: triggering SimpleUpdate with ImageURI=%s",
+            image_uri,
+        )
+        return client._http_client.post(target, RedfishResponse, raw_body=body)

redfish_sdk/managers/update_strategies/nettrix.py

@@ -0,0 +1,56 @@
+"""
+Nettrix (宁畅) firmware update strategy.
+
+Nettrix BMCs are closest to standard Redfish. The only extension is
+SaveConfig at the body top level (not under Oem).
+
+Reference: UpdateService固件刷新接口 — 宁畅
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from ...models.common import RedfishResponse
+from .base import BaseUpdateStrategy
+
+if TYPE_CHECKING:
+    from ...client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+
+class NettrixUpdateStrategy(BaseUpdateStrategy):
+    """
+    Firmware update strategy for Nettrix (宁畅) servers.
+
+    Supported kwargs:
+        preserve_config (bool): Preserve config -> body.SaveConfig
+    """
+
+    def execute(
+        self,
+        client: RedfishClient,
+        image_uri: str,
+        transfer_protocol: str = "HTTPS",
+        targets: Optional[list] = None,
+        **kwargs: Any,
+    ) -> RedfishResponse:
+        target = self._discover_action_target(client)
+
+        body: Dict[str, Any] = {
+            "ImageURI": image_uri,
+            "TransferProtocol": transfer_protocol,
+        }
+        if targets:
+            body["Targets"] = targets
+
+        # Nettrix puts SaveConfig at the body top level
+        if "preserve_config" in kwargs:
+            body["SaveConfig"] = bool(kwargs["preserve_config"])
+
+        logger.info(
+            "NettrixUpdateStrategy: triggering SimpleUpdate with ImageURI=%s",
+            image_uri,
+        )
+        return client._http_client.post(target, RedfishResponse, raw_body=body)