include/anna/diameter.comm/Message.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_Message_hpp
  10 #define anna_diameter_comm_Message_hpp
  11
  12 // Local
  13 #include <anna/diameter/defines.hpp>
  14 #include <anna/diameter.comm/ClassCode.hpp>
  15
  16 #include <anna/core/RuntimeException.hpp>
  17 #include <anna/comm/Message.hpp>
  18 #include <anna/core/util/Millisecond.hpp>
  19 #include <anna/core/functions.hpp>
  20
  21
  22
  23 namespace anna {
  24 namespace xml {
  25 class Node;
  26 }
  27 }
  28
  29
  30
  31 namespace anna {
  32
  33 namespace diameter {
  34
  35 namespace comm {
  36
  37
  38 class ClientSession;
  39 class ServerSession;
  40
  41 /**
  42    Messages launched to diameter servers
  43    Could be proxied (end-to-end kept) or not (by default).
  44 */
  45 class Message : public anna::comm::Message {
  46 public:
  47
  48   /**
  49    * Define las acciones a realizar en caso de que el temporizador de la petici�n expire.
  50    */
  51   struct OnExpiry { enum _v { Abandon, Ignore, Retransmit }; };
  52
  53   /**
  54      Constructor.
  55      \param onExpiry Indica la acci�n a realizar si el temporizador de esta transaci�n expira.
  56   */
  57   Message(const OnExpiry::_v onExpiry = OnExpiry::Ignore) : anna::comm::Message(StatusCodeBuffer::Reserve),
  58     a_classCode(ClassCode::ApplicationMessage),
  59     a_onExpiry(onExpiry) { initialize(); }
  60
  61   /**
  62      Devuelve el tipo de la clase de esta peticion indicada en el contructor.
  63      \return El tipo de la clase de esta peticion indicada en el contructor.
  64   */
  65   const ClassCode::_v & getClassCode() const { return a_classCode; }
  66
  67   /**
  68    * Devuelve la acci�n a realizar en caso de que el temporizador asociado a esta petici�n expire.
  69    * \return la acci�n a realizar en caso de que el temporizador asociado a esta petici�n expire.
  70    */
  71   OnExpiry::_v getOnExpiry() const { return a_onExpiry; }
  72
  73   /**
  74    * Establece la acci�n a realizar en caso de que el temporizador asociado a esta petici�n expire.
  75    * \param onExpiry Indica la acci�n a realizar en caso de que el temporizador asociado a esta petici�n expire.
  76    *
  77    * \warning Establecer el valor OnExpiry::Ignore podr�a causar p�rdida de memoria y uso innecesario de recursos.
  78    */
  79   void setOnExpiry(const OnExpiry::_v onExpiry) { a_onExpiry = onExpiry; }
  80
  81   // Internal use (CER message)
  82   void setClassCode(const ClassCode::_v & classCode) { a_classCode = classCode; }
  83
  84
  85   /**
  86      Class string representation
  87      \return String with relevant information for this instance.
  88   */
  89   virtual std::string asString() const ;
  90
  91   /**
  92      Class xml representation
  93      \param parent Parent XML node on which hold this instance information.
  94      \return XML document with relevant information for this instance.
  95   */
  96   virtual anna::xml::Node* asXML(anna::xml::Node* parent) const ;
  97
  98
  99   // Helpers
 100   HopByHop getHopByHop() const ;
 101   EndToEnd getEndToEnd() const ;
 102   HopByHop getRequestHopByHop() const { return a_requestHopByHop; }
 103   EndToEnd getRequestEndToEnd() const { return a_requestEndToEnd; }
 104   void setRequestHopByHop(HopByHop hbh) { a_requestHopByHop = hbh; }
 105   void setRequestEndToEnd(EndToEnd ete) { a_requestEndToEnd = ete; }
 106   CommandId getCommandId(bool &isRequest) const ;
 107   CommandId getCommandId() const { bool dummy; return getCommandId(dummy); }
 108   ApplicationId getApplicationId() const ;
 109
 110   bool fixRequestSequence(HopByHop hbh, EndToEnd ete) ;
 111
 112   // http://diameter-protocol.blogspot.com.es/2011/05/diameter-message-structure-and-message.html
 113
 114   /**
 115    * In general, diameter nodes will sequence the End-To-End value when sending new requests.
 116    * A 'false' value stands for intermediate agents (must keep end-to-end during 4 minutes even upon reboots).
 117    */
 118   bool endToEndSequenced() const { return a_endToEndSequenced; }
 119
 120   /**
 121    * By default, the diameter::comm message will sequence the end-to-end increasing the initial value created
 122    * during session establishment. Anyway you could change this behaviour with this method.
 123    *
 124    * @see sequenceEndToEnd
 125    */
 126   void forwardEndToEnd() { a_endToEndSequenced = false; }
 127
 128   /**
 129    * By default, the diameter::comm message will sequence the end-to-end increasing the initial value created
 130    * during session establishment. Anyway you could set again this behaviour with this method.
 131    *
 132    * @see forwardEndToEnd
 133    */
 134   void sequenceEndToEnd() { a_endToEndSequenced = true; }
 135
 136
 137   // Statistics
 138   void updateRequestTimestampMs(void) { a_request_timestamp_ms = anna::functions::millisecond(); }
 139   const anna::Millisecond & getRequestTimestampMs() const { return (a_request_timestamp_ms); }
 140
 141   int getRetries() const { return a_retries; }
 142   void setRetries(int value) { a_retries = value; }
 143
 144
 145   int getRequestServerSessionKey() const { return a_requestServerSessionKey; }
 146
 147   /** Application specific socket id to keep origin track for request which came from a specific client, at asyncronous contexts (process with both diameter interfaces: client & entities) */
 148   void setRequestServerSessionKey(int value) { a_requestServerSessionKey = value; }
 149
 150   const std::string & getRequestClientSessionKey() const { return a_requestClientSessionKey; }
 151
 152   /** Application specific socket id to keep origin track for request which came from a specific server (entity), at asyncronous contexts (process with both diameter interfaces: client & entities) */
 153   void setRequestClientSessionKey(const std::string & value) { a_requestClientSessionKey = value; }
 154
 155   /** Initializes class information */
 156   void initialize() {
 157     a_retries = 1;
 158     a_requestServerSessionKey = -1; // means unknown/unset
 159     a_requestClientSessionKey = ""; // means unknown/unset
 160     a_requestHopByHop = 0;
 161     a_requestEndToEnd = 0;
 162     a_endToEndSequenced = true;
 163   }
 164
 165
 166 protected:
 167   /**
 168      Constructor.
 169      \param classCode Tipo de clase de esta peticion.
 170      \param onExpiry Indica la acci�n a realizar si el temporizador de esta transaci�n expira.
 171   */
 172   Message(const ClassCode::_v & classCode, const OnExpiry::_v onExpiry = OnExpiry::Ignore) : anna::comm::Message(StatusCodeBuffer::Reserve),
 173     a_classCode(classCode),
 174     a_onExpiry(onExpiry) { initialize(); }
 175
 176
 177 private:
 178   ClassCode::_v a_classCode;
 179   OnExpiry::_v a_onExpiry;
 180   anna::Millisecond a_request_timestamp_ms;    // Lapsed timestamp milliseconds at request event. Used for statistic purposes.
 181   int a_retries;
 182   int a_requestServerSessionKey;            // useful to resolve origin of messages when diameter sessions are involved in the other side (if another interface, inherit from this Message class and put/carry context information)
 183   std::string a_requestClientSessionKey;    // idem for request which was received from servers
 184   HopByHop a_requestHopByHop; // application backup for hop-by-hop in order to restore on answer receive
 185   EndToEnd a_requestEndToEnd; // application backup for end-to-end in order to restore on answer receive
 186   bool a_endToEndSequenced; // end-to-end will be sequenced by default (true)
 187
 188   void send(ClientSession&) const noexcept(false);
 189   void send(ServerSession&) const noexcept(false);
 190   void restoreSequencesAfterFix() ;
 191
 192   static const char* asText(const OnExpiry::_v) ;
 193
 194   friend class Session;
 195   friend class ClientSession;
 196   friend class ServerSession;
 197 };
 198
 199 }
 200 }
 201 }
 202
 203 #endif
 204