Check PowerSupply availability prop for State/Hlth

This commit makes use of the Available property on the power supply
D-Bus object when determining the power supply state and health in the
PowerSupply response.  The power supply monitor code from phosphor-power
will set the property to false if it can determine that the power supply
isn't able to provide power due to certain faults.

If the PS isn't available, then the Health property will be set to
Critical, and the State will be set to UnavailableOffline (assuming it
shouldn't be Absent instead).

This is necessary because on IBM systems the Functional property
determines the fault LED state as well as the health value, and in
certain cases the fault LED needs to stay off even though the PS health
is not OK.  A specific example of this is when the PS cord is unplugged:
no fault LED is desired but it is desired for the Redfish output to show
that there is an issue with the PS.

If the Available property isn't present on D-Bus, it acts as if it had a
value of true and behaves the same as it does today.

Tested:
Available = false:
    "Health": "Critical",
    "State": "UnavailableOffline"

Available = true, Functional = false:
    "Health": "Critical",
    "State": "Enabled"

PS missing:
    "Health": "Critical",
    "State": "Absent"

Everything OK:
    "Health": "OK",
    "State": "Enabled"

No Available property on D-Bus:
    "Health": "OK",
    "State": "Enabled"

Change-Id: I1a3194bf3a6ca3936954b31439070dcc2f343411

Signed-off-by: Matt Spinler <[email protected]>
Signed-off-by: Myung Bae <[email protected]>

Author: spinler

redfish-core/lib/power_supply.hpp

@@ -208,11 +208,12 @@ inline void getValidPowerSupplyPath(
 
 inline void getPowerSupplyState(
     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
-    const std::string& service, const std::string& path)
+    const std::string& service, const std::string& path, bool available)
 {
     dbus::utility::getProperty<bool>(
         service, path, "xyz.openbmc_project.Inventory.Item", "Present",
-        [asyncResp](const boost::system::error_code& ec, const bool value) {
+        [asyncResp,
+         available](const boost::system::error_code& ec, const bool value) {
             if (ec)
             {
                 if (ec.value() != EBADR)
@@ -229,17 +230,23 @@ inline void getPowerSupplyState(
                 asyncResp->res.jsonValue["Status"]["State"] =
                     resource::State::Absent;
             }
+            else if (!available)
+            {
+                asyncResp->res.jsonValue["Status"]["State"] =
+                    resource::State::UnavailableOffline;
+            }
         });
 }
 
 inline void getPowerSupplyHealth(
     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
-    const std::string& service, const std::string& path)
+    const std::string& service, const std::string& path, bool available)
 {
     dbus::utility::getProperty<bool>(
         service, path, "xyz.openbmc_project.State.Decorator.OperationalStatus",
         "Functional",
-        [asyncResp](const boost::system::error_code& ec, const bool value) {
+        [asyncResp,
+         available](const boost::system::error_code& ec, const bool value) {
             if (ec)
             {
                 if (ec.value() != EBADR)
@@ -251,14 +258,39 @@ inline void getPowerSupplyHealth(
                 return;
             }
 
-            if (!value)
+            if (!value || !available)
             {
                 asyncResp->res.jsonValue["Status"]["Health"] =
                     resource::Health::Critical;
             }
         });
 }
 
+inline void getPowerSupplyStateAndHealth(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const std::string& service, const std::string& path)
+{
+    dbus::utility::getProperty<bool>(
+        service, path, "xyz.openbmc_project.State.Decorator.Availability",
+        "Available",
+        [asyncResp, service,
+         path](const boost::system::error_code& ec, const bool available) {
+            if (ec)
+            {
+                if (ec.value() != EBADR)
+                {
+                    BMCWEB_LOG_ERROR("DBUS response error for Available {}",
+                                     ec.value());
+                    messages::internalError(asyncResp->res);
+                }
+                return;
+            }
+
+            getPowerSupplyState(asyncResp, service, path, available);
+            getPowerSupplyHealth(asyncResp, service, path, available);
+        });
+}
+
 inline void getPowerSupplyAsset(
     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
     const std::string& service, const std::string& path)
@@ -478,8 +510,7 @@ inline void doPowerSupplyGet(
     asyncResp->res.jsonValue["Status"]["State"] = resource::State::Enabled;
     asyncResp->res.jsonValue["Status"]["Health"] = resource::Health::OK;
 
-    getPowerSupplyState(asyncResp, service, powerSupplyPath);
-    getPowerSupplyHealth(asyncResp, service, powerSupplyPath);
+    getPowerSupplyStateAndHealth(asyncResp, service, powerSupplyPath);
     getPowerSupplyAsset(asyncResp, service, powerSupplyPath);
     getPowerSupplyFirmwareVersion(asyncResp, service, powerSupplyPath);
     getPowerSupplyLocation(asyncResp, service, powerSupplyPath);