Transport.h

Go to the documentation of this file.

#ifndef _MADARA_TRANSPORT_H_
#define _MADARA_TRANSPORT_H_
 
#include <string>
#include <sstream>
#include <vector>
#include <ostream>
 
#include "madara/utility/ThreadSafeVector.h"
#include "madara/MadaraExport.h"
#include "madara/transport/QoSTransportSettings.h"
 
#include "ReducedMessageHeader.h"
#include "madara/transport/BandwidthMonitor.h"
#include "madara/transport/PacketScheduler.h"
 
#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/knowledge/ThreadSafeContext.h"
#include "madara/expression/ExpressionTree.h"
#include "madara/expression/Interpreter.h"
 
namespace madara
{
namespace transport
{
class MADARA_EXPORT Base
{
public:
  typedef std::vector<std::string> HostsVector;
 
  Base(const std::string& id, TransportSettings& new_settings,
      knowledge::ThreadSafeContext& context);
 
  virtual ~Base() = 0;
 
  int validate_transport(void);
 
  virtual int setup(void);
 
  int check_transport(void);
 
  TransportSettings& settings(void);
 
  long prep_send(const knowledge::KnowledgeMap& orig_updates,
      const char* print_prefix);
 
  virtual long send_data(const knowledge::KnowledgeMap&) = 0;
 
  void invalidate_transport(void);
 
  virtual void close(void);
 
protected:
  volatile bool is_valid_;
  volatile bool shutting_down_;
  HostsVector hosts;
 
  const std::string id_;
 
  QoSTransportSettings settings_;
 
  // context for knowledge base
  madara::knowledge::ThreadSafeContext& context_;
 
#ifndef _MADARA_NO_KARL_
  madara::expression::ExpressionTree on_data_received_;
 
#endif  // _MADARA_NO_KARL_
 
  BandwidthMonitor send_monitor_;
 
  BandwidthMonitor receive_monitor_;
 
  PacketScheduler packet_scheduler_;
 
  madara::utility::ScopedArray<char> buffer_;
 
  uint64_t last_toi_sent_ = 0;
};
 
int MADARA_EXPORT process_received_update(const char* buffer,
    uint32_t bytes_read, const std::string& id,
    knowledge::ThreadSafeContext& context, const QoSTransportSettings& settings,
    BandwidthMonitor& send_monitor, BandwidthMonitor& receive_monitor,
    knowledge::KnowledgeMap& rebroadcast_records,
#ifndef _MADARA_NO_KARL_
 
    knowledge::CompiledExpression& on_data_received,
#endif  // _MADARA_NO_KARL_
 
    const char* print_prefix, const char* remote_host, MessageHeader*& header);
 
int MADARA_EXPORT prep_rebroadcast(knowledge::ThreadSafeContext& context,
    char* buffer, int64_t& buffer_remaining,
    const QoSTransportSettings& settings, const char* print_prefix,
    MessageHeader* header, const knowledge::KnowledgeMap& records,
    PacketScheduler& packet_scheduler);
 
inline std::string MADARA_EXPORT get_operation_type(int type)
{
  if (type == 0)
  {
    return "IDLE_OPERATION";
  }
  else if (type == 1)
  {
    return "SENDING_OPERATION";
  }
  else if (type == 2)
  {
    return "RECEIVING_OPERATION";
  }
  else if (type == 3)
  {
    return "REBROADCASTING_OPERATION";
  }
  else
  {
    return "UNKNOWN_OPERATION";
  }
}
 
typedef utility::ThreadSafeVector<Base*> Transports;
}
}
 
#include "Transport.inl"
 
#endif  // _MADARA_TRANSPORT_H_