tlbmc/sensors/nic_sensor.cc

#include "tlbmc/sensors/nic_sensor.h"

#include <memory>
#include <optional>
#include <string>
#include <utility>

#include "absl/log/log.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "nic_telemetry_config.pb.h"
#include "sensor_instance_properties.pb.h"
#include "tlbmc/hal/nic_veeprom/interface.h"
#include "veeprom.pb.h"
#include "resource.pb.h"
#include "sensor.pb.h"
#include "tlbmc/sensors/sync_polling_sensor.h"

namespace milotic_tlbmc {
namespace {

// Translates canonical HAL error codes into `milotic_tlbmc::Status` buckets.
milotic_tlbmc::Status MapNicSensorStatusToStoreStatus(
    const absl::Status& hal_status) {
  switch (hal_status.code()) {
    case absl::StatusCode::kOk:
      return milotic_tlbmc::STATUS_READY;
    case absl::StatusCode::kUnavailable:
      return milotic_tlbmc::STATUS_DRIVER_READ_ERROR;
    case absl::StatusCode::kFailedPrecondition:
    case absl::StatusCode::kDataLoss:
      return milotic_tlbmc::STATUS_INVALID_DATA;
    default:
      return milotic_tlbmc::STATUS_OTHER_ERROR;
  }
}

}  // namespace

absl::StatusOr<std::shared_ptr<NicSensor>> NicSensor::Create(
    const NicTelemetryInstance& instance_config,
    const EntityCommonConfig& entity_common_config,
    const std::shared_ptr<boost::asio::io_context>& io_context,
    const nic_veeprom::Accessor& accessor,
    std::optional<NotificationCb> on_batch_notify) {
  SensorInstanceProperties instance_properties =
      instance_config.instance_properties();
  auto telemetry_name = static_cast<nic_veeprom::NicTelemetryName>(
      instance_config.telemetry_name());
  std::string sensor_name = nic_veeprom::NicTelemetryName_Name(telemetry_name);
  constexpr absl::string_view kNicTelemetryNamePrefix = "NIC_TELEMETRY_NAME_";
  if (absl::StartsWith(sensor_name, kNicTelemetryNamePrefix)) {
    sensor_name = sensor_name.substr(kNicTelemetryNamePrefix.size());
  }
  sensor_name =
      absl::StrCat(entity_common_config.board_config_key(), "_", sensor_name);
  instance_properties.set_name(sensor_name);
  instance_properties.set_unit(accessor.GetSensorUnit(telemetry_name));
  return std::make_shared<NicSensor>(Token(), instance_config.telemetry_name(),
                                     entity_common_config, instance_properties,
                                     io_context, accessor, on_batch_notify);
}

NicSensor::NicSensor(Token token, nic_veeprom::NicTelemetryName telemetry_name,
                     const EntityCommonConfig& entity_common_config,
                     const SensorInstanceProperties& sensor_instance_properties,
                     const std::shared_ptr<boost::asio::io_context>& io_context,
                     const nic_veeprom::Accessor& accessor,
                     std::optional<NotificationCb> on_batch_notify)
    : SyncPollingSensor(CreateStaticAttributes(sensor_instance_properties,
                                               /*hal_common_config=*/{},
                                               entity_common_config),
                        sensor_instance_properties.thresholds(), io_context,
                        on_batch_notify),
      telemetry_name_(telemetry_name),
      accessor_(accessor) {}

absl::StatusOr<SensorValue> NicSensor::ReadSensorData() {
  absl::StatusOr<std::shared_ptr<const SensorValue>> result =
      accessor_.GetSensorValue(telemetry_name_);
  milotic_tlbmc::Status store_status =
      MapNicSensorStatusToStoreStatus(result.status());
  State state;
  state.set_status(store_status);
  this->UpdateState(std::move(state));
  if (!result.ok()) {
    return absl::Status(result.status().code(),
                        absl::StrCat("Failed to read sensor value with error: ",
                                     result.status().message()));
  }
  return *result.value();
}

}  // namespace milotic_tlbmc