e0ce97c7e2ad77345178c0c987a6118276c47392
[anna.git] / include / anna / diameter.comm / LocalServer.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_LocalServer_hpp
10 #define anna_diameter_comm_LocalServer_hpp
11
12
13 #include <anna/core/RuntimeException.hpp>
14 #include <anna/core/util/Millisecond.hpp>
15 #include <anna/core/util/Recycler.hpp>
16
17 // STL
18 #include <string>
19 #include <vector>
20 #include <map>
21
22 // Project
23 #include <anna/config/defines.hpp>
24 #include <anna/diameter.comm/ServerSession.hpp>
25 #include <anna/diameter/defines.hpp>
26 #include <anna/diameter.comm/MessageStatistics.hpp>
27
28
29 namespace anna {
30 namespace xml {
31 class Node;
32 }
33 namespace comm {
34 class ClientSocket;
35 //class LocalConnection;
36 }
37 class DataBlock;
38 }
39
40 namespace anna {
41
42 namespace diameter {
43
44 namespace comm {
45
46 class Engine;
47 class Response;
48 class ServerSocket;
49 class Message;
50
51
52 /**
53    Diameter server socket
54 */
55 class LocalServer {
56
57   // main
58   socket_t a_key;
59   std::string a_description;
60   int a_maxConnections;
61   int a_currentConnections; // deberia coincidir en todo momento con el numero de local connections del server socket
62   anna::Millisecond a_allowedInactivityTime;
63   ServerSocket *a_serverSocket;
64   int a_category;
65   bool a_lock;
66
67   // Engine
68   Engine *a_engine;
69
70   // Statistics
71   MessageStatistics a_messageStatistics;
72   void initializeStatisticResources() throw();
73   void resetStatistics() throw();
74
75 //   void eraseServerSession(const anna::comm::ClientSocket& clientSocket) throw();
76 //   void eraseServerSession(const serverSession_iterator &it) throw();
77   void lostConnection() throw();
78   void newConnection() throw(anna::RuntimeException);
79
80   // Activity
81   anna::Millisecond a_lastIncomingActivityTime;   // last unix timestamp (in milliseconds) when message reception was managed over this entity
82   anna::Millisecond a_lastOutgoingActivityTime;   // last unix timestamp (in milliseconds) when message sending was managed over this entity
83   void updateIncomingActivityTime() throw();
84   void updateOutgoingActivityTime() throw();
85
86   // Availability
87   bool a_available; // any of the server-sessions must be bound
88   void availabilityLost() throw();
89   void availabilityRecovered() throw();
90   bool refreshAvailability() throw(); // return true if change
91
92   void attach() throw(); // attach server socket to the communicator
93   void attachPlanning() throw(); // used when attach fails (socket already in use, etc.)
94
95   typedef int serverSession_key;
96   serverSession_key getServerSessionKey(const anna::comm::ClientSocket&) const throw(); // hash for Client Socket INetAddress serialization
97   typedef std::map <serverSession_key, ServerSession*> serverSession_container;
98   typedef serverSession_container::value_type serverSession_value_type;
99   typedef serverSession_container::iterator serverSession_iterator;
100   typedef serverSession_container::const_iterator const_serverSession_iterator;
101   serverSession_container a_serverSessions;
102   anna::Recycler<ServerSession> a_serverSessionsRecycler;
103   serverSession_iterator serverSession_find(const serverSession_key&) throw();
104   serverSession_iterator serverSession_begin() throw() { return a_serverSessions.begin(); }
105   serverSession_iterator serverSession_end() throw() { return a_serverSessions.end(); }
106   static ServerSession* serverSession(serverSession_iterator ii) throw() { return ii->second; }
107   const_serverSession_iterator serverSession_begin() const throw() { return a_serverSessions.begin(); }
108   const_serverSession_iterator serverSession_end() const throw() { return a_serverSessions.end(); }
109   static const ServerSession* serverSession(const_serverSession_iterator ii) throw() { return ii->second; }
110
111   // INTERNAL CREATORS AND CLOSE METHODS
112   ServerSession *createServerSession(const anna::comm::ClientSocket&) throw(anna::RuntimeException);
113   void closeServerSession(ServerSession*) throw(anna::RuntimeException);
114
115   // INTERNAL ALLOCATORS
116   ServerSession* allocateServerSession() throw();
117   void releaseServerSession(ServerSession*) throw();
118
119   // Auxiliary
120   serverSession_iterator a_deliveryIterator;
121   ServerSession *a_lastUsedResource;
122
123 public:
124
125   /** Constructor */
126   LocalServer();
127
128   /** Destructor */
129   ~LocalServer() { close(); }
130
131
132   // setters
133
134   /**
135   * Sets the local server key
136   * @param LocalServer key
137   */
138   void setKey(const socket_t &key) throw() { a_key = key; }
139
140   /**
141      Sets the server socket optional description
142
143      @param description Server socket description
144   */
145   void setDescription(const std::string description) throw() { a_description = description; }
146
147   /**
148      Set timeout to consider failed a request.
149      \param v Requests class code.
150      \param millisecond Milliseconds wait before considering the requests failed.
151
152      Timers are internally managed and automatically activated.
153   */
154   void setClassCodeTimeout(const ClassCode::_v v, const anna::Millisecond & millisecond) throw();
155
156   /**
157      Sets the server socket optional category
158
159      @param description Server socket category
160   */
161   void setCategory(int category) throw() { a_category = category; }
162
163   /**
164      Sets the maximum supported connections.
165      If provided value is negative or lesser than the number of current connections, an exception will be launched.
166      If all the connections was established, a new maximum will open the listen port.
167      when margin is zeroed (maximum configured is equal to current connections), listen port will be closed.
168
169      @param maxConnections Number of maximum connections allowed
170   */
171   void setMaxConnections(int maxConnections) throw(anna::RuntimeException);
172
173   /**
174      Sets the maximum allowed inactivity time on server sessions born over the local server before being reset.
175      Communication engine assign a default value of 90000 msecs.
176
177      @param allowedInactivityTime Inactivity time allowed
178   */
179   void setAllowedInactivityTime(const anna::Millisecond & allowedInactivityTime) throw() { a_allowedInactivityTime = allowedInactivityTime; }
180
181   /**
182   * Sets the diameter::comm::Engine
183   * @param e Diameter::comm::Engine
184   */
185   void setEngine(Engine *e) throw() { a_engine = e; }
186
187   // getters
188
189   /**
190   * Gets the diameter::comm::Engine
191   * @return Diameter::comm::Engine
192   */
193   Engine *getEngine() const throw() { return a_engine; }
194
195   /**
196   * Gets the local server key
197   * @return LocalServer key
198   */
199   const socket_t & getKey() const throw() { return a_key; }
200
201   /**
202      Gets the number of maximum accepted connections that server socket is configured to handle
203   */
204   int getMaxConnections() const throw() { return a_maxConnections; }
205
206   /**
207      Gets the number of current connections being established through server socket
208   */
209   int getCurrentConnections() const throw() { return a_currentConnections; }
210
211   /**
212      Gets the maximum allowed inactivity time on server sessions born over the local server before being reset
213
214      @return Inactivity time allowed
215   */
216   const anna::Millisecond & getAllowedInactivityTime() const throw() { return a_allowedInactivityTime; }
217
218   /**
219      Returns true when any of the server-sessions is Bound. False when all not-bound.
220   */
221   bool isAvailable() const throw() { return a_available; }
222
223   // helpers
224
225   /**
226      Disables local server socket (listener) keeping current server sessions alive.
227      Note that applications should not close the listen port directly to keep coherence (see #resetConnectionsMargin)
228
229      @param lock Locks disabled state (make it permanent even if new connections margin is reached).
230      Used during diameter agent isolation (lost of service, maintenance, etc.)
231   */
232   void disable(bool lock = false) throw(anna::RuntimeException);
233
234   /** Enables local server socket (listener)
235
236      @param unlock Unlocks permanent disabled states
237   */
238   void enable(bool unlock = false) throw(anna::RuntimeException);
239
240   /**
241      Gets the number of requests messages over-the-air.
242
243      @return OTA messages.
244   */
245   int getOTARequests() const throw();
246
247   /**
248      Returns idle state (no pending answers).
249
250      @return Idle state.
251   */
252   bool idle() const throw() { return (getOTARequests() == 0); }
253
254   /**
255      Close the local server means two things: close the server socket and close all the server sessions born
256      from this local server freeing such server sessions resources.
257   */
258   void close() throw(anna::RuntimeException);
259
260   /**
261      Performs coherent server socket close procedure zeroing margin between current established connections and maximum allowed.
262   */
263   void resetConnectionsMargin() throw(anna::RuntimeException) { setMaxConnections(a_currentConnections); }
264
265
266   /**
267    * Returns server-session instance identified by client socket provided.
268    *
269    * \param clientSocket Client socket associated to the server session
270    * \param emode Action when no client-session is found with provided parameters (Throw/Ignore).
271    *
272    * \return The server-session instance identified by client socket provided.
273    *
274    * \warning If no server-session found, an exception is launched by default.
275    */
276   ServerSession* findServerSession(const anna::comm::ClientSocket &clientSocket, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) throw(anna::RuntimeException);
277
278   /**
279    * Returns server-session instance identified by socket id provided (hash over serialized client socket information).
280    *
281    * \param socketId Socket id which is key for the server session
282    * \param emode Action when no client-session is found with provided parameters (Throw/Ignore).
283    *
284    * \return The server-session instance identified by client socket provided.
285    *
286    * \warning If no server-session found, an exception is launched by default.
287    */
288   ServerSession* findServerSession(int socketId, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) throw(anna::RuntimeException);
289
290
291   /**
292      Sent a message to the client using a certain server-session provided or defined by #readSocketId if not.
293      When the message is a request, a timer will be set automatically to control the response time.
294      If expires, the ResultCode Timeout will be finally notified on #LocalServer::eventResponse. This
295      timeout value will be configured at #setClassCodeTimeout.
296
297      \param message Message sent.
298      \param socketId Server session socket id INetAddress serialization. By default, #readSocketId is invoked to get the socket id used (which uses round-robin if not re-implemented)
299
300      @return Boolean about success in send operation. True when any of the server sessions could send the message.
301      False, when neither of the server sessions was available or fail to send the message. Broadcast try to send all over
302      the resources in spite of any fail. If a specific socket id is provided, only this socket is used without trying any other
303      and returning false if fails.
304   */
305   bool send(const Message*, int socketId = -1 /* default uses readSocketId() */) throw(anna::RuntimeException);
306   bool send(const Message& message, int socketId = -1 /* default uses readSocketId() */) throw(anna::RuntimeException) { return send(&message, socketId); }
307
308   /**
309      Gets the last used resource (server session) during sending.
310      Broadcast doesn't updates this information.
311   */
312   ServerSession *getLastUsedResource() const throw() { return (a_lastUsedResource); }
313
314   /**
315      Before sending a message over each local server, socketId could be specified to select
316      which session within such server will manage the message.
317
318      Default implementation performs round-robin (value '-1' for socketId) but any other kind of
319      application could re-implement this method and change the behaviour.
320
321      \param message Message which is being sent.
322
323      @return Socket-id (hash over serialized client socket information). Value '-1' if round-robin is desired.
324      If socket-id is unkonwn, send procedure will throw an exception.
325   */
326   virtual int readSocketId(const Message *message) const throw() { return -1; }
327
328   /**
329      Sent a message to all the server sessions.
330      It is used, i.e., in Disconnect-Peer-Request procedure over a certain entity.
331
332      \param message Message which is being sent.
333
334      @return Returns true (success) only when broadcast is success over all the entity servers. If any server fails,
335      then false is returned.
336   */
337   bool broadcast(const Message *message) throw(anna::RuntimeException);
338   bool broadcast(const Message &message) throw(anna::RuntimeException) { return broadcast(&message); }
339
340
341   /**
342      Class string representation
343      \return String with relevant information for this instance.
344   */
345   std::string asString() const throw();
346
347   /**
348      Class xml representation
349      \param parent Parent XML node on which hold this instance information.
350      \return XML document with relevant information for this instance.
351   */
352   anna::xml::Node* asXML(anna::xml::Node* parent) const throw();
353
354   // Statistics
355   void updateProcessingTimeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) throw();
356   void updateReceivedMessageSizeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) throw();
357 //  int getProcessingTimeStatisticConcept() const throw() { return a_processing_time__StatisticConceptId; }
358 //  int getReceivedMessageSizeStatisticConcept() const throw() { return a_received_message_size__StatisticConceptId; }
359
360 protected:
361
362   // Handlers:
363   /**
364      Handler about event break connection from diameter client over this server-session.
365      When notified, ANNA.diameter.comm generates an diameter::comm::ServerSession::eventResponse for every request with pending answers.
366      Default implementation traces warning event
367      \param serverSession ServerSession from which shutdown has been received
368   */
369   virtual void eventPeerShutdown(const ServerSession* serverSession) throw();
370
371   /**
372      Handler about a request retransmission over the server-session.
373      Default implementation traces warning event
374      \param serverSession ServerSession from which retransmission happened
375      \param request Retransmitted request message
376   */
377   virtual void eventRequestRetransmission(const ServerSession* serverSession, Message *request) throw();
378
379   /**
380      Handler for diameter client responses
381
382      \param response Answer container object for corresponding diameter request
383   */
384   virtual void eventResponse(const Response& response) throw(anna::RuntimeException) = 0;
385
386   /**
387      Handler for diameter client requests
388
389      \param serverSession ServerSession from which request has been received
390      \param request Request data block object for corresponding diameter reception
391   */
392   virtual void eventRequest(ServerSession* serverSession, const anna::DataBlock& request) throw(anna::RuntimeException) = 0;
393   //void eventRequest(ServerSession* serverSession, const Message& request) throw(anna::RuntimeException);
394
395   /**
396      Handler for diameter client responses out of context
397
398      \param serverSession ServerSession from which request has been received
399      \param response Answer data block object without context match
400   */
401   virtual void eventUnknownResponse(ServerSession* serverSession, const anna::DataBlock& response) throw(anna::RuntimeException) = 0;
402
403   /**
404      Handler for diameter client Disconnect-Peer-Answer messages
405
406      \param serverSession ServerSession from which request has been received
407      \param response Answer data block object without context match
408   */
409   virtual void eventDPA(ServerSession* serverSession, const anna::DataBlock& response) throw(anna::RuntimeException) = 0;
410
411
412   friend class anna::diameter::comm::Timer;
413   friend class Engine;
414   friend class ServerSocket;
415   friend class ServerSession;
416   friend class ServerSessionReceiver;
417 };
418
419 }
420 }
421 }
422
423 #endif