fcfCommHelpers.hpp

Go to the documentation of this file.

 
#ifndef IFW_FCF_DEVMGR_COMMON_FCF_COMM_HELPERS_HPP_
#define IFW_FCF_DEVMGR_COMMON_FCF_COMM_HELPERS_HPP_
 
#include <chrono>
#include <functional>
#include <stdexcept>
#include <string>
#include <utility>
#include <variant>
#include <vector>
 
#include <fmt/format.h>
 
#include <ifw/fnd/defs/iCommAdapter.hpp>
 
#include <eso/uatools/ualib/client.hpp>
 
namespace ifw::fcf::devmgr::common {

  template <typename... Args>
  std::vector<ifw::fnd::defs::CallArgument>
  MakeCallArgs(Args&&... args) {
    return {
      ifw::fnd::defs::CallArgument{
        /*name=*/"",
        /*value=*/ifw::fnd::defs::Value(std::forward<Args>(args))
      }...
    };
  }

  inline void
  CheckRpcReply(const ifw::fnd::defs::CallResult& result,
                const std::string& what,
                const std::function<std::string(short)>& error_message_fn) {
    // Wire-level call failure (transport, BadInvalidState, ...).
    if (result.status != ifw::fnd::defs::Status::Ok) {
      throw std::runtime_error(fmt::format(
          "RPC {} failed: {}", what, result.message));
    }
    // FCF convention: every device-controller RPC returns one
    // short. A missing return slot means the ICD doesn't match what
    // we sent.
    if (result.output_arguments.empty()) {
      throw std::runtime_error(fmt::format(
          "RPC {} returned no output (ICD mismatch)", what));
    }
    const auto& out_val = result.output_arguments.front().data.value;
    short reply = 0;
    try {
      reply = std::get<short>(out_val);
    } catch (const std::bad_variant_access&) {
      throw std::runtime_error(fmt::format(
          "RPC {} return type does not match a short (check the ICD)",
          what));
    }
    if (reply != 0) {
      throw std::runtime_error(error_message_fn(reply));
    }
  }

  inline constexpr std::chrono::milliseconds kRpcTimeout{60'000};
 
  inline void
  ExecuteRpcCall(ifw::fnd::defs::ICommAdapter& comm,
                 const std::string& method_node_id,
                 std::vector<ifw::fnd::defs::CallArgument> args,
                 const std::string& what,
                 const std::function<std::string(short)>& error_message_fn,
                 const std::string& object_node_id = "") {
    ifw::fnd::defs::CallRequest req;
    req.method = method_node_id;
    req.input_arguments = std::move(args);
    req.options.timeout = kRpcTimeout;
    // OPC UA Call needs the parent object of the method. ualib can
    // derive it from a dotted method NodeId, but FCF already knows it
    // exactly (the '#'-decoded prefix), so pass it explicitly — this
    // is both faster and unambiguous for servers whose method NodeId is
    // not the dotted parent of the object.
    if (!object_node_id.empty()) {
      req.options.properties.Set("object", object_node_id);
    }
    auto res = comm.Call(req);
    CheckRpcReply(res, what, error_message_fn);
  }
 
}  // namespace ifw::fcf::devmgr::common
 
#endif  // IFW_FCF_DEVMGR_COMMON_FCF_COMM_HELPERS_HPP_