Entity.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_diameter_comm_Entity_hpp
#define anna_diameter_comm_Entity_hpp


// STL
#include <string>
#include <vector>

#include <anna/config/defines.hpp>

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

#include <anna/diameter.comm/ClassCode.hpp>


namespace anna {
class DataBlock;
namespace xml {
class Node;
}
}



namespace anna {

namespace diameter {

namespace comm {

class Engine;
class Server;
class Response;
class Message;
class ClientSession;


class Entity {

public:

  struct SessionBasedModelsType { enum _v { RoundRobin, SessionIdOptionalPart, SessionIdHighPart, SessionIdLowPart /* default */ }; };

private:


  std::vector<Server*> a_servers;
  int a_maxServers; // -1 means "no limit to add servers"
  std::string a_description;
  int a_category;
  std::vector<Server*>::iterator a_deliveryIterator;
  Server *a_lastUsedResource;

  // Engine
  Engine *a_engine;

  // Balance and socket selection:
  bool a_balance;
  SessionBasedModelsType::_v a_sessionBasedModelsType;

  // Availability
  bool a_available; // any of the servers must be bound
  void availabilityLost() ;
  void availabilityRecovered() ;
  bool refreshAvailability() ; // return true if change
  void assertReady() noexcept(false);
  void initialize() ;
  void childIdle() const ;

  // Selected for remove
  bool a_deprecated; // entity has been selected as deprecated (will be removed when idle)

  // internal helpers
  std::string a_socketListLiteral; // ADDRESS:PORT space-separated list
  std::string a_primarySocketLiteral; // ADDRESS:PORT for primary (used on standard entities)
  std::string a_secondarySocketLiteral; // ADDRESS:PORT for primary (used on standard entities)


  // Activity
  anna::Millisecond a_lastIncomingActivityTime;   // last unix timestamp (in milliseconds) when message reception was managed over this entity
  anna::Millisecond a_lastOutgoingActivityTime;   // last unix timestamp (in milliseconds) when message sending was managed over this entity
  void updateIncomingActivityTime() ;
  void updateOutgoingActivityTime() ;

  // Private close/destroy method
  void close(bool destroy) noexcept(false);

  // helpers
  static const char* asText(const SessionBasedModelsType::_v) ;

public:


  Entity(int maxServers = 2) : a_maxServers(maxServers) { initialize(); }


  void setMaxServers(int maxServers) { a_maxServers = maxServers; }

  int getMaxServers() const { return a_maxServers; }


  void setDescription(const std::string &description) { a_description = description; }

  const std::string & getDescription() const { return a_description; }


  void setEngine(Engine *e) { a_engine = e; }

  Engine *getEngine() const { return a_engine; }

  void addServer(const socket_t & serverId) noexcept(false);

  bool bind() noexcept(false);

  void raiseAutoRecovery(bool autoRecovery = true) noexcept(false);

  void setClassCodeTimeout(const ClassCode::_v v, const anna::Millisecond & millisecond) ;

  void setCategory(int category) { a_category = category; }

  int getCategory() const { return a_category; }

  Server *getLastUsedResource() const { return (a_lastUsedResource); }


   void setBalance (bool balance) { a_balance = balance; }

   bool getBalance() const { return a_balance; }


// SIMPLE BALANCE or STANDARD documentation version
//   /**
//      Sent a message to the entity. First uses primary server, secondary if fails and so on to the
//      last defined resource (server) within entity. Another sending algorithm (non standard) could
//      be enabled (balance boolean parameter): it consist in round-robin server selection without
//      trying any one if fails (standard behaviour tries all servers from FIRST defined).
//      Anyway, last used delivery resource could be known through #getLastUsedResource().
//
//      When the message is a request, a timer will be set automatically to control the response time.
//      If expires, the ResultCode Timeout will be finally notified on #Entity::eventResponse. This
//      timeout value will be configured at #setClassCodeTimeout.
//
//      \param message Message sent.
//      \param balance False by default (standard beaviour), but useful to balance over servers within entity.
//
//      @return Boolean about success in send operation. Standard behaviour (no balance) implies true result when any
//      of the entity servers could send the message, and false when neither of the servers was available or fail to
//      send the message. Broadcast try to send all over the resources in spite of any fail, and balanced sendings
//      fails when next selected resource fail to send the message (and no alarm or error counter is generated in
//      this case because it can't be understood/ensured as entity-sending fail.
//   */

// OJO: en el caso estandard, no se prueban todas las sessiones de un servidor si tiene mas de una, luego la alarma
//      generada en caso de error, presupone que las sessiones no usadas, tambi�n dar�an error, lo cual no tiene porque
//      ser cierto. En condiciones normales, los servidores tienen una session, con lo que lo anterior es cierto y el
//      la practica es lo mas normal.

  bool send(const Message *message) noexcept(false);
  bool send(const Message &message) noexcept(false) { return send(&message); }

  void setSessionBasedModelsType(const SessionBasedModelsType::_v sessionBasedModelsType)  { a_sessionBasedModelsType = sessionBasedModelsType; }

  SessionBasedModelsType::_v getSessionBasedModelsType() const { return a_sessionBasedModelsType; }


  virtual int readSocketId(const Message *message, int maxClientSessions) const ;


  bool broadcast(const Message *message) noexcept(false);
  bool broadcast(const Message &message) noexcept(false) { return broadcast(&message); }


  bool isAvailable() const { return a_available; }

  bool isDeprecated() const { return a_deprecated; }

  void setDeprecated(bool deprecated = true) { a_deprecated = deprecated; }


  int getOTARequests() const ;

  bool idle() const { return (getOTARequests() == 0); }


  std::vector<Server*>::iterator begin() { return a_servers.begin(); }
  std::vector<Server*>::iterator end() { return a_servers.end(); }
  std::vector<Server*>::const_iterator begin() const { return a_servers.begin(); }
  std::vector<Server*>::const_iterator end() const { return a_servers.end(); }

  void close() noexcept(false) { close(false /* no destroy */); }

  // helpers

  int getNumberOfServers() const { return a_servers.size(); }

  int getMaxServerss() const { return a_maxServers; }

  socket_v getAddressPortList() const ;


  void hide() ;

  void show() ;

  bool hidden() const ;

  bool shown() const ;


  std::string asString() const ;

  anna::xml::Node* asXML(anna::xml::Node* parent) const ;

protected:

  virtual void eventPeerShutdown(const ClientSession* clientSession) ;

  virtual void eventRequestRetransmission(const ClientSession* clientSession, Message *request) ;

  virtual void eventResponse(const Response& response, const anna::diameter::comm::OriginHost *myNode) noexcept(false) = 0;

  virtual void eventRequest(ClientSession* clientSession, const anna::DataBlock &request, const anna::diameter::comm::OriginHost *myNode) noexcept(false) = 0;
  //virtual void eventRequest(ClientSession* clientSession, const Message& request) noexcept(false) = 0;

  virtual void eventUnknownResponse(ClientSession *clientSession, const anna::DataBlock& response, const anna::diameter::comm::OriginHost *myNode) noexcept(false) = 0;

  virtual void eventDPA(ClientSession *clientSession, const anna::DataBlock& response, const anna::diameter::comm::OriginHost *myNode) noexcept(false) = 0;




  friend class Engine;
  friend class Server;
};

}
}
}

#endif