EndpointClear.cpp

Go to the documentation of this file.

#include "EndpointClear.h"
#include "madara/utility/Utility.h"
#include "madara/logger/GlobalLogger.h"
 
namespace utility = madara::utility;
typedef madara::knowledge::KnowledgeRecord::Integer Integer;
 
madara::filters::EndpointClear::EndpointClear(const std::string& prefix)
  : initialized_(false), prefix_(prefix)
{
}
 
madara::filters::EndpointClear::~EndpointClear() {}
 
void madara::filters::EndpointClear::filter(knowledge::KnowledgeMap& records,
    const transport::TransportContext& transport_context,
    knowledge::Variables& vars)
{
  if (!initialized_)
  {
    knowledge::KnowledgeUpdateSettings settings(true);
    endpoints_.set_settings(settings);
    endpoints_.set_name(prefix_, vars);
    initialized_ = true;
  }
 
  endpoints_.sync_keys();
 
  madara_logger_log(vars.get_context()->get_logger(), logger::LOG_MAJOR,
      "EndpointClear::filter:"
      " Processing a new update from %s with %d records\n",
      transport_context.get_originator().c_str(), (int)records.size());
 
  // if a trusted originator has been added, and this is the originator
  if (trusted_originators_.size() != 0 &&
      (trusted_originators_.find(transport_context.get_originator()) !=
          trusted_originators_.end()))
  {
    madara_logger_log(vars.get_context()->get_logger(), logger::LOG_MAJOR,
        "EndpointClear::filter:"
        " Sender is trusted. Clearing endpoints.\n");
 
    // then clear the endpoints
    endpoints_.clear();
 
    if (vars.get_context()->get_logger().get_level() >= logger::LOG_DETAILED)
    {
      vars.print();
    }
  }
  else
  {
    bool found = false;
    const std::string prefix(endpoints_.get_name());
 
    if (prefix != "")
    {
      // iterate through all records looking for the common prefix
      for (knowledge::KnowledgeMap::const_iterator i = records.begin();
           i != records.end() && !found; ++i)
      {
        // if we've found the prefix, then clear the endpoints
        if (utility::begins_with(i->first, prefix))
        {
          madara_logger_log(vars.get_context()->get_logger(), logger::LOG_MAJOR,
              "EndpointClear::filter:"
              " Prefix is match. Clearing endpoints.\n");
 
          endpoints_.clear();
          found = true;
 
          if (vars.get_context()->get_logger().get_level() >=
              logger::LOG_DETAILED)
          {
            vars.print();
          }
        }
        // if we're past where the prefix would be, quit
        else if (prefix[0] < i->first[0])
        {
          madara_logger_log(vars.get_context()->get_logger(), logger::LOG_MAJOR,
              "EndpointClear::filter:"
              " Prefix is not a match. Not clearing endpoints.\n");
 
          found = true;
        }
      }
    }
  }
}
 
void madara::filters::EndpointClear::add_trusted_originator(
    const std::vector<std::string>& originators)
{
  for (std::vector<std::string>::const_iterator i = originators.begin();
       i != originators.end(); ++i)
  {
    trusted_originators_[*i] = true;
  }
}
 
void madara::filters::EndpointClear::add_trusted_originator(
    const std::string& originator)
{
  trusted_originators_[originator] = true;
}
 
void madara::filters::EndpointClear::clear_trusted_originators(void)
{
  trusted_originators_.clear();
}
 
void madara::filters::EndpointClear::set_prefix(const std::string& prefix)
{
  prefix_ = prefix;
}