ddtDataTransferLib.hpp

Go to the documentation of this file.

 
#ifndef DDTDATATRANSFERLIB_HPP_
#define DDTDATATRANSFERLIB_HPP_
 
#include <Ddtdatatransfericd.hpp>
#include <boost/property_tree/ini_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <iostream>
#include <mal/Cii.hpp>
#include <mal/rr/qos/ReplyTime.hpp>
#include <mal/utility/LoadMal.hpp>
 
#include "ddt/ddtErrorCodes.hpp"
#include "ddt/ddtLogger.hpp"
#include "ddt/ddtMemoryAccessor.hpp"
 
namespace mal = ::elt::mal;
namespace datatransfer = ::elt::ddt::datatransfer;
 
namespace ddt {
 
class DdtDataTransferLib {
 public:
  explicit DdtDataTransferLib(DdtLogger* ddt_logger);
 
  explicit DdtDataTransferLib(log4cplus::Logger const& log4cplus_logger);
 
  virtual ~DdtDataTransferLib();
 
  void SetQoS(const int ddt_latency, const int ddt_deadline);
 
  const std::string VerifyPathInBrokerUri(std::string broker_uri);
 
  int InitMAL(const std::string broker_uri);
 
  std::unique_ptr<datatransfer::DataBrokerRegistrationSync,
                  std::default_delete<datatransfer::DataBrokerRegistrationSync>> 
    GetBrokerClient();
 
  virtual int RegisterPublisher(const std::string uri, const std::string dsi,
                                const bool compute_crc) {
    return 0;
  };
 
  virtual int UnregisterPublisher() { return 0; };
 
  virtual void PublishData() {
    // intentionally-blank override
  }
 
  virtual int RegisterSubscriber(const std::string uri, const std::string dsi,
                                 const std::string remote_uri,
                                 const int32_t interval = 10) {
    return 0;
  };
 
  virtual int UnregisterSubscriber() { return 0; };
 
  virtual DataSample* ReadData() { return nullptr; };
 
 protected:
  void StartHeartbeat(const int32_t interval, const std::string id);
 
  void StopHeartbeat();
 
  void CheckHeartbeatTimeout(int32_t& new_reply_time);
 
  const std::string GetConfigFilePath();
 
  int latency;
 
  int deadline;
 
  int32_t reply_time;
 
  int32_t heartbeat_interval;
 
  std::promise<void> exit_signal_heartbeat;
 
  std::future<void> future_object_heartbeat;
 
  std::atomic<bool> heartbeat_active;
 
  std::unique_ptr<
      datatransfer::DataBrokerRegistrationSync,
      std::default_delete<datatransfer::DataBrokerRegistrationSync> >
      client;
 
  std::atomic<bool> connected_to_broker;
 
  elt::mal::rr::ListenerRegistration connection_listener;
 
  DdtLogger* logger;
 
  DdtLogger* my_logger = nullptr;
 
  const int32_t REPLY_TIME_DEFAULT = 6;
 
  const int32_t REPLY_TIME_MIN = 2;
 
 private:
  void Init(DdtLogger* ddt_logger);
 
  void HeartbeatThread();
 
  std::string identifier;
 
  const std::string BROKER_PATH{"/broker/Broker1"};
  const int LATENCY_DEFAULT = 10000;
  const int DEADLINE_DEFAULT = 10;
  const int32_t HEARTBEAT_INTERVAL_DEFAULT = 1;
};
 
}  // namespace ddt
 
#endif /* DDTDATATRANSFERLIB_HPP_ */