QoSTransportSettings.h

Go to the documentation of this file.

#ifndef _MADARA_QOS_TRANSPORT_SETTINGS_H_
#define _MADARA_QOS_TRANSPORT_SETTINGS_H_

#include <string>

#include "madara/transport/TransportSettings.h"
#include "madara/transport/TransportContext.h"
#include "madara/knowledge/ThreadSafeContext.h"
#include "madara/utility/StdInt.h"
#include "madara/MadaraExport.h"
#include "madara/filters/AggregateFilter.h"
#include "madara/filters/RecordFilter.h"
#include "madara/filters/BufferFilter.h"
#include "madara/knowledge/KnowledgeRecordFilters.h"

#ifdef _MADARA_JAVA_
  #include <jni.h>
#endif

#ifdef _MADARA_PYTHON_CALLBACKS_
  #include <boost/python.hpp>
#endif


namespace madara
{
  namespace transport
  {
    enum PacketDropType {
      PACKET_DROP_DETERMINISTIC,
      PACKET_DROP_PROBABLISTIC
    };

    class MADARA_EXPORT QoSTransportSettings : public TransportSettings
    {
    public:
      QoSTransportSettings ();

      QoSTransportSettings (const QoSTransportSettings & settings);
      
      QoSTransportSettings (const TransportSettings & settings);

      virtual ~QoSTransportSettings ();
       
      void operator= (const QoSTransportSettings & settings);
      
      void operator= (const TransportSettings & settings);

      void add_send_filter (uint32_t types,
        knowledge::KnowledgeRecord (*function) (knowledge::FunctionArguments &,
                                      knowledge::Variables &));
      
      void add_send_filter (uint32_t types,
        filters::RecordFilter * filter);
      
      void add_send_filter (void (*function) (
        knowledge::KnowledgeMap &, const TransportContext &,
        knowledge::Variables &));
      
      void add_send_filter (filters::AggregateFilter * filter);

      void add_filter (filters::BufferFilter * filter);

      void add_receive_filter (uint32_t types,
        knowledge::KnowledgeRecord (*function) (knowledge::FunctionArguments &,
                                      knowledge::Variables &));
      
      void add_receive_filter (uint32_t types,
        filters::RecordFilter * filter);
      
      void add_receive_filter (void (*function) (
        knowledge::KnowledgeMap &, const TransportContext &,
        knowledge::Variables &));
 
      void add_receive_filter (filters::AggregateFilter * filter);
      
      void add_rebroadcast_filter (uint32_t types,
        knowledge::KnowledgeRecord (*function) (knowledge::FunctionArguments &,
                                      knowledge::Variables &));
      
      void add_rebroadcast_filter (uint32_t types,
        filters::RecordFilter * filter);
      
      void add_rebroadcast_filter (void (*function) (
        knowledge::KnowledgeMap &, const TransportContext &,
        knowledge::Variables &));
 
      void add_rebroadcast_filter (filters::AggregateFilter * filter);
      
#ifdef _MADARA_JAVA_
      
      void add_receive_filter (
                               uint32_t types, jobject & object);
      
      void add_send_filter (
                            uint32_t types, jobject & object);
      
      void add_rebroadcast_filter (
                                   uint32_t types, jobject & object);
      
      void add_receive_filter (jobject & object);
      
      void add_send_filter (jobject & object);
      
      void add_rebroadcast_filter (jobject & object);
      
#endif
      
#ifdef _MADARA_PYTHON_CALLBACKS_
      
      void add_receive_filter (
        uint32_t types, boost::python::object & object);
      
      void add_send_filter (
        uint32_t types, boost::python::object & object);
      
      void add_rebroadcast_filter (
        uint32_t types, boost::python::object & object);
      
      void add_receive_filter (boost::python::object & object);
      
      void add_send_filter (boost::python::object & object);
      
      void add_rebroadcast_filter (boost::python::object & object);
      
#endif

      void attach (knowledge::ThreadSafeContext * context);
      
      void clear_send_filters (uint32_t types);

      void clear_send_aggregate_filters (void);

      void clear_receive_filters (uint32_t types);

      void clear_buffer_filters (void);

      void clear_receive_aggregate_filters (void);

      void clear_rebroadcast_filters (uint32_t types);
      
      void clear_rebroadcast_aggregate_filters (void);
      
      knowledge::KnowledgeRecord filter_send (
        const madara::knowledge::KnowledgeRecord & input,
        const std::string & name,
        transport::TransportContext & context) const;
        
      void filter_send (knowledge::KnowledgeMap & records,
        const transport::TransportContext & transport_context) const;
          
      knowledge::KnowledgeRecord filter_receive (
        const madara::knowledge::KnowledgeRecord & input,
        const std::string & name,
        transport::TransportContext & context) const;
      
      void filter_receive (knowledge::KnowledgeMap & records,
        const transport::TransportContext & transport_context) const;
          
      knowledge::KnowledgeRecord filter_rebroadcast (
        const madara::knowledge::KnowledgeRecord & input,
        const std::string & name,
        transport::TransportContext & context) const;

      void filter_rebroadcast (knowledge::KnowledgeMap & records,
        const transport::TransportContext & transport_context) const;

      int filter_encode (unsigned char * source, int size, int max_size) const;

      int filter_decode (unsigned char * source, int size, int max_size) const;

      void print_num_filters_send (void) const;

      void print_num_filters_receive (void) const;

      void print_num_filters_rebroadcast (void) const;

      void set_rebroadcast_ttl (unsigned char ttl);

      unsigned char get_rebroadcast_ttl (void) const;

      size_t get_number_of_send_filtered_types (void) const;
      
      size_t get_number_of_send_aggregate_filters (void) const;
       
      size_t get_number_of_rebroadcast_aggregate_filters (void) const;

      size_t get_number_of_rebroadcast_filtered_types (void) const;
       
      size_t get_number_of_receive_aggregate_filters (void) const;

      size_t get_number_of_receive_filtered_types (void) const;

      size_t get_number_of_buffer_filters (void) const;

      void add_trusted_peer (const std::string & peer);

      void add_banned_peer (const std::string & peer);
      
      bool remove_trusted_peer (const std::string & peer);

      bool remove_banned_peer (const std::string & peer);

      bool is_trusted (const std::string & peer) const;

      void enable_participant_ttl (unsigned char maximum_ttl = 255);

      unsigned char get_participant_ttl (void) const;

      void update_drop_rate (double drop_rate,
        int drop_type = PACKET_DROP_DETERMINISTIC,
        uint64_t drop_burst = 1);

      double get_drop_rate (void) const;
      
      int get_drop_type (void) const;

      uint64_t get_drop_burst (void) const;

      void set_send_bandwidth_limit (int64_t bandwidth);
      
      int64_t  get_send_bandwidth_limit (void) const;
       
      void set_total_bandwidth_limit (int64_t bandwidth);
       
      int64_t get_total_bandwidth_limit (void) const;

       void set_deadline (double deadline);

       double get_deadline (void) const;

       virtual void load (const std::string & filename,
         const std::string & prefix = "transport");

       virtual void load_text (const std::string & filename,
         const std::string & prefix = "transport");

       virtual void save (const std::string & filename,
         const std::string & prefix = "transport") const;

       virtual void save_text (const std::string & filename,
         const std::string & prefix = "transport") const;

    private:
       
      unsigned char rebroadcast_ttl_;

      unsigned char participant_rebroadcast_ttl_;

      std::map <std::string, int> trusted_peers_;
      
      std::map <std::string, int> banned_peers_;

      knowledge::KnowledgeRecordFilters  rebroadcast_filters_;
         
      knowledge::KnowledgeRecordFilters  receive_filters_;

      knowledge::KnowledgeRecordFilters  send_filters_;

      filters::BufferFilters   buffer_filters_;

      double packet_drop_rate_;

      int packet_drop_type_;

      uint64_t packet_drop_burst_;

      int64_t max_send_bandwidth_;

      int64_t max_total_bandwidth_;

      double deadline_;
    };
  } // end Transport namespace
} // end Madara namespace

#endif // _MADARA_QOS_TRANSPORT_SETTINGS_H_