redfish-python-sdk 1.3.0__tar.gz → 1.3.1__tar.gz

{redfish_python_sdk-1.3.0/redfish_python_sdk.egg-info → redfish_python_sdk-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redfish-python-sdk
-Version: 1.3.0
+Version: 1.3.1
 Summary: A Python SDK for interacting with Redfish-compliant BMC endpoints
 Author: RedNote Infrastructure
 License: BSD 3-Clause License

{redfish_python_sdk-1.3.0 → redfish_python_sdk-1.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "redfish-python-sdk"
-version = "1.3.0"
+version = "1.3.1"
 description = "A Python SDK for interacting with Redfish-compliant BMC endpoints"
 requires-python = ">=3.9"
 readme = "README.md"

{redfish_python_sdk-1.3.0 → redfish_python_sdk-1.3.1/redfish_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redfish-python-sdk
-Version: 1.3.0
+Version: 1.3.1
 Summary: A Python SDK for interacting with Redfish-compliant BMC endpoints
 Author: RedNote Infrastructure
 License: BSD 3-Clause License

{redfish_python_sdk-1.3.0 → redfish_python_sdk-1.3.1}/redfish_python_sdk.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ redfish_sdk/managers/update.py
 redfish_sdk/managers/log_collect_strategies/__init__.py
 redfish_sdk/managers/log_collect_strategies/base.py
 redfish_sdk/managers/log_collect_strategies/enginetech.py
+redfish_sdk/managers/log_collect_strategies/h3c.py
 redfish_sdk/managers/log_collect_strategies/inspur.py
 redfish_sdk/managers/log_collect_strategies/lenovo.py
 redfish_sdk/managers/log_collect_strategies/registry.py
@@ -88,6 +89,7 @@ tests/test_action_models.py
 tests/test_chassis_discovery.py
 tests/test_client_mock.py
 tests/test_composition_mock.py
+tests/test_event_headers_mock.py
 tests/test_exception_hints_mock.py
 tests/test_firmware_upload_mock.py
 tests/test_http_retry_mock.py

{redfish_python_sdk-1.3.0 → redfish_python_sdk-1.3.1}/redfish_sdk/__init__.py

@@ -68,7 +68,7 @@ from .models.systems import BootOption
 from .models.telemetry import MetricDefinition, MetricReport, MetricReportDefinition, TelemetryService, Triggers
 from .models.update import FirmwareUpdateResponse
 
-__version__ = "1.3.0"
+__version__ = "1.3.1"
 __author__ = "RedNote Infrastructure"
 
 __all__ = [

{redfish_python_sdk-1.3.0 → redfish_python_sdk-1.3.1}/redfish_sdk/client.py

@@ -1653,8 +1653,8 @@ class RedfishClient:
             context: Optional context string identifying the subscription.
             protocol: Wire protocol; defaults to ``"Redfish"``.
             http_headers: Optional headers to send on the callback POST.
-                Pass either a ``dict`` or a ``list[dict]`` — both forms are
-                commonly seen across BMC vendors.
+                Pass a ``dict`` or a ``list[dict]``. Dictionaries are converted
+                to the standard array form; ``raw_body`` preserves vendor forms.
             origin_resources: Optional list of ``{"@odata.id": "..."}``.
             subscription_type: Optional ``SubscriptionType`` value.
             registry_prefixes: Optional message-registry filter list.

{redfish_python_sdk-1.3.0 → redfish_python_sdk-1.3.1}/redfish_sdk/http_client.py

@@ -307,8 +307,17 @@ class RedfishHttpClient:
         except Exception:
             pass
 
-        logger.error("Request failed: %s %s -> HTTP %d, body: %s",
-                     response.request.method, path, code, body[:500])
+        # 404 ("not found") is routinely an expected outcome handled by callers
+        # via fallback (e.g. Chassis/1 -> Chassis/Self) or treated as "absent"
+        # (e.g. optional sub-resources). Logging it at ERROR produces alarming
+        # noise for what is normal control flow, so it is recorded at DEBUG only.
+        # All other non-2xx responses remain at ERROR.
+        if code == 404:
+            logger.debug("Request returned 404 (not found): %s %s",
+                         response.request.method, path)
+        else:
+            logger.error("Request failed: %s %s -> HTTP %d, body: %s",
+                         response.request.method, path, code, body[:500])
 
         if code in (401, 403):
             raise RedfishAuthError(code)

{redfish_python_sdk-1.3.0 → redfish_python_sdk-1.3.1}/redfish_sdk/managers/chassis.py

@@ -197,7 +197,20 @@ class ChassisManager:
         """
         chassis = self.get(chassis_id)
 
-        # Strategy 1: Use Chassis.Links.Drives
+        # Strategy 1: Chassis.Drives (canonical chassis-owned drive collection).
+        # Preferred because some BMCs expose the authoritative Drive resources
+        # (with fields such as IndicatorLED) only here, while Chassis.Links.Drives
+        # may resolve to Storage-side Drive references that lack those fields.
+        if chassis.drives:
+            try:
+                drives = self._client._get_collection(chassis.drives.odata_id, Drive)
+                if drives:
+                    return drives
+            except RedfishException as exc:
+                logger.warning("Chassis.Drives collection failed: %s", exc)
+
+        # Strategy 2: Chassis.Links.Drives (links may resolve to Storage-side
+        # Drive resources). Kept as fallback for BMCs that only populate links.
         if chassis.links and chassis.links.drives:
             drive_links = chassis.links.drives
             if drive_links:
@@ -223,13 +236,6 @@ class ChassisManager:
                 if result:
                     return result
 
-        # Strategy 2: Use Chassis.Drives collection endpoint
-        if chassis.drives:
-            try:
-                return self._client._get_collection(chassis.drives.odata_id, Drive)
-            except RedfishException as exc:
-                logger.warning("Chassis.Drives collection failed: %s", exc)
-
         return []
 
     def network_adapters(self, chassis_id: Optional[str] = None) -> List[NetworkAdapter]:

{redfish_python_sdk-1.3.0 → redfish_python_sdk-1.3.1}/redfish_sdk/managers/event.py

@@ -135,7 +135,8 @@ class EventServiceManager:
             protocol: Wire protocol; defaults to ``"Redfish"``.
             http_headers: Optional headers to be sent on the callback POST.
                 Pass a ``dict`` (``{"X-Auth-Token": "..."}``) or a
-                ``list[dict]`` — both forms are common across BMC vendors.
+                ``list[dict]``. Dictionaries are serialized as the standard
+                array of header objects. Use ``raw_body`` for vendor shapes.
             origin_resources: Optional list of ``{"@odata.id": "..."}``
                 filtering the resources of interest.
             subscription_type: Optional ``SubscriptionType`` value
@@ -167,7 +168,9 @@ class EventServiceManager:
             if context is not None:
                 body["Context"] = context
             if http_headers is not None:
-                body["HttpHeaders"] = http_headers
+                body["HttpHeaders"] = (
+                    [http_headers] if isinstance(http_headers, dict) else http_headers
+                )
             if origin_resources is not None:
                 body["OriginResources"] = origin_resources
             if subscription_type is not None:

{redfish_python_sdk-1.3.0 → redfish_python_sdk-1.3.1}/redfish_sdk/managers/log_collect_strategies/__init__.py

@@ -10,13 +10,17 @@ Architecture:
     BaseLogCollectStrategy (ABC)
       ├── GenericLogCollectStrategy       — standard Redfish (DMTF) default
       ├── XFusionLogCollectStrategy       — xFusion (超聚变), OEM diagnostic body
+      ├── H3cLogCollectStrategy           — H3C (新华三), Manager.Dump +
+                                            Manager.GeneralDownload SDS flow
       ├── InspurLogCollectStrategy        — Inspur (浪潮), collection-level
                                             CollectAllLog / DownloadAllLog pair
+      │   └── IeitLogCollectStrategy  — IEIT SYSTEMS, member actions +
+                                            in-flight Task reuse
       ├── LenovoLogCollectStrategy        — Lenovo (联想, AMI-based),
                                             CollectAllLog + private
                                             CollectProgress + DownloadAllLog
       ├── ZteLogCollectStrategy           — ZTE (中兴), Dump + Dump/Progress +
-                                            GeneralDownload
+                                            ExportLogs
       └── SmoothcomputeLogCollectStrategy — smoothcompute (顺算), OEM
                                             DiagnosticService.CollectBlackBox /
                                             ExportBlackBox (trigger returns a
@@ -25,7 +29,7 @@ Architecture:
 
 Only vendors that genuinely differ from the standard DMTF behaviour get a
 dedicated strategy. Vendors whose ``CollectDiagnosticData`` matches the
-standard body (e.g. Lenovo, Nettrix) intentionally have no file and fall back
+standard body (e.g. Nettrix) intentionally have no file and fall back
 to :class:`GenericLogCollectStrategy` via the registry.
 
 Vendor detection is shared with the firmware ``update_strategies`` package
@@ -37,7 +41,8 @@ All strategies are auto-registered when this package is imported.
 from ..update_strategies.vendor_detect import VendorDetector
 from .base import BaseLogCollectStrategy, GenericLogCollectStrategy
 from .enginetech import EnginetechLogCollectStrategy
-from .inspur import InspurLogCollectStrategy
+from .h3c import H3cLogCollectStrategy
+from .inspur import IeitLogCollectStrategy, InspurLogCollectStrategy
 from .lenovo import LenovoLogCollectStrategy
 from .registry import LogCollectStrategyRegistry
 from .smoothcompute import SmoothcomputeLogCollectStrategy
@@ -48,7 +53,9 @@ from .zte import ZteLogCollectStrategy
 LogCollectStrategyRegistry.register("generic", GenericLogCollectStrategy())
 LogCollectStrategyRegistry.register("enginetech", EnginetechLogCollectStrategy())
 LogCollectStrategyRegistry.register("xfusion", XFusionLogCollectStrategy())
+LogCollectStrategyRegistry.register("h3c", H3cLogCollectStrategy())
 LogCollectStrategyRegistry.register("inspur", InspurLogCollectStrategy())
+LogCollectStrategyRegistry.register("ieit", IeitLogCollectStrategy())
 LogCollectStrategyRegistry.register("lenovo", LenovoLogCollectStrategy())
 LogCollectStrategyRegistry.register("zte", ZteLogCollectStrategy())
 LogCollectStrategyRegistry.register(
@@ -60,6 +67,8 @@ __all__ = [
     "GenericLogCollectStrategy",
     "EnginetechLogCollectStrategy",
     "XFusionLogCollectStrategy",
+    "H3cLogCollectStrategy",
+    "IeitLogCollectStrategy",
     "InspurLogCollectStrategy",
     "LenovoLogCollectStrategy",
     "ZteLogCollectStrategy",

redfish_python_sdk-1.3.1/redfish_sdk/managers/log_collect_strategies/h3c.py

@@ -0,0 +1,212 @@
+"""H3C (新华三) SDS diagnostic-log collection strategy.
+
+H3C HDM does not expose the standard per-LogService
+``#LogService.CollectDiagnosticData`` action.  The Manager instead publishes
+OEM ``Manager.Dump`` and ``Manager.GeneralDownload`` actions.  Collection
+creates an asynchronous Redfish Task; after it completes, the SDS archive is
+downloaded with a second POST.
+
+Observed on H3C HDM firmware 2.09, ``#Manager.GeneralDownload`` is advertised
+as an empty object without a ``target``.  For that specific malformed action
+descriptor, this strategy derives the conventional action URI from the
+advertised Manager resource rather than treating an unadvertised action as
+available.
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from ...models.common import Collection, Link
+from ...models.managers import Manager
+from ...models.task import Task
+from .base import BaseLogCollectStrategy
+
+if TYPE_CHECKING:
+    from ...client import RedfishClient
+
+logger = logging.getLogger(__name__)
+
+_DUMP_ACTION = "#Manager.Dump"
+_DOWNLOAD_ACTION = "#Manager.GeneralDownload"
+_SDS_PATH = "/mnt/sdmmc0p1/sds/bmc/dump.tar.gz"
+
+
+class H3cLogCollectStrategy(BaseLogCollectStrategy):
+    """Collect and download H3C SDS bundles through Manager OEM actions."""
+
+    def find_existing_task(
+        self,
+        client: "RedfishClient",
+        log_services_odata_id: str,
+        manager_id: Optional[str] = None,
+    ) -> Optional[Task]:
+        """Always create a fresh SDS bundle at H3C's fixed artifact path."""
+        return None
+
+    def discover_collect_target(
+        self,
+        client: "RedfishClient",
+        log_services_odata_id: str,
+        log_id: Optional[str],
+    ) -> Optional[str]:
+        """Return the Manager-level ``Manager.Dump`` action target."""
+        manager = self._manager_for_log_services(client, log_services_odata_id)
+        advertised, target = self._manager_oem_action(manager, _DUMP_ACTION)
+        return target if advertised else None
+
+    def build_collect_body(
+        self,
+        diagnostic_data_type: Optional[str] = None,
+        oem_params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Build H3C's request for generating an SDS archive on the BMC."""
+        body: Dict[str, Any] = {
+            "Type": "URI",
+            "Content": _SDS_PATH,
+        }
+        if diagnostic_data_type:
+            body["LogType"] = diagnostic_data_type
+        if oem_params:
+            body.update(oem_params)
+        return body
+
+    def trigger(
+        self,
+        client: "RedfishClient",
+        log_services_odata_id: str,
+        *,
+        log_id: Optional[str] = None,
+        diagnostic_data_type: Optional[str] = None,
+        oem_params: Optional[Dict[str, Any]] = None,
+        manager_id: Optional[str] = None,
+    ) -> Task:
+        """POST ``Manager.Dump`` and convert its task collection response."""
+        from ...exceptions import RedfishValidationError
+
+        manager = self._manager_for_log_services(client, log_services_odata_id)
+        advertised, target = self._manager_oem_action(manager, _DUMP_ACTION)
+        if not advertised or not target:
+            raise RedfishValidationError(
+                f"H3C Manager {manager.odata_id!r} does not expose "
+                f"{_DUMP_ACTION} with an action target"
+            )
+
+        body = self.build_collect_body(diagnostic_data_type, oem_params)
+        logger.info("H3C Manager.Dump POST %s body=%s", target, body)
+        response = client._http_client.post(
+            target, Collection[Link], raw_body=body
+        )
+
+        task_url = next(
+            (
+                member.odata_id
+                for member in response.members or []
+                if member.odata_id
+            ),
+            None,
+        )
+        if not task_url and response.odata_id and "/Tasks/" in response.odata_id:
+            task_url = response.odata_id
+        if not task_url:
+            raise RedfishValidationError(
+                "H3C Manager.Dump did not return a Redfish Task reference"
+            )
+
+        return Task.model_construct(
+            id=task_url.rstrip("/").rsplit("/", 1)[-1],
+            odata_id=task_url,
+            _h3c_manager_id=self._manager_id(manager),
+        )
+
+    def wait_until_ready(
+        self,
+        client: "RedfishClient",
+        task: Task,
+        poll_interval: int = 5,
+        timeout: int = 1800,
+    ) -> Task:
+        """Wait through TaskService while retaining the owning Manager id."""
+        finished = super().wait_until_ready(
+            client, task, poll_interval=poll_interval, timeout=timeout
+        )
+        manager_id = getattr(task, "_h3c_manager_id", None)
+        if manager_id:
+            finished = finished.model_copy(
+                update={"_h3c_manager_id": manager_id}
+            )
+        return finished
+
+    def download_artifact(
+        self,
+        client: "RedfishClient",
+        task: Task,
+        output_path: Optional[str] = None,
+    ) -> "bytes | str":
+        """POST ``Manager.GeneralDownload`` and save the returned archive."""
+        from ...exceptions import RedfishValidationError
+
+        manager_id = getattr(task, "_h3c_manager_id", None)
+        manager = client.get_manager(manager_id)
+        advertised, target = self._manager_oem_action(
+            manager, _DOWNLOAD_ACTION
+        )
+        if not advertised:
+            raise RedfishValidationError(
+                f"H3C Manager {manager.odata_id!r} does not advertise "
+                f"{_DOWNLOAD_ACTION}"
+            )
+        if not target and manager.odata_id:
+            target = (
+                f"{manager.odata_id.rstrip('/')}"
+                "/Actions/Oem/Public/Manager.GeneralDownload"
+            )
+        if not target:
+            raise RedfishValidationError(
+                f"Could not resolve {_DOWNLOAD_ACTION} for H3C Manager"
+            )
+
+        body = {
+            "TransferProtocol": "HTTPS",
+            "Content": _SDS_PATH,
+        }
+        logger.info("H3C Manager.GeneralDownload POST %s", target)
+        return client._http_client.download_via_post(
+            target, output_path, raw_body=body
+        )
+
+    @staticmethod
+    def _manager_for_log_services(
+        client: "RedfishClient", log_services_odata_id: str
+    ) -> Manager:
+        """Resolve the Manager owning an advertised LogServices collection."""
+        suffix = "/LogServices"
+        manager_url = log_services_odata_id.rstrip("/")
+        if manager_url.endswith(suffix):
+            manager_url = manager_url[: -len(suffix)]
+        manager_id = manager_url.rstrip("/").rsplit("/", 1)[-1]
+        return client.get_manager(manager_id)
+
+    @staticmethod
+    def _manager_id(manager: Manager) -> Optional[str]:
+        if manager.odata_id:
+            return manager.odata_id.rstrip("/").rsplit("/", 1)[-1]
+        return str(manager.id) if manager.id is not None else None
+
+    @staticmethod
+    def _manager_oem_action(
+        manager: Manager, action_name: str
+    ) -> tuple[bool, Optional[str]]:
+        """Return whether an H3C OEM action is advertised and its target."""
+        if manager.actions is None:
+            return False, None
+        actions = manager.actions.model_dump(by_alias=True, exclude_none=True)
+        oem = actions.get("Oem")
+        public = oem.get("Public") if isinstance(oem, dict) else None
+        if not isinstance(public, dict) or action_name not in public:
+            return False, None
+        descriptor = public[action_name]
+        if not isinstance(descriptor, dict):
+            return True, None
+        target = descriptor.get("target")
+        return True, target if isinstance(target, str) and target else None