ByRangeDelivery.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_comm_ByRangeDelivery_hpp
#define anna_comm_ByRangeDelivery_hpp

#include <anna/core/functions.hpp>
#include <anna/core/tracing/Logger.hpp>

#include <anna/xml/Node.hpp>
#include <anna/xml/Attribute.hpp>

#include <anna/comm/RoundRobinDelivery.hpp>

namespace anna {

namespace comm {
class Resource;
}

namespace comm {

template < typename TKey, typename TDelivery = RoundRobinDelivery, typename TSerializer = anna::functions > class ByRangeDelivery : public comm::Service {
protected:
  struct Range {
    const TKey bottom;
    const TKey top;
    TDelivery* delivery;

    Range(const std::string& baseName, const TKey& _bottom, const TKey& _top) :
      bottom(_bottom), top(_top) {
      std::string name(baseName);
      name += '[';
      name += TSerializer::asString(_bottom);
      name += ',';
      name += TSerializer::asString(_top);
      name += ']';
      delivery = new TDelivery(name.c_str(), false);
    }

    std::string asString() const {
      std::string result("comm::ByRangeDelivery { Bottom: ");
      result += TSerializer::asString(bottom);
      result += " | Top: ";
      result += TSerializer::asString(top);
      result += " | ";
      result += delivery->asString();
      return result += " }";
    }

    xml::Node* asXML(xml::Node* parent) const {
      xml::Node* result = parent->createChild("comm.Range");
      result->createAttribute("Bottom", TSerializer::asString(bottom));
      result->createAttribute("Top", TSerializer::asString(top));
      delivery->asXML(result);
      return result;
    }
  };

public:
  typedef std::vector<Range*> range_container;
  typedef typename range_container::iterator range_iterator;
  typedef typename range_container::const_iterator const_range_iterator;

  ByRangeDelivery(const char* name, const bool isCritical) :
    comm::Service(name, isCritical),
    a_currentRange(NULL)
  {;}

  virtual ~ByRangeDelivery() {
    for(range_iterator ii = range_begin(), maxii = range_end(); ii != maxii; ii ++)
      delete range(ii)->delivery;

    a_ranges.clear();
  }

  range_iterator createRange(const TKey& bottom, const TKey& top)
  noexcept(false) {
    Range* result;

    if(bottom > top) {
      std::string msg(asString());
      msg += " | Bottom: ";
      msg += TSerializer::asString(bottom);
      msg += " | Invalid range (bottom > top)";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    if((result = find(bottom)) != NULL) {
      std::string msg(asString());
      msg += " | Bottom: ";
      msg += TSerializer::asString(bottom);
      msg += " | Overlapped with ";
      msg += result->asString();
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    if((result = find(top)) != NULL) {
      std::string msg(asString());
      msg += " | top: ";
      msg += TSerializer::asString(top);
      msg += " | Overlapped with ";
      msg += result->asString();
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    a_ranges.push_back(result = new Range(getName(), bottom, top));
    return range_begin() + a_ranges.size() - 1;
  }

  void attach(range_iterator& ii, Server* server) noexcept(false) {
    range(ii)->delivery->attach(server);
    comm::Service::attach(server);
  }

  void prepare(const TKey& key) noexcept(false) {
    Range* w = find(key);

    if(w == NULL && Logger::isActive(Logger::Warning)) {
      std::string msg(asString());
      msg += " | TKey: ";
      msg += TSerializer::asString(key);
      msg += " | No range associated";
      Logger::warning(msg, ANNA_FILE_LOCATION);
    } else
      a_currentRange = w;

    if(a_currentRange == NULL) {
      std::string msg(asString());
      msg += " | TKey: ";
      msg += TSerializer::asString(key);
      msg += " | No delivery service associated has been found";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }
  }

  std::string asString() const
  {
    std::string result = className();
    result += " { ";
    result += comm::Delivery::asString();
    result += " | Ranges: ";

    for(const_range_iterator ii = range_begin(), maxii = range_end(); ii != maxii; ii ++)  {
      result += "\n\t";
      result += range(ii)->asString();
    }

    return result += "}";
  }

  xml::Node* asXML(xml::Node* parent) const
  {
    xml::Node* result = parent->createChild("anna.comm.ByRangeDelivery");
    xml::Node* node = comm::Service::asXML(result);

    for(const_range_iterator ii = range_begin(), maxii = range_end(); ii != maxii; ii ++)
      range(ii)->asXML(node);

    return result;
  }

  static const char* className() { return "anna::comm::ByRangeDelivery"; }

protected:
  range_iterator range_begin() { return a_ranges.begin(); }
  range_iterator range_end() { return a_ranges.end(); }

  const_range_iterator range_begin() const { return a_ranges.begin(); }
  const_range_iterator range_end() const { return a_ranges.end(); }

  static Range* range(range_iterator& ii) { return *ii; }
  static const Range* range(const_range_iterator& ii) { return *ii; }

  virtual void do_initialize()
  noexcept(false) {
    for(range_iterator ii = range_begin(), maxii = range_end(); ii != maxii; ii ++)
      range(ii)->delivery->initialize();
  }

private:
  range_container a_ranges;
  Range* a_currentRange;

  Range* find(const TKey& key) {
    Range* result(NULL);
    Range* w;

    for(range_iterator ii = range_begin(), maxii = range_end(); ii != maxii; ii ++) {
      w = range(ii);

      if(w->bottom <= key && key <= w->top) {
        result = w;
        break;
      }
    }

    return result;
  }

  comm::Resource* do_apply()
  noexcept(false) {
    if(a_currentRange == NULL) {
      std::string msg(asString());
      msg += " | Wrong call to anna::comm::ByRangeDelivery::prepare";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    return a_currentRange->delivery->apply();
  }

  // Considera que el servicio esta NO-disponible cuando TODOS los servicios fallan
  bool do_fault(const comm::Resource* resource)
  {
    int n, nfault;
    n = nfault = 0;

    for(range_iterator ii = range_begin(), maxii = range_end(); ii != maxii; ii ++) {
      n ++;

      if(range(ii)->delivery->fault(resource) == true)
        nfault ++;
    }

    return (n == nfault);
  }

  // Considera que el servicio esta recuperado cuando alguno de los servicios esta disponible
  bool do_recover(const comm::Resource* resource)
  {
    bool result(false);

    for(range_iterator ii = range_begin(), maxii = range_end(); ii != maxii; ii ++) {
      if(range(ii)->delivery->recover(resource) == true)
        result = true;
    }

    return result;
  }
};

}
}

#endif