RBMC: Put Failover interface on D-Bus

Create an instance of the xyz.openbmc_project.Control.Failover interface
on the /xyz/openbmc_project/state/bmc0 path.  Its 'StartFailover' method
will be used to start a failover.

If at any time a failover can't be done the method will return the
'Unavailable' D-Bus error.  In this commit, that's all it does to start
with.

The interface is always on D-Bus, regardless of the BMC's role, because:
1. Failovers need to be triggered from both active and passive BMCs.
2. The FailoverInProgress property spans BMC roles. It gets set to true
   while the BMC is passive and stays that way until a bit after the BMC
   goes to active.

The main driver of the failover will be the passive BMC, so if called on
the active BMC the command would need to propagate to the passive BMC.

Tested:
```
$ busctl introspect xyz.openbmc_project.State.BMC.Redundancy /xyz/openbmc_project/state/bmc0
NAME                                     TYPE      SIGNATURE RESULT/VALUE                             FLAGS
...
xyz.openbmc_project.Control.Failover     interface -         -                                        -
.StartFailover                           method    a{sv}     -                                        -
.FailoverInProgress                      property  b         false                                    emits-change
...
```

Call it:
```
$ busctl call xyz.openbmc_project.State.BMC.Redundancy \
/xyz/openbmc_project/state/bmc0 \
xyz.openbmc_project.Control.Failover StartFailover a{sv} 0

Call failed: The service is temporarily unavailable.
```

Change-Id: I5f9cfd83d90d10dfc22f191f3d85756aa2614af5
Signed-off-by: Matt Spinler <[email protected]>

Author: spinler

redundant-bmc/src/manager.cpp

@@ -11,8 +11,14 @@
 namespace rbmc
 {
 
+const std::string failoverPath =
+    std::string{RedundancyInterface::namespace_path::value} + '/' +
+    RedundancyInterface::namespace_path::bmc;
+
 Manager::Manager(sdbusplus::async::context& ctx,
                  std::unique_ptr<Providers>&& providers) :
+    sdbusplus::aserver::xyz::openbmc_project::control::Failover<Manager>(
+        ctx, failoverPath.c_str()),
     ctx(ctx), redundancyInterface(ctx, *this), providers(std::move(providers))
 {
     try
@@ -42,6 +48,9 @@ Manager::Manager(sdbusplus::async::context& ctx,
                    "ERROR", e);
     }
 
+    // emit the Failover interfaces added signal
+    emit_added();
+
     ctx.spawn(startup());
 }
 
@@ -267,4 +276,13 @@ void Manager::disableRedPropChanged(bool disable)
     handler->disableRedPropChanged(disable);
 }
 
+// NOLINTNEXTLINE
+sdbusplus::async::task<> Manager::method_call(
+    start_failover_t /* unused */, const FailoverOptions& /* options */)
+{
+    // TODO: Implement the failover
+    lg2::error("Failovers are not implemented yet");
+    throw sdbusplus::xyz::openbmc_project::Common::Error::Unavailable();
+}
+
 } // namespace rbmc

redundant-bmc/src/manager.hpp

@@ -7,20 +7,23 @@
 #include "role_handler.hpp"
 
 #include <sdbusplus/async.hpp>
+#include <xyz/openbmc_project/Control/Failover/aserver.hpp>
 
 namespace rbmc
 {
 
+using FailoverOptions = std::map<std::string, std::variant<bool>>;
+
 /**
  * @class Manager
  *
  * Manages the high level operations of the redundant
  * BMC functionality.
  */
-class Manager
+class Manager :
+    public sdbusplus::aserver::xyz::openbmc_project::control::Failover<Manager>
 {
   public:
-    Manager() = delete;
     ~Manager() = default;
     Manager(const Manager&) = delete;
     Manager& operator=(const Manager&) = delete;
@@ -46,6 +49,14 @@ class Manager
      */
     void disableRedPropChanged(bool disable);
 
+    /**
+     * @brief Implements the StartFailover D-Bus method.
+     *
+     * @param[in] options - The failover options
+     */
+    sdbusplus::async::task<> method_call(start_failover_t /* unused */,
+                                         const FailoverOptions& options);
+
   private:
     /**
      * @brief Kicks off the Manager startup