Context.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_timex_Context_hpp
#define anna_timex_Context_hpp

#include <string>
#include <map>

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

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

#include <anna/timex/Engine.hpp>
#include <anna/timex/TimeEventObserver.hpp>
#include <anna/timex/Transaction.hpp>

#include <anna/core/util/Millisecond.hpp>

namespace anna {

namespace timex {

template <typename Tid> class Context : public timex::TimeEventObserver {
public:
  Transaction* open(const Tid& tid, const int classType = 0)
  noexcept(false) {
    Transaction* result = NULL;
    {
      Guard guard(a_mutex, "timex::Context::open");
      transaction_iterator ii = a_transactions.find(tid);

      if(ii != a_transactions.end()) {
        std::string msg(transaction(ii)->asString());
        msg += " | Already in progress";
        throw RuntimeException(msg, ANNA_FILE_LOCATION);
      }

      if((result = createTransaction(classType)) == NULL) {
        std::string msg("timex::Context::createTransaction returned NULL | ClassType: ");
        msg += functions::asString(classType);
        throw RuntimeException(msg, ANNA_FILE_LOCATION);
      }

      result->setTimeout(a_timeout);
      result->setObserver(this);
      result->setControlPoint();
      result->setId(anna_ptrnumber_cast(result));
      // Copia en el contexto de la transacción la clave usada.
      // Se usará para poder buscar por clave a la hora de liberar la transacción.
      std::pair <transaction_iterator, bool> rr = a_transactions.insert(value_type(tid, result));
      result->setContext((void*) &rr.first->first);
    }

    try {
      a_timeController.activate(result);
    } catch(RuntimeException&) {
      releaseTransaction(result);
      throw;
    }

    LOGINFORMATION(
      std::string msg("timex::Context::open | ");
      msg += result->asString();
      Logger::information(msg, ANNA_FILE_LOCATION);
    );
    return result;
  }

  Transaction* find(const Tid& tid, const Exception::Mode::_v emode = Exception::Mode::Throw)
  noexcept(false) {
    Guard guard(a_mutex, "timex::Context::find");
    transaction_iterator ii = a_transactions.find(tid);
    Transaction* result = (ii != a_transactions.end()) ? transaction(ii) : NULL;

    if(result == NULL) {
      if(emode == Exception::Mode::Throw) {
        std::string msg("Transaction: ");
        msg += identifierAsString(tid);
        msg += " | Tid not found";
        throw RuntimeException(msg, ANNA_FILE_LOCATION);
      } else if(emode == Exception::Mode::Trace && Logger::isActive(Logger::Warning)) {
        std::string msg("Transaction: ");
        msg += identifierAsString(tid);
        msg += " | Tid not found";
        Logger::warning(msg, ANNA_FILE_LOCATION);
      }
    }

    return result;
  }

  const Tid& getIdentifier(const Transaction* transaction) const
  noexcept(false) {
    if(transaction == NULL)
      throw RuntimeException("timex::Context::getIdentifier | Can not work with NULL transaction", ANNA_FILE_LOCATION);

    const void* context =  transaction->getContext();

    if(context == NULL) {
      std::string msg("timex::Context::getIdentifier | ");
      msg += transaction->asString();
      msg += " | Can not work with NULL context";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    return contextAsIdentifier(context);
  }

  void close(Transaction* transaction)
  {
    if(transaction == NULL)
      return;

    LOGINFORMATION(
      std::string msg("timex::Context::close | ");
      msg += transaction->asString();
      Logger::information(msg, ANNA_FILE_LOCATION);
    );

    try {
      a_timeController.cancel(transaction);
    } catch(RuntimeException& ex) {
      ex.trace();
    }
  }

  virtual xml::Node* asXML(xml::Node* parent) const
  {
    xml::Node* result = parent->createChild("timex.Context");
    result->createAttribute("Size", a_transactions.size());
    result->createAttribute("AvgSize", (a_counter == 0) ? 0 : a_accSize / a_counter);
    result->createChild("Timeout")->createAttribute("Millisecond", a_timeout.getValue());
    result->createChild("AvgResponseTime")->createAttribute("Millisecond", (a_counter == 0) ? 0 : a_accDelay / a_counter);
    return result;
  }

  static const Context* getInstance(const Transaction* transaction)
  noexcept(false) {
    if(transaction == NULL)
      throw RuntimeException("timex::Context::getInstance | Can not work with NULL transaction", ANNA_FILE_LOCATION);

    return reinterpret_cast <const Context*>(transaction->getObserver());
  }

protected:
  Context(const char* observerName, timex::Engine& timeController, const Millisecond& timeout) :
    TimeEventObserver(observerName),
    a_timeController(timeController),
    a_timeout(timeout) {
    a_counter = a_accDelay = a_accSize = 0;
  }

  virtual Transaction* createTransaction(const int classType)  = 0;

  virtual void releaseTransaction(Transaction* transaction)  = 0;

  virtual std::string identifierAsString(const Tid& tid) const  = 0;

  virtual const Tid& contextAsIdentifier(const void* tid) const  = 0;

private:
  typedef typename std::map <Tid, Transaction*> transaction_container;
  typedef typename transaction_container::iterator transaction_iterator;
  typedef typename transaction_container::value_type value_type;

  Engine& a_timeController;
  transaction_container a_transactions;
  Mutex a_mutex;
  Millisecond a_timeout;
  unsigned int a_counter;
  unsigned int a_accDelay;
  unsigned int a_accSize;

  /* Método re-implementado de timex::TimeEventObserver */
  void release(timex::TimeEvent* event)
  {
    Transaction* tt = static_cast <Transaction*>(event);
    Guard guard(a_mutex, "timex::Context::release");
    // Calcula la duración media de las transaciones de este contexto.
    const Millisecond &delay = tt->getDelay();
    const int size = a_transactions.size();

    /* Si desborda el acumulador de tiempo ... */
    if(++ a_counter == 0 || (a_accDelay + delay) < a_accDelay || (a_accSize + size) < a_accSize) {
      a_counter = 1;
      a_accDelay = 0;
      a_accSize = 0;
    }

    const Tid& tid(contextAsIdentifier(tt->getContext()));

    if(a_transactions.erase(tid) == 0) {
      std::string msg("Transaction: ");
      msg += identifierAsString(tid);
      msg += " | Tid can not be erased from map";
      Logger::warning(msg, ANNA_FILE_LOCATION);
    }

    releaseTransaction(tt);
    a_accDelay += delay;
    a_accSize += a_transactions.size();
  }

  static Transaction* transaction(transaction_iterator ii) { return ii->second; }
};

}
}

#endif