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

redfish_sdk/managers/update_strategies/registry.py

@@ -0,0 +1,72 @@
+"""
+Update strategy registry — maps vendor keys to strategy instances.
+
+Strategies are registered at import time via register(). The registry
+provides a get() method that returns the appropriate strategy for a
+given vendor, falling back to GenericUpdateStrategy for unknown vendors.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Dict
+
+from .base import BaseUpdateStrategy, GenericUpdateStrategy
+
+logger = logging.getLogger(__name__)
+
+# Singleton fallback strategy
+_GENERIC_STRATEGY = GenericUpdateStrategy()
+
+
+class UpdateStrategyRegistry:
+    """
+    Registry mapping vendor keys to update strategy instances.
+
+    Usage:
+        # Registration (done at module import time)
+        UpdateStrategyRegistry.register("inspur", InspurUpdateStrategy())
+
+        # Lookup
+        strategy = UpdateStrategyRegistry.get("inspur")
+        response = strategy.execute(client, image_uri, ...)
+    """
+
+    _strategies: Dict[str, BaseUpdateStrategy] = {}
+
+    @classmethod
+    def register(cls, vendor: str, strategy: BaseUpdateStrategy) -> None:
+        """
+        Register a strategy for a vendor.
+
+        Args:
+            vendor: Canonical vendor key (lowercase, e.g., "inspur")
+            strategy: Strategy instance
+        """
+        cls._strategies[vendor.lower()] = strategy
+        logger.debug("Registered update strategy for vendor: %s", vendor)
+
+    @classmethod
+    def get(cls, vendor: str) -> BaseUpdateStrategy:
+        """
+        Get the update strategy for a vendor.
+
+        Args:
+            vendor: Vendor key (case-insensitive)
+
+        Returns:
+            Registered strategy, or GenericUpdateStrategy as fallback
+        """
+        strategy = cls._strategies.get(vendor.lower())
+        if strategy is None:
+            logger.warning(
+                "No update strategy registered for vendor '%s', "
+                "using generic Redfish strategy",
+                vendor,
+            )
+            return _GENERIC_STRATEGY
+        return strategy
+
+    @classmethod
+    def registered_vendors(cls) -> list:
+        """Return the list of registered vendor keys."""
+        return list(cls._strategies.keys())

redfish_sdk/managers/update_strategies/vendor_detect.py

@@ -0,0 +1,111 @@
+"""
+Vendor detection for automatic update strategy routing.
+
+Detects the server vendor at runtime by inspecting the System resource's
+Manufacturer field, falling back to OEM key detection.
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Dict, List
+
+if TYPE_CHECKING:
+    from ...client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+# Canonical vendor key -> list of known manufacturer substrings (lowercase)
+_VENDOR_KEYWORDS: Dict[str, List[str]] = {
+    "inspur": ["inspur", "浪潮", "maginfra"],
+    "zte": ["zte", "中兴"],
+    "h3c": ["h3c", "新华三", "h3c servers"],
+    "nettrix": ["nettrix", "宁畅"],
+    "xfusion": ["xfusion", "超聚变", "huawei"],
+    "lenovo": ["lenovo", "联想"],
+}
+
+
+class VendorDetector:
+    """
+    Detects the server vendor from the Redfish System resource.
+
+    Detection order:
+    1. System.Manufacturer field (primary)
+    2. OEM key names in the System resource (fallback)
+
+    Results are cached per client instance to avoid repeated HTTP calls.
+    """
+
+    # Cache: client id -> detected vendor string
+    _cache: Dict[int, str] = {}
+
+    @classmethod
+    def detect(cls, client: RedfishClient) -> str:
+        """
+        Detect the server vendor for the given client.
+
+        Args:
+            client: RedfishClient instance
+
+        Returns:
+            Canonical vendor key (e.g., "inspur", "zte") or "generic"
+        """
+        client_id = id(client)
+        if client_id in cls._cache:
+            return cls._cache[client_id]
+
+        vendor = cls._detect_from_system(client)
+        cls._cache[client_id] = vendor
+
+        if vendor == "generic":
+            logger.warning(
+                "Could not detect server vendor, falling back to generic strategy"
+            )
+        else:
+            logger.info("Detected server vendor: %s", vendor)
+
+        return vendor
+
+    @classmethod
+    def _detect_from_system(cls, client: RedfishClient) -> str:
+        """Attempt detection from System.Manufacturer."""
+        try:
+            system = client.get_system()
+            manufacturer = (system.manufacturer or "").lower().strip()
+
+            if manufacturer:
+                for vendor_key, keywords in _VENDOR_KEYWORDS.items():
+                    for keyword in keywords:
+                        if keyword.lower() in manufacturer:
+                            return vendor_key
+
+            # Fallback: check OEM keys in the raw system response
+            return cls._detect_from_oem_keys(client)
+        except Exception:
+            logger.debug("Vendor detection from System failed, trying OEM keys")
+            return cls._detect_from_oem_keys(client)
+
+    @classmethod
+    def _detect_from_oem_keys(cls, client: RedfishClient) -> str:
+        """Fallback: detect vendor from OEM key names in System resource."""
+        try:
+            system = client.get_system()
+            if system.oem and system.oem.model_extra:
+                extra_keys = {k.lower() for k in system.oem.model_extra.keys()}
+                if "lenovo" in extra_keys:
+                    return "lenovo"
+                if "xfusion" in extra_keys:
+                    return "xfusion"
+                if "hpe" in extra_keys or "hp" in extra_keys:
+                    return "generic"  # HPE not adapted yet
+                if "dell" in extra_keys:
+                    return "generic"  # Dell not adapted yet
+        except Exception:
+            logger.debug("Vendor detection from OEM keys failed")
+
+        return "generic"
+
+    @classmethod
+    def clear_cache(cls) -> None:
+        """Clear the vendor detection cache."""
+        cls._cache.clear()

redfish_sdk/managers/update_strategies/xfusion.py

@@ -0,0 +1,60 @@
+"""
+xFusion (超聚变) firmware update strategy.
+
+xFusion BMCs place extension fields at the body top level (not under Oem),
+including PreserveConfig, ActiveMode, and ModuleArray for PSU updates.
+
+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 XFusionUpdateStrategy(BaseUpdateStrategy):
+    """
+    Firmware update strategy for xFusion (超聚变) servers.
+
+    Supported kwargs:
+        preserve_config (bool): Preserve config -> body.PreserveConfig
+        active_mode (str): Immediately/ResetBMC -> body.ActiveMode
+        module_array (list): PSU module names -> body.ModuleArray
+    """
+
+    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,
+        }
+
+        # xFusion puts extension fields at body top level
+        if "preserve_config" in kwargs:
+            body["PreserveConfig"] = bool(kwargs["preserve_config"])
+        if kwargs.get("active_mode"):
+            body["ActiveMode"] = kwargs["active_mode"]
+        if kwargs.get("module_array"):
+            body["ModuleArray"] = kwargs["module_array"]
+
+        logger.info(
+            "XFusionUpdateStrategy: triggering SimpleUpdate with ImageURI=%s",
+            image_uri,
+        )
+        return client._http_client.post(target, RedfishResponse, raw_body=body)

redfish_sdk/managers/update_strategies/zte.py

@@ -0,0 +1,68 @@
+"""
+ZTE (中兴) firmware update strategy.
+
+ZTE BMCs extend SimpleUpdate with OEM fields under Oem.Public for
+BMC/BIOS flash selection, config preservation, and apply time.
+
+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 ZteUpdateStrategy(BaseUpdateStrategy):
+    """
+    Firmware update strategy for ZTE (中兴) servers.
+
+    Supported kwargs:
+        preserve_config (bool): Preserve config -> Oem.Public.PreserveConf
+        bmc_flash (str): Flash1/Flash2/Both -> Oem.Public.BMCFlash
+        bios_flash (str): Flash1/Flash2/Both -> Oem.Public.BiosFlash
+        apply_time (str): Immediate/OnReset -> Oem.Public.ApplyTime
+    """
+
+    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,
+        }
+
+        # Build OEM extension
+        oem_public: Dict[str, Any] = {}
+
+        if "preserve_config" in kwargs:
+            oem_public["PreserveConf"] = bool(kwargs["preserve_config"])
+        if kwargs.get("bmc_flash"):
+            oem_public["BMCFlash"] = kwargs["bmc_flash"]
+        if kwargs.get("bios_flash"):
+            oem_public["BiosFlash"] = kwargs["bios_flash"]
+        if kwargs.get("apply_time"):
+            oem_public["ApplyTime"] = kwargs["apply_time"]
+
+        if oem_public:
+            body["Oem"] = {"Public": oem_public}
+
+        logger.info(
+            "ZteUpdateStrategy: triggering SimpleUpdate with ImageURI=%s",
+            image_uri,
+        )
+        return client._http_client.post(target, RedfishResponse, raw_body=body)

redfish_sdk/models/__init__.py

@@ -0,0 +1,55 @@
+from .account import Account, AccountService, Role
+from .chassis import Chassis, Drive, Fan, NetworkAdapter, PCIeDevice, Power, PowerSupply, Temperature, Thermal
+from .common import Collection, Entity, Link, RedfishError, RedfishResponse, Status
+from .drive import Location  # noqa: F401
+from .event import EventService, Subscription
+from .fru import Fru, FruChassis, FruProduct
+from .logs import Log, LogEntry
+from .managers import EthernetInterface, HostInterface, Manager, NetworkProtocol
+from .memory import MemoryLocation  # noqa: F401
+from .network_adapter import Controller, ControllerCapabilities  # noqa: F401
+from .oem import Bmc, MainBoard, Oem
+from .pcie_device import (  # noqa: F401
+    GpuCore,
+    GpuPerformanceParameters,
+    PCIeDeviceOEM,
+    PCIeDeviceOEMPublic,
+    PCIeInterface,
+)
+from .power import InputRange, PowerControl, Voltage  # noqa: F401
+
+# Additional component models (also available via individual modules)
+from .processor import ProcessorId  # noqa: F401
+from .registry import Registry
+from .root import RootService
+from .session import Session, SessionService
+from .storage import CacheSummary, Identifier, StorageController  # noqa: F401
+from .systems import Bios, Boot, Gpu, GpuOEM, Memory, Processor, Storage, System, Volume
+from .task import Task, TaskService
+from .thermal import HistoricalInletTempEntry, InletHistoryTemperature, Redundancy  # noqa: F401
+from .update import ClientCertificate, FirmwareInventory, UpdateService
+
+__all__ = [
+    "Link", "Entity", "Collection", "Status", "RedfishResponse", "RedfishError",
+    "RootService",
+    "System", "Processor", "Memory", "Storage", "Volume", "Bios", "Boot", "Gpu", "GpuOEM",
+    "Chassis", "Drive", "NetworkAdapter", "Power", "PowerSupply", "Thermal",
+    "PCIeDevice", "Fan", "Temperature",
+    "Manager", "NetworkProtocol", "EthernetInterface", "HostInterface",
+    "AccountService", "Account", "Role",
+    "SessionService", "Session",
+    "EventService", "Subscription",
+    "UpdateService", "FirmwareInventory", "ClientCertificate",
+    "Registry",
+    "TaskService", "Task",
+    "Oem", "Bmc", "MainBoard",
+    "Log", "LogEntry",
+    "Fru", "FruChassis", "FruProduct",
+    # Additional component models
+    "ProcessorId", "MemoryLocation", "StorageController", "CacheSummary", "Identifier",
+    "Location", "Controller", "ControllerCapabilities",
+    "PCIeInterface", "PCIeDeviceOEM", "PCIeDeviceOEMPublic",
+    "GpuCore", "GpuPerformanceParameters",
+    "PowerControl", "Voltage", "InputRange", "Redundancy",
+    "InletHistoryTemperature", "HistoricalInletTempEntry",
+]

redfish_sdk/models/account.py

@@ -0,0 +1,60 @@
+"""
+Account service models.
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import Field
+
+from .common import Entity, Link, Status
+from .oem import Oem
+
+
+class AccountService(Entity):
+    """
+    The Account service provides user account management.
+    Endpoint: /redfish/v1/AccountService
+    """
+    accounts: Optional[Link] = Field(None, alias="Accounts")
+    roles: Optional[Link] = Field(None, alias="Roles")
+    auth_failure_logging_threshold: Optional[int] = Field(
+        None, alias="AuthFailureLoggingThreshold"
+    )
+    max_password_length: Optional[int] = Field(None, alias="MaxPasswordLength")
+    min_password_length: Optional[int] = Field(None, alias="MinPasswordLength")
+    account_lockout_threshold: Optional[int] = Field(None, alias="AccountLockoutThreshold")
+    account_lockout_duration: Optional[int] = Field(None, alias="AccountLockoutDuration")
+    service_enabled: Optional[bool] = Field(None, alias="ServiceEnabled")
+    status: Optional[Status] = Field(None, alias="Status")
+
+
+class Account(Entity):
+    """
+    Represents a user account on the BMC.
+    Endpoint: /redfish/v1/AccountService/Accounts/{accountId}
+
+    """
+    account_types: Optional[List[str]] = Field(None, alias="AccountTypes")
+    certificates: Optional[Link] = Field(None, alias="Certificates")
+    email_address: Optional[str] = Field(None, alias="EmailAddress")
+    enabled: Optional[bool] = Field(None, alias="Enabled")
+    locked: Optional[bool] = Field(None, alias="Locked")
+    password: Optional[str] = Field(None, alias="Password")
+    password_change_required: Optional[bool] = Field(None, alias="PasswordChangeRequired")
+    phone_number: Optional[str] = Field(None, alias="PhoneNumber")
+    role_id: Optional[str] = Field(None, alias="RoleId")
+    user_name: Optional[str] = Field(None, alias="UserName")
+    oem: Optional[Oem] = Field(None, alias="Oem")
+
+
+class Role(Entity):
+    """
+    Represents an account role with associated privileges.
+    Endpoint: /redfish/v1/AccountService/Roles/{roleId}
+    """
+    assigned_privileges: Optional[List[str]] = Field(None, alias="AssignedPrivileges")
+    is_predefined: Optional[bool] = Field(None, alias="IsPredefined")
+    oem_privileges: Optional[List[str]] = Field(None, alias="OemPrivileges")
+    role_id: Optional[str] = Field(None, alias="RoleId")
+    status: Optional[Status] = Field(None, alias="Status")

redfish_sdk/models/chassis.py

@@ -0,0 +1,86 @@
+"""
+Chassis resource models.
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .common import Entity, Link, Status
+from .drive import Drive, Location  # noqa: F401
+from .network_adapter import (  # noqa: F401
+    NPAR,
+    Controller,
+    ControllerCapabilities,
+    DataCenterBridging,
+    NetworkAdapter,
+    VirtualFunction,
+    VirtualizationOffload,
+)
+from .oem import Oem
+from .pcie_device import (  # noqa: F401
+    GpuCore,
+    GpuPerformanceParameters,
+    PCIeDevice,
+    PCIeDeviceOEM,
+    PCIeDeviceOEMPublic,
+    PCIeInterface,
+)
+from .power import (  # noqa: F401
+    InputRange,
+    Power,
+    PowerControl,
+    PowerSupply,
+    Voltage,
+)
+
+# ---------------------------------------------------------------------------
+# Re-export component models for backward compatibility
+# ---------------------------------------------------------------------------
+from .thermal import Fan, Redundancy, Temperature, Thermal  # noqa: F401
+
+# ---------------------------------------------------------------------------
+# Chassis
+# ---------------------------------------------------------------------------
+
+class ChassisLinks(BaseModel):
+    """Links section within a Chassis resource."""
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+    drives: Optional[List[Link]] = Field(None, alias="Drives")
+    pcie_devices: Optional[List[Link]] = Field(None, alias="PCIeDevices")
+    managed_by: Optional[List[Link]] = Field(None, alias="ManagedBy")
+    contains: Optional[List[Link]] = Field(None, alias="Contains")
+    contained_by: Optional[Link] = Field(None, alias="ContainedBy")
+    computer_systems: Optional[List[Link]] = Field(None, alias="ComputerSystems")
+
+
+class Chassis(Entity):
+    """
+    Represents a physical chassis (server enclosure).
+    Endpoint: /redfish/v1/Chassis/{chassisId}
+
+    """
+    uuid: Optional[str] = Field(None, alias="UUID")
+    links: Optional[ChassisLinks] = Field(None, alias="Links")
+    asset_tag: Optional[str] = Field(None, alias="AssetTag")
+    chassis_type: Optional[str] = Field(None, alias="ChassisType")
+    depth_mm: Optional[float] = Field(None, alias="DepthMm")
+    height_mm: Optional[float] = Field(None, alias="HeightMm")
+    indicator_led: Optional[str] = Field(None, alias="IndicatorLED")
+    manufacturer: Optional[str] = Field(None, alias="Manufacturer")
+    model: Optional[str] = Field(None, alias="Model")
+    drives: Optional[Link] = Field(None, alias="Drives")
+    part_number: Optional[str] = Field(None, alias="PartNumber")
+    power: Optional[Link] = Field(None, alias="Power")
+    power_state: Optional[str] = Field(None, alias="PowerState")
+    sku: Optional[str] = Field(None, alias="SKU")
+    serial_number: Optional[str] = Field(None, alias="SerialNumber")
+    status: Optional[Status] = Field(None, alias="Status")
+    thermal: Optional[Link] = Field(None, alias="Thermal")
+    weight_kg: Optional[float] = Field(None, alias="WeightKg")
+    width_mm: Optional[float] = Field(None, alias="WidthMm")
+    pcie_devices: Optional[Link] = Field(None, alias="PCIeDevices")
+    network_adapters: Optional[Link] = Field(None, alias="NetworkAdapters")
+    sensors: Optional[Link] = Field(None, alias="Sensors")
+    oem: Optional[Oem] = Field(None, alias="Oem")