tlbmc/store/factory.h

#ifndef THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_STORE_FACTORY_H_
#define THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_STORE_FACTORY_H_

#include <cstddef>
#include <memory>
#include <vector>

#include "one/offline_node_entities.pb.h"
#include "absl/base/nullability.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include <nlohmann/json_fwd.hpp>
#include "tlbmc/collector/fru_collector.h"
#include "tlbmc/collector/gpio_collector.h"
#include "tlbmc/collector/led_collector.h"
#include "tlbmc/collector/metric_collector.h"
#include "tlbmc/collector/pcie_collector.h"
#include "tlbmc/collector/power_control_collector.h"
#include "tlbmc/collector/power_fault_log_collector.h"
#include "tlbmc/collector/sel_collector.h"
#include "tlbmc/collector/sensor_collector.h"
#include "tlbmc/collector/sensor_collector_aggregator.h"
#include "tlbmc/collector/thermal_collector.h"
#include "tlbmc/configs/entity_config.h"
#include "tlbmc/host_state/host_state_collector.h"
#include "tlbmc/host_state/power_control.h"
#include "fru.pb.h"
#include "sensor.pb.h"
#include "software_metrics.pb.h"

namespace milotic_tlbmc {

// Factory to create collectors.
// This is useful for dependency injection for tests.
class CollectorFactory {
 public:
  virtual ~CollectorFactory() = default;
  virtual absl::StatusOr<std::unique_ptr<SensorCollector>>
  CreateSensorCollector(const SensorCollector::Params& params) = 0;
  virtual absl::StatusOr<std::unique_ptr<FruCollector>> CreateFruCollector(
      const FruCollector::Options& options) = 0;
  virtual absl::StatusOr<std::unique_ptr<MetricCollector>>
  CreateMetricCollector(const MetricCollector::Params& params) = 0;
  virtual absl::StatusOr<std::unique_ptr<GpioCollector>> CreateGpioCollector(
      const GpioCollector::Params& params) = 0;
  virtual absl::StatusOr<std::unique_ptr<LedCollector>> CreateLedCollector(
      const LedCollector::Params& params) = 0;
  virtual absl::StatusOr<std::unique_ptr<ThermalCollector>>
  CreateThermalCollector(const ThermalCollector::Params& params,
                         SensorCollectorAggregator* absl_nonnull aggregator,
                         FruCollector* absl_nonnull fru_collector,
                         EntityConfig* absl_nonnull entity_config) = 0;
  virtual absl::StatusOr<std::unique_ptr<PowerControlCollector>>
  CreatePowerControlCollector(const PowerControlCollector::Params& params) = 0;
  virtual absl::StatusOr<std::unique_ptr<PowerFaultLogCollector>>
  CreatePowerFaultLogCollector(
      const PowerFaultLogCollector::Params& params) = 0;
  virtual absl::StatusOr<std::unique_ptr<SelCollector>> CreateSelCollector(
      const SelCollector::Params& params) = 0;
  virtual absl::StatusOr<std::unique_ptr<PcieCollector>> CreatePcieCollector(
      const PcieCollector::Params& params) = 0;
};

class CollectorFactoryImpl : public CollectorFactory {
 public:
  absl::StatusOr<std::unique_ptr<SensorCollector>> CreateSensorCollector(
      const SensorCollector::Params& params) override {
    return SensorCollector::Create(params);
  }

  absl::StatusOr<std::unique_ptr<FruCollector>> CreateFruCollector(
      const FruCollector::Options& options) override {
    return FruCollector::Create(options);
  }

  absl::StatusOr<std::unique_ptr<MetricCollector>> CreateMetricCollector(
      const MetricCollector::Params& params) override {
    return MetricCollector::Create(params);
  }

  absl::StatusOr<std::unique_ptr<GpioCollector>> CreateGpioCollector(
      const GpioCollector::Params& params) override {
    return GpioCollector::Create(params);
  }

  absl::StatusOr<std::unique_ptr<LedCollector>> CreateLedCollector(
      const LedCollector::Params& params) override {
    return LedCollector::Create(params);
  }

  absl::StatusOr<std::unique_ptr<ThermalCollector>> CreateThermalCollector(
      const ThermalCollector::Params& params,
      SensorCollectorAggregator* absl_nonnull aggregator,
      FruCollector* absl_nonnull fru_collector,
      EntityConfig* absl_nonnull entity_config) override {
    return ThermalCollector::Create(params, aggregator, fru_collector,
                                    entity_config);
  }

  absl::StatusOr<std::unique_ptr<PowerControlCollector>>
  CreatePowerControlCollector(
      const PowerControlCollector::Params& params) override {
    return PowerControlCollector::Create(params);
  }

  absl::StatusOr<std::unique_ptr<PowerFaultLogCollector>>
  CreatePowerFaultLogCollector(
      const PowerFaultLogCollector::Params& params) override {
    return PowerFaultLogCollector::Create(params);
  }

  absl::StatusOr<std::unique_ptr<SelCollector>> CreateSelCollector(
      const SelCollector::Params& params) override {
    return SelCollector::Create(params);
  }

  absl::StatusOr<std::unique_ptr<PcieCollector>> CreatePcieCollector(
      const PcieCollector::Params& params) override {
    return PcieCollector::Create(params);
  }
};

// Factory to create a config reader.
// This is useful for dependency injection for tests.
class EntityConfigReader {
 public:
  virtual ~EntityConfigReader() = default;
  virtual absl::Status LoadEntityConfig(
      absl::string_view config_location,
      absl::string_view offline_node_entities_path) = 0;
  virtual const std::vector<nlohmann::json>& GetConfig() const = 0;
  virtual const ::production_msv::node_entities_proto::
      OfflineNodeEntityInformation&
      GetOfflineNodeEntities() const = 0;
  virtual absl::StatusOr<std::unique_ptr<EntityConfig>> CreateEntityConfig(
      const RawFruTable& fru_table, size_t ad_hoc_fru_count,
      bool enable_deterministic_bmc, GpioCollector* gpio_collector = nullptr,
      bool enable_hft_test_sensor = false) = 0;
};

class EntityConfigReaderImpl : public EntityConfigReader {
 public:
  absl::Status LoadEntityConfig(
      absl::string_view config_location,
      absl::string_view offline_node_entities_path) override;

  absl::StatusOr<std::unique_ptr<EntityConfig>> CreateEntityConfig(
      const RawFruTable& fru_table, size_t ad_hoc_fru_count,
      bool enable_deterministic_bmc, GpioCollector* gpio_collector = nullptr,
      bool enable_hft_test_sensor = false) override;

  const std::vector<nlohmann::json>& GetConfig() const override;

  const ::production_msv::node_entities_proto::OfflineNodeEntityInformation&
  GetOfflineNodeEntities() const override;

 private:
  std::vector<nlohmann::json> config_list_;
  ::production_msv::node_entities_proto::OfflineNodeEntityInformation
      offline_node_entities_;
};

}  // namespace milotic_tlbmc

#endif  // THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_STORE_FACTORY_H_