redfish-core/lib/telemetry_service.hpp

#ifndef THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_TELEMETRY_SERVICE_H_
#define THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_TELEMETRY_SERVICE_H_

#include <chrono>  // NOLINT
#include <cstddef>
#include <cstdint>
#include <ctime>
#include <functional>
#include <memory>
#include <string>

#include "app.hpp"
#include "http_request.hpp"
#include "logging.hpp"
#include "async_resp.hpp"
#include "dbus_utility.hpp"
#include "error_messages.hpp"
#include "query.hpp"
#include "registries/privilege_registry.hpp"
#include "dbus_utils.hpp"
#include "telemetry_utils.hpp"
#include "time_utils.hpp"
#include "managed_store.hpp"
#include "managed_store_types.hpp"
#include "sdbusplus/unpack_properties.hpp"

#ifdef UNIT_TEST_BUILD
#include "test/g3/mock_managed_store.hpp"  // NOLINT
#endif

namespace redfish {

inline void handleTelemetryServiceGet(
    crow::App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
  if (!redfish::setUpRedfishRoute(app, req, asyncResp)) {
    return;
  }
  asyncResp->res.jsonValue["@odata.type"] =
      "#TelemetryService.v1_2_1.TelemetryService";
  asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/TelemetryService";
  asyncResp->res.jsonValue["Id"] = "TelemetryService";
  asyncResp->res.jsonValue["Name"] = "Telemetry Service";

  asyncResp->res.jsonValue["MetricReportDefinitions"]["@odata.id"] =
      "/redfish/v1/TelemetryService/MetricReportDefinitions";
  asyncResp->res.jsonValue["MetricReports"]["@odata.id"] =
      "/redfish/v1/TelemetryService/MetricReports";
  asyncResp->res.jsonValue["Triggers"]["@odata.id"] =
      "/redfish/v1/TelemetryService/Triggers";

  managedStore::ManagedObjectStoreContext context(asyncResp);
  managedStore::GetManagedObjectStore()->getAllProperties(
      telemetry::service, "/xyz/openbmc_project/Telemetry/Reports",
      "xyz.openbmc_project.Telemetry.ReportManager", context,
      [asyncResp](const boost::system::error_code& ec,
                  const dbus::utility::DBusPropertiesMap& ret) {
        if (ec == boost::system::errc::host_unreachable) {
          asyncResp->res.jsonValue["Status"]["State"] = "Absent";
          return;
        }
        if (ec) {
          BMCWEB_LOG_ERROR << "respHandler DBus error " << ec;
          messages::internalError(asyncResp->res);
          return;
        }

        asyncResp->res.jsonValue["Status"]["State"] = "Enabled";

        const size_t* maxReports = nullptr;
        const uint64_t* minInterval = nullptr;

        const bool success = sdbusplus::unpackPropertiesNoThrow(
            dbus_utils::UnpackErrorPrinter(), ret, "MaxReports", maxReports,
            "MinInterval", minInterval);

        if (!success) {
          messages::internalError(asyncResp->res);
          return;
        }

        if (maxReports != nullptr) {
          asyncResp->res.jsonValue["MaxReports"] = *maxReports;
        }

        if (minInterval != nullptr) {
          asyncResp->res.jsonValue["MinCollectionInterval"] =
              time_utils::toDurationString(
                  std::chrono::milliseconds(static_cast<time_t>(*minInterval)));
        }
      });
}

inline void requestRoutesTelemetryService(App& app) {
  BMCWEB_ROUTE(app, "/redfish/v1/TelemetryService/")
      .privileges(redfish::privileges::getTelemetryService)
      .methods(boost::beast::http::verb::get)(
          std::bind_front(handleTelemetryServiceGet, std::ref(app)));
}

}  // namespace redfish

#endif  // THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_TELEMETRY_SERVICE_H_