Engine.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_Engine_hpp
#define anna_diameter_comm_Engine_hpp


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

#include <anna/app/Component.hpp>
#include <anna/core/util/Recycler.hpp>

#include <anna/diameter/codec/Engine.hpp>
#include <anna/diameter.comm/Server.hpp>
#include <anna/diameter.comm/ServerSession.hpp>
#include <anna/config/defines.hpp>
#include <anna/diameter.comm/ClientSession.hpp>
#include <anna/diameter.comm/ServerSession.hpp>
#include <anna/core/util/defines.hpp> // U32


// Standard
#include <time.h>


//------------------------------------------------------------------------------
//---------------------------------------------------------------------- #define
//------------------------------------------------------------------------------

namespace anna {
class DataBlock;
class Millisecond;
}



namespace anna {

namespace diameter {

namespace codec {
class Engine;
}

namespace stack {
class Dictionary;
}

namespace comm {

class Response;
class Entity;
class Server;
class LocalServer;

class Engine : public anna::app::Component {
public:

  void setOriginRealmName(const std::string & originRealmName) ;

  void setOriginHostName(const std::string & originHostName) ;

  const std::string & getOriginRealmName() const { return a_originRealm; }

  const std::string & getOriginHostName() const { return a_originHost; }


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

  bool getAutoBind() const { return a_autoBind; }

  void setAutoBind(const bool autoBind) { a_autoBind = autoBind; }

  void setMaxConnectionDelay(const anna::Millisecond & maxConnectionDelay) { a_maxConnectionDelay = maxConnectionDelay; }

  const anna::Millisecond & getMaxConnectionDelay() { return a_maxConnectionDelay; }

  bool bind() noexcept(false);

  void setClientCER(const anna::DataBlock & cer) noexcept(false);

  void setClientCER(const std::string & cerPathFile) noexcept(false);

  void setClientCER(const anna::U32 &applicationId) noexcept(false);

  void setClientDWR(const anna::DataBlock & dwr) noexcept(false);

  void setClientDWR(const std::string & dwrPathFile = "") noexcept(false);

  void setWatchdogPeriod(const anna::Millisecond & wp) noexcept(false);

  int getNumberOfClientSessionsPerServer() const { return a_numberOfClientSessionsPerServer; }

  void setNumberOfClientSessionsPerServer(int numberOfClientSessionsPerServer) { a_numberOfClientSessionsPerServer = numberOfClientSessionsPerServer; }


  ClientSession* findClientSession(const std::string & addr, int port, int socketId, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) noexcept(false);


  ClientSession* findClientSession(const std::string & key, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) noexcept(false);


  Server* findServer(const std::string & addr, int port, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) noexcept(false);

  Entity* findEntity(const socket_v & socketList, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) noexcept(false);

  Entity* findEntity(const std::string & addr1, int port1, const std::string & addr2, int port2, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) noexcept(false);

  Entity* createEntity(const socket_v & socketList, const std::string & description = "")
  noexcept(false);

  Entity* createEntity(const std::string & addr1, int port1, const std::string & addr2, int port2, const std::string & description = "")
  noexcept(false);


  LocalServer* findLocalServer(const std::string & addr, int port, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) noexcept(false);

  ServerSession* findServerSession(int socketId, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) noexcept(false);

  LocalServer *createLocalServer(const std::string & addr, int port = Session::DefaultPort, int maxConnections = -1, const anna::Millisecond & allowedInactivityTime = ServerSession::DefaultAllowedInactivityTime, int category = 1, const std::string & description = "")
  noexcept(false);


  void close(bool destroy = false) noexcept(false) { closeEntities(destroy); closeLocalServers(destroy); }


  void closeEntities(bool destroy = false) noexcept(false);


  void closeEntity(Entity* entity, bool destroy = false) noexcept(false);


  void closeLocalServers(bool destroy = false) noexcept(false);

  void closeLocalServer(LocalServer * localServer, bool destroy = false) noexcept(false);

  int getOTARequestsForEntities() const ;

  int getOTARequestsForLocalServers() const ;

  int getOTARequests() const { return (getOTARequestsForEntities() + getOTARequestsForLocalServers()); }

  bool idleForEntities() const { return (getOTARequestsForEntities() == 0); }

  bool idleForLocalServers() const { return (getOTARequestsForLocalServers() == 0); }

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

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

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

  virtual std::string asString(void) const ;

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

  virtual void bindingClientSession(const ClientSession *) const {;}

  virtual void readDPA(anna::DataBlock &dpa, const anna::DataBlock & dpr) const;

  void setCEA(const std::string &ceaPathfile) { a_ceaPathfile = ceaPathfile; }

  const std::string & getCEA() const { return a_ceaPathfile; }

  virtual void readCEA(anna::DataBlock &cea, const anna::DataBlock & cer) const;

  virtual void readDWA(anna::DataBlock &dwa, const anna::DataBlock & dwr) const;

  const Response* sendRealmHost(const Message* message, const std::string &destinationRealm, const std::string &destinationHost = "") noexcept(false);

  void resetStatistics() ;


  void lazyInitialize() noexcept(false);


protected:
  Engine(const char *className, const stack::Dictionary *baseProtocolDictionary);

  // INTERNAL CREATORS AND CLOSE METHODS
  Server *createServer(Entity*, const socket_t&) noexcept(false);
  void closeServer(Server*, bool) noexcept(false);
  ClientSession *createClientSession(Server*, int) noexcept(false);
  void closeClientSession(ClientSession*, bool) noexcept(false);

  // INTERNAL ALLOCATORS
  Server* allocateServer() ;
  void releaseServer(Server*) ;
  ClientSession* allocateClientSession() ;
  void releaseClientSession(ClientSession*) ;


  virtual Entity* allocateEntity() { return NULL; }


  virtual void releaseEntity(Entity*) {;}


  virtual LocalServer* allocateLocalServer() { return NULL; }


  virtual void releaseLocalServer(LocalServer*) {;}

  //  Gets the base protocol codec engine used internally.
  //  This engine is initializaed on constructor with the base protocol dictionary.
  //  The reason to not reuse any other codec engine from the application is to have this one isolated with no interference
  //  regarding configuration changes (validation depth/mode, fix mode, etc.).
  //
  //  @return Pointer to the internal base protocol codec engine
  codec::Engine *getBaseProtocolCodecEngine() const { return const_cast<codec::Engine *>(&a_baseProtocolCodecEngine); }

private:

  // Internal use: tracing and readCEA/DPA/DWA
  codec::Engine a_baseProtocolCodecEngine;

  std::string a_originRealm;
  std::string a_originHost;
  bool a_autoBind;
  int a_numberOfClientSessionsPerServer;


  // ClientSessions messages:
  anna::DataBlock a_client_cer;
  anna::DataBlock a_client_dwr;
  anna::Millisecond a_watchdogPeriod;

  // ServerSessions messages: no need for DWA and DPA templates, they are built on the fly (enough information).
  std::string a_ceaPathfile; // path file to optional CEA (diameter local server configuration)

  // Client connectivity
  anna::Millisecond a_maxConnectionDelay;


  // Availability
  bool a_availableForEntities; // any of the entities must be bound
  void availabilityLostForEntities() ;
  void availabilityRecoveredForEntities() ;
  bool refreshAvailabilityForEntities() ; // return true if change

  bool a_availableForLocalServers; // any of the local servers must be bound
  void availabilityLostForLocalServers() ;
  void availabilityRecoveredForLocalServers() ;
  bool refreshAvailabilityForLocalServers() ; // return true if change

  void eraseDeprecatedIdleEntities() ;

  // Component:
  void do_initialize() noexcept(false);
  void do_stop() ;

  // Integrity:
  void checkEntityCollision(const socket_v &) noexcept(false);
  void assertBaseProtocolHealth() const noexcept(false); // checks the dictionary


  // CLIENT FUNCTIONALITY //

  typedef std::string clientSession_key; // 'ADDR:PORT|id'
  typedef std::map <clientSession_key, ClientSession*> clientSession_container;
  typedef clientSession_container::value_type clientSession_value_type;
  typedef clientSession_container::iterator clientSession_iterator;
  typedef clientSession_container::const_iterator const_clientSession_iterator;
  clientSession_container a_clientSessions;
  anna::Recycler<ClientSession> a_clientSessionsRecycler;
  clientSession_iterator clientSession_find(const clientSession_key&) ;
  clientSession_iterator clientSession_begin() { return a_clientSessions.begin(); }
  clientSession_iterator clientSession_end() { return a_clientSessions.end(); }
  static ClientSession* clientSession(clientSession_iterator ii) { return ii->second; }
  const_clientSession_iterator clientSession_begin() const { return a_clientSessions.begin(); }
  const_clientSession_iterator clientSession_end() const { return a_clientSessions.end(); }
  static const ClientSession* clientSession(const_clientSession_iterator ii) { return ii->second; }

  typedef socket_t server_key;
  server_key getServerKey(const std::string & addr, int port) const ;
  typedef std::map <server_key, Server*> server_container;
  typedef server_container::value_type server_value_type;
  typedef server_container::iterator server_iterator;
  typedef server_container::const_iterator const_server_iterator;
  server_container a_servers;
  anna::Recycler<Server> a_serversRecycler;
  server_iterator server_find(const server_key&) ;
  server_iterator server_begin() { return a_servers.begin(); }
  server_iterator server_end() { return a_servers.end(); }
  static Server* server(server_iterator ii) { return ii->second; }
  const_server_iterator server_begin() const { return a_servers.begin(); }
  const_server_iterator server_end() const { return a_servers.end(); }
  static const Server* server(const_server_iterator ii) { return ii->second; }

  typedef std::string entity_key; // 'ADDR1:PORT1 ADDR2:PORT2 ADDR3:PORT3 ...'
  entity_key getEntityKey(const socket_v &) const ;
  entity_key getEntityKey(const std::string & addr1, int port1, const std::string & addr2, int port2) const ;
  typedef std::map <entity_key, Entity*> entity_container;
  typedef entity_container::value_type entity_value_type;
  typedef entity_container::iterator entity_iterator;
  typedef entity_container::const_iterator const_entity_iterator;
  entity_container a_entities;
  entity_iterator entity_find(const entity_key&) ;
  entity_iterator entity_begin() { return a_entities.begin(); }
  entity_iterator entity_end() { return a_entities.end(); }
  static Entity* entity(entity_iterator ii) { return ii->second; }
  const_entity_iterator entity_begin() const { return a_entities.begin(); }
  const_entity_iterator entity_end() const { return a_entities.end(); }
  static const Entity* entity(const_entity_iterator ii) { return ii->second; }


  // SERVER FUNCTIONALITY //

  // Local servers
  typedef std::map <socket_t, LocalServer*> localServer_container;
  typedef localServer_container::value_type localServer_value_type;
  typedef localServer_container::iterator localServer_iterator;
  typedef localServer_container::const_iterator const_localServer_iterator;
  localServer_container a_localServers;
  localServer_iterator localServer_find(const socket_t&) ;
  localServer_iterator localServer_begin() { return a_localServers.begin(); }
  localServer_iterator localServer_end() { return a_localServers.end(); }
  static LocalServer* localServer(localServer_iterator ii) { return ii->second; }
  const_localServer_iterator localServer_begin() const { return a_localServers.begin(); }
  const_localServer_iterator localServer_end() const { return a_localServers.end(); }
  static const LocalServer* localServer(const_localServer_iterator ii) { return ii->second; }

  // Server sessions are managed within LocalServer (not at engine) due to dynamic creation nature
  // Here we maintain the Destination-Realm / Destination-Host maps for DRA basics:
  typedef std::vector<ServerSession*> server_sessions_vector_t;
  typedef server_sessions_vector_t::const_iterator server_sessions_it_t;
  typedef server_sessions_vector_t::iterator server_sessions_nc_it_t;
  typedef std::map <std::string /* Destination-Host */, server_sessions_vector_t> dh_server_sessions_map_t;
  typedef dh_server_sessions_map_t::const_iterator dh_server_sessions_it_t;
  typedef dh_server_sessions_map_t::iterator dh_server_sessions_nc_it_t;
  typedef std::map <std::string /* Destination-Realm */, dh_server_sessions_map_t> dr_dh_server_sessions_map_t;
  typedef dr_dh_server_sessions_map_t::const_iterator dr_dh_server_sessions_it_t;
  typedef dr_dh_server_sessions_map_t::iterator dr_dh_server_sessions_nc_it_t;
  dr_dh_server_sessions_map_t a_dr_dh_server_sessions;
  void manageDrDhServerSession(ServerSession *ss, bool register_or_desregister) ;

  friend class Session;
  friend class ClientSession;
  friend class ServerSession;
  friend class ServerSocket;
  friend class Server;
  friend class Entity;
  friend class LocalServer;
  //friend class Message;
};

}
}
}

#endif