include/anna/diameter.comm/Server.hpp

   1 // ANNA - Anna is Not Nothingness Anymore                                                         //
   2 //                                                                                                //
   3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
   4 //                                                                                                //
   5 // See project site at http://redmine.teslayout.com/projects/anna-suite                           //
   6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
   7
   8
   9 #ifndef anna_diameter_comm_Server_hpp
  10 #define anna_diameter_comm_Server_hpp
  11
  12
  13 // STL
  14 #include <string>
  15 #include <vector>
  16 #include <map>
  17
  18 // Project
  19 #include <anna/core/util/Millisecond.hpp>
  20 #include <anna/core/RuntimeException.hpp>
  21 #include <anna/diameter/defines.hpp>
  22 #include <anna/config/defines.hpp>
  23 #include <anna/diameter.comm/ClassCode.hpp>
  24 #include <anna/diameter.comm/MessageStatistics.hpp>
  25
  26
  27
  28
  29 namespace anna {
  30 class DataBlock;
  31 namespace timex {
  32 class Engine;
  33 }
  34 }
  35
  36
  37 namespace anna {
  38
  39 namespace diameter {
  40
  41 namespace comm {
  42
  43 class Engine;
  44 class Entity;
  45 class ClientSession;
  46 class Response;
  47 class Message;
  48
  49
  50 /**
  51    Diameter server with 1..N connections.
  52 */
  53 class Server {
  54
  55   // Parent information
  56   Entity *a_parent;
  57
  58   // Main server attributes
  59   socket_t a_socket;
  60
  61   // ClientSessions
  62   std::vector<ClientSession*> a_clientSessions;
  63   int a_maxClientSessions; // -1 means "no limit to add client-sessions" (sockets per server)
  64   std::vector<ClientSession*>::iterator a_deliveryIterator;
  65   ClientSession *a_lastUsedResource;
  66
  67   // Activity
  68   anna::Millisecond a_lastIncomingActivityTime;   // last unix timestamp (in milliseconds) when message reception was managed over this server
  69   anna::Millisecond a_lastOutgoingActivityTime;   // last unix timestamp (in milliseconds) when message sending was managed over this server
  70   void updateIncomingActivityTime() throw();
  71   void updateOutgoingActivityTime() throw();
  72
  73   // Engine
  74   Engine *a_engine;
  75
  76   // Statistics
  77   MessageStatistics a_messageStatistics;
  78   void initializeStatisticResources() throw();
  79   void resetStatistics() throw();
  80
  81   // Availability
  82   bool a_available; // any of the client-sessions must be bound
  83   void availabilityLost() throw();
  84   void availabilityRecovered() throw();
  85   bool refreshAvailability() throw(); // return true if change
  86   void assertReady() throw(anna::RuntimeException);
  87   void initialize() throw();
  88   void childIdle() const throw();
  89
  90   // Private close/destroy method
  91   void close(bool destroy) throw(anna::RuntimeException);
  92
  93
  94 public:
  95
  96
  97   /**
  98    * Default constructor.
  99    * @param maxClientSessions Maximum number of client-sessions managed by the server. Default is 1 (monoconnection server).
 100    * The value -1, means no limit to add client-sessions.
 101    */
 102   Server(int maxClientSessions = 1) : a_maxClientSessions(maxClientSessions) { initialize(); }
 103
 104   /** Destructor */
 105   virtual ~Server() {;}
 106
 107
 108   /**
 109   * Add a server to the entity and create all the client-sessions configured at #setSocketsPerDiameterServer within that server.
 110   *
 111   * \param socketId Diameter socket identifier within the server.
 112   */
 113   void addClientSession(int socketId) throw(anna::RuntimeException);
 114
 115   /**
 116      Set timeout to consider failed a request.
 117      \param v Requests class code.
 118      \param millisecond Milliseconds wait before considering the requests failed.
 119
 120      Timers are internally managed and automatically activated.
 121   */
 122   void setClassCodeTimeout(const ClassCode::_v v, const anna::Millisecond & millisecond) throw();
 123
 124   /**
 125    * Binds server client-sessions.
 126    *
 127    * @return Returns true if all client-session were successfully bound
 128    */
 129   bool bind() throw(anna::RuntimeException);
 130
 131   /**
 132    * Propagate auto recovery configuration to client-sessions within server
 133    *
 134    * @param autoRecovery Auto recovery indicator. True by default.
 135    */
 136   void raiseAutoRecovery(bool autoRecovery = true) throw(anna::RuntimeException);
 137
 138
 139 // Sent a message to the server using a certain client-session by mean round-robin between socketId's for
 140 //  multiple client client-sessions functionality. If a specific socketId is provided, then uses such specific client-session.
 141 // Last used delivery resource could be known through #getLastUsedResource().
 142   bool send(const Message*, int socketId = -1 /* client-sessions round-robin */) throw(anna::RuntimeException);
 143   bool send(const Message& message, int socketId = -1 /* client-sessions round-robin */) throw(anna::RuntimeException) { return send(&message, socketId); }
 144
 145   /**
 146      Gets the last used resource (client session) during sending.
 147      Broadcast doesn't updates this information.
 148   */
 149   ClientSession *getLastUsedResource() const throw() { return (a_lastUsedResource); }
 150
 151   /**
 152      Sent a message to all the server client-sessions (socketId's) for multiple client client-sessions functionality.
 153      It is used, i.e., in Disconnect-Peer-Request procedure over a certain server.
 154      Returns true (success) only when broadcast is success over all the server client-sessions. If any client-session fails,
 155      then false is returned. Broadcast try to send all over the resources in spite of any fail.
 156   */
 157   bool broadcast(const Message*) throw(anna::RuntimeException);
 158   bool broadcast(const Message& message) throw(anna::RuntimeException) { return broadcast(&message); }
 159
 160   /**
 161      Close all the server client-sessions. Depending on client-session configuration ('OnDisconnect' behaviour),
 162      pending answers will be wait (graceful) or ignored (immediate-abrupt close).
 163      Resources are not destroyed.
 164   */
 165   void close() throw(anna::RuntimeException) { close(false /* no destroy */); }
 166
 167
 168   /**
 169      Diameter parent entity.
 170      \return Diameter parent entity.
 171   */
 172   const Entity *getParent() const throw() { return a_parent; }
 173
 174   /**
 175      Returns true when any of the server client-sessions is Bound. False when all not-bound.
 176   */
 177   bool isAvailable() const throw() { return a_available; }
 178
 179
 180   std::vector<ClientSession*>::iterator begin() throw() { return a_clientSessions.begin(); }
 181   std::vector<ClientSession*>::iterator end() throw() { return a_clientSessions.end(); }
 182   std::vector<ClientSession*>::const_iterator begin() const throw() { return a_clientSessions.begin(); }
 183   std::vector<ClientSession*>::const_iterator end() const throw() { return a_clientSessions.end(); }
 184
 185   int getNumberOfClientSessions() const throw() { return a_clientSessions.size(); }
 186   int getMaxClientSessions() const throw() { return a_maxClientSessions; }
 187   void setMaxClientSessions(int maxClientSessions) throw() { a_maxClientSessions = maxClientSessions; }
 188
 189   /**
 190      Diameter server  address (IP or hostname)
 191      \return Diameter server address.
 192   */
 193   const std::string& getAddress() const throw() { return a_socket.first; }
 194
 195   /**
 196      Diameter server port.
 197      \return Diameter server port.
 198   */
 199   int getPort() const throw() { return a_socket.second; }
 200
 201
 202   /** Server presentation as 'ADDRESS:PORT' */
 203   std::string socketAsString() const throw();
 204
 205
 206   /**
 207      Gets the timestamp for last incoming activity over the server.
 208
 209      @return Last incoming activity timestamp.
 210   */
 211   const anna::Millisecond & getLastIncomingActivityTime() const throw() { return a_lastIncomingActivityTime; }
 212
 213   /**
 214      Gets the timestamp for last outgoing activity over the server.
 215
 216      @return Last outgoing activity timestamp.
 217   */
 218   const anna::Millisecond & getLastOutgoingActivityTime() const throw() { return a_lastOutgoingActivityTime; }
 219
 220
 221   /**
 222      Gets the number of requests messages over-the-air.
 223
 224      @return OTA messages.
 225   */
 226   int getOTARequests() const throw();
 227
 228   /**
 229      Returns idle state (no pending answers).
 230
 231      @return Idle state.
 232   */
 233   bool idle() const throw() { return (getOTARequests() == 0); }
 234
 235
 236   /**
 237      Deny resources for delivery restriction.
 238      Deny all its client sessions
 239   */
 240   void hide() throw();
 241
 242   /**
 243      Allow resource for delivery permission.
 244      Allow all its client sessions
 245   */
 246   void show() throw();
 247
 248   /**
 249      Returns true when all its client session resources are hidden for application messages delivery
 250   */
 251   bool hidden() const throw();
 252
 253   /**
 254      Returns true when all its client session resources are shown for application messages delivery
 255   */
 256   bool shown() const throw();
 257
 258
 259   /**
 260      Class string representation
 261      \return String with relevant information for this instance.
 262   */
 263   std::string asString() const throw();
 264
 265   /**
 266      Class xml representation
 267      \param parent Parent XML node on which hold this instance information.
 268      \return XML document with relevant information for this instance.
 269   */
 270   anna::xml::Node* asXML(anna::xml::Node* parent) const throw();
 271
 272
 273   // Statistics
 274   void updateProcessingTimeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) throw();
 275   void updateReceivedMessageSizeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) throw();
 276 //  int getProcessingTimeStatisticConcept() const throw() { return a_processing_time__StatisticConceptId; }
 277 //  int getReceivedMessageSizeStatisticConcept() const throw() { return a_received_message_size__StatisticConceptId; }
 278
 279 protected:
 280
 281   /**
 282      Handler about event break connection from diameter server (client-session) over this entity.
 283
 284      When notified, ANNA.diameter.comm generates an diameter::comm::Entity::eventResponse for every request with pending answers.
 285   */
 286   virtual void eventPeerShutdown(const ClientSession*) throw();
 287
 288   /**
 289      Handler about a request retransmission over the session.
 290
 291      \param request Message retransmitted
 292   */
 293   virtual void eventRequestRetransmission(const ClientSession*, Message *request) throw();
 294
 295   /**
 296      Handler for diameter server (client-session) responses
 297
 298      \param response Answer container object for corresponding diameter request
 299   */
 300   virtual void eventResponse(const Response & response) throw(anna::RuntimeException);
 301
 302   /**
 303      Handler for diameter server (client-session) requests
 304
 305      \param clientSession ClientSession from which request has been received
 306      \param request Diameter request message received
 307   */
 308   virtual void eventRequest(ClientSession *clientSession, const anna::DataBlock &request) throw(anna::RuntimeException);
 309   //virtual void eventRequest(ClientSession *clientSession, const Message & request) throw(anna::RuntimeException);
 310
 311   /**
 312      Handler for diameter server (client-session) responses out of context
 313
 314      \param clientSession ClientSession from which request has been received
 315      \param response Answer data block object without context match
 316   */
 317   virtual void eventUnknownResponse(ClientSession *clientSession, const anna::DataBlock& response) throw(anna::RuntimeException);
 318
 319   /**
 320      Handler for diameter server (client-session) Disconnect-Peer-Answer messages
 321
 322      \param clientSession ClientSession from which request has been received
 323      \param response Answer data block object without context match
 324   */
 325   virtual void eventDPA(ClientSession *clientSession, const anna::DataBlock& response) throw(anna::RuntimeException);
 326
 327
 328
 329   friend class Engine;
 330   friend class ClientSession;
 331 };
 332
 333 }
 334 }
 335 }
 336
 337 #endif