tlbmc/hal/shared_mem/static_client_impl.h

#ifndef THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_HAL_SHARED_MEM_STATIC_SHARED_MEMORY_CLIENT_IMPL_H
#define THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_HAL_SHARED_MEM_STATIC_SHARED_MEMORY_CLIENT_IMPL_H
#include <cstdint>
#include <memory>
#include <string>
#include <utility>

#include "absl/base/thread_annotations.h"
#include "absl/container/flat_hash_map.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/synchronization/mutex.h"
#include "boost/interprocess/exceptions.hpp"  // NOLINT
#include "boost/interprocess/managed_shared_memory.hpp"  //NOLINT
#include "tlbmc/hal/shared_mem/client_interface.h"
#include "tlbmc/hal/shared_mem/client_segment.h"
// copybara:strip_begin(g3-shared-libs)
#include "tlbmc/hal/shared_mem/metrics.h"
// copybara:strip_end
#include "tlbmc/hal/shared_mem/sensors.h"

namespace milotic_tlbmc {

class StaticSharedMemoryClient : public IpcClient {
  class Token {
    explicit Token() = default;
    friend class StaticSharedMemoryClient;
  };

 public:
  static IpcClient& GetInstance();
  static IpcClient& GetInstance(const std::string& initialized_file_path,
                                const std::string& shared_memory_name);
  static void SetupInstanceForUnitTest();

  absl::StatusOr<ClientSegment*> GetOrCreateClientSegment();

  absl::StatusOr<std::pair<float, uint64_t>> ReadSensorValue(
      const std::string& sensor_name);

  bool IsSharedMemoryReady() override;

  absl::Status UpdateSensorValue(const std::string& sensor_name,
                                 float value) override;
  absl::Status UpdateSensorValue(const std::string& sensor_name, float value,
                                 uint64_t timestamp) override;
  // copybara:strip_begin(g3-shared-libs)
  const TlbmcMetrics* GetMetrics() override;
  // copybara:strip_end

  ~StaticSharedMemoryClient() override = default;

  StaticSharedMemoryClient(Token /*unused*/,
                           const std::string& initialized_file_path,
                           const std::string& shared_memory_name)
      : initialized_file_path_(initialized_file_path),
        shared_memory_name_(shared_memory_name) {}

 protected:
  static std::unique_ptr<StaticSharedMemoryClient> CreateInstanceForTesting(
      const std::string& initialized_file_path,
      const std::string& shared_memory_name);
  StaticSharedMemoryClient() = default;

  absl::StatusOr<IpcSensor*> FindSensor(const std::string& sensor_name)
      ABSL_LOCKS_EXCLUDED(sensors_mutex_);

 private:
  std::string initialized_file_path_;
  std::string shared_memory_name_;

  absl::Mutex sensors_mutex_;
  absl::Mutex client_segment_mutex_;
  std::unique_ptr<ClientSegment> client_segment_;
  absl::flat_hash_map<std::string, IpcSensor*> sensors_
      ABSL_GUARDED_BY(sensors_mutex_);
};

using SharedMemoryClient = StaticSharedMemoryClient;
}  // namespace milotic_tlbmc
#endif  // THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_HAL_SHARED_MEM_STATIC_SHARED_MEMORY_CLIENT_IMPL_H