LocalServer.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_LocalServer_hpp
#define anna_diameter_comm_LocalServer_hpp


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

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

// Project
#include <anna/config/defines.hpp>
#include <anna/diameter.comm/ServerSession.hpp>
#include <anna/diameter/defines.hpp>
#include <anna/diameter.comm/MessageStatistics.hpp>


namespace anna {
namespace xml {
class Node;
}
namespace comm {
class ClientSocket;
//class LocalConnection;
}
class DataBlock;
}

namespace anna {

namespace diameter {

namespace comm {

class Response;
class ServerSocket;
class Message;
class Engine;


class LocalServer {

  // main
  socket_t a_key;
  std::string a_description;
  int a_maxConnections;
  int a_currentConnections; // deberia coincidir en todo momento con el numero de local connections del server socket
  anna::Millisecond a_allowedInactivityTime;
  ServerSocket *a_serverSocket;
  int a_category;
  bool a_lock;

  // Engine
  Engine *a_engine; // only for refresh availability

  // Statistics
  MessageStatistics a_messageStatistics;
  void initializeStatisticResources() ;
  void resetStatistics() ;

//   void eraseServerSession(const anna::comm::ClientSocket& clientSocket) ;
//   void eraseServerSession(const serverSession_iterator &it) ;
  void lostConnection() ;
  void newConnection() noexcept(false);

  // 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() ;

  // Availability
  bool a_available; // any of the server-sessions must be bound
  void availabilityLost() ;
  void availabilityRecovered() ;
  bool refreshAvailability() ; // return true if change

  void attach() ; // attach server socket to the communicator
  void attachPlanning() ; // used when attach fails (socket already in use, etc.)

  typedef int serverSession_key;
  serverSession_key getServerSessionKey(const anna::comm::ClientSocket&) const ; // hash for Client Socket INetAddress serialization
  typedef std::map <serverSession_key, ServerSession*> serverSession_container;
  typedef serverSession_container::value_type serverSession_value_type;
  typedef serverSession_container::iterator serverSession_iterator;
  typedef serverSession_container::const_iterator const_serverSession_iterator;
  serverSession_container a_serverSessions;
  anna::Recycler<ServerSession> a_serverSessionsRecycler;
  serverSession_iterator serverSession_find(const serverSession_key&) ;
  serverSession_iterator serverSession_begin() { return a_serverSessions.begin(); }
  serverSession_iterator serverSession_end() { return a_serverSessions.end(); }
  static ServerSession* serverSession(serverSession_iterator ii) { return ii->second; }
  const_serverSession_iterator serverSession_begin() const { return a_serverSessions.begin(); }
  const_serverSession_iterator serverSession_end() const { return a_serverSessions.end(); }
  static const ServerSession* serverSession(const_serverSession_iterator ii) { return ii->second; }

  // INTERNAL CREATORS AND CLOSE METHODS
  ServerSession *createServerSession(const anna::comm::ClientSocket&) noexcept(false);
  void closeServerSession(ServerSession*) noexcept(false);

  // INTERNAL ALLOCATORS
  ServerSession* allocateServerSession() ;
  void releaseServerSession(ServerSession*) ;

  // Auxiliary
  serverSession_iterator a_deliveryIterator;
  ServerSession *a_lastUsedResource;

public:

  LocalServer();

  ~LocalServer() { close(); }


  // setters

  void setKey(const socket_t &key) { a_key = key; }

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

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

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

  void setMaxConnections(int maxConnections) noexcept(false);

  void setAllowedInactivityTime(const anna::Millisecond & allowedInactivityTime) { a_allowedInactivityTime = allowedInactivityTime; }

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

  // getters

  const socket_t & getKey() const { return a_key; }

  int getMaxConnections() const { return a_maxConnections; }

  int getCurrentConnections() const { return a_currentConnections; }

  const anna::Millisecond & getAllowedInactivityTime() const { return a_allowedInactivityTime; }

  bool isAvailable() const { return a_available; }

  // helpers

  void disable(bool lock = false) noexcept(false);

  void enable(bool unlock = false) noexcept(false);

  int getOTARequests() const ;

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

  void close() noexcept(false);

  void resetConnectionsMargin() noexcept(false) { setMaxConnections(a_currentConnections); }


  ServerSession* findServerSession(const anna::comm::ClientSocket &clientSocket, 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);


  bool send(const Message*, int socketId = -1 /* default uses readSocketId() */) noexcept(false);
  bool send(const Message& message, int socketId = -1 /* default uses readSocketId() */) noexcept(false) { return send(&message, socketId); }

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

  virtual int readSocketId(const Message *message) const { return -1; }

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


  std::string asString() const ;

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

  // Statistics
  void updateProcessingTimeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) ;
  void updateReceivedMessageSizeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) ;
//  int getProcessingTimeStatisticConcept() const { return a_processing_time__StatisticConceptId; }
//  int getReceivedMessageSizeStatisticConcept() const { return a_received_message_size__StatisticConceptId; }

protected:

  // Handlers:
  virtual void eventPeerShutdown(const ServerSession* serverSession) ;

  virtual void eventRequestRetransmission(const ServerSession* serverSession, Message *request) ;

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

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

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

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


  friend class anna::diameter::comm::Timer;
  friend class Engine;
  friend class ServerSocket;
  friend class ServerSession;
  friend class ServerSessionReceiver;
};

}
}
}

#endif