Session.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_Session_hpp
#define anna_diameter_comm_Session_hpp


// STL
#include <string>

#include <anna/core/util/SortedVector.hpp>
#include <anna/core/util/Millisecond.hpp>
#include <anna/core/RuntimeException.hpp>
#include <anna/timex/Timer.hpp>

#include <anna/diameter/defines.hpp>
#include <anna/diameter.comm/ClassCode.hpp>
#include <anna/diameter.comm/Message.hpp>
#include <anna/diameter.comm/Timer.hpp>


namespace anna {
class DataBlock;
namespace timex {
class Engine;
}
}


namespace anna {

namespace diameter {

namespace stack {
class Engine;
}

namespace comm {

class Timer;
class Engine;
class Response;
class OriginHost;



class Session : public anna::timex::Timer {

public:

  Session(const char *className, const char *timerName);
  //virtual ~Session();

  static const anna::Millisecond DefaultTimeout;

  static const int DefaultPort;




  struct State {
    enum _v {
      /* client + server */ Closed, 
      /* client          */ WaitingBind, 
      /* client + server */ Bound, 
      /* client          */ Failover, 
      /*          server */ Suspect, 
// .......


      // Cierre de iniciativa local:
      // 1. Envio DPR al PCRF y me pongo en estado 'WaitingDPA'. En este estado no habr� keep-alive DWR/DWA.
      // 2. No dejo pasar nuevas peticiones (BLOCK-SEND).
      // 3. Cierro al recibir el DPA.
      // 4. Si expira el DPA, tambien cierro.
      WaitingDPA, 
      // Cierre de iniciativa remota:
      // 1. Recibo DPR del PCRF y me pongo en estado 'Disconnecting'. En este estado no habr� keep-alive DWR/DWA.
      // 2. No dejo pasar nuevas peticiones (BLOCK-SEND).
      // 3. Espero cursar las peticiones pendientes (a m�s tardar, ser� una expiracion Tx desde la recepcion del DPR).
      // 4. Envio DPA y activo un temporizador de cierre local (2*Tx) como proteccion (por si el servidor no cierra).
      Disconnecting, 
      // Cierre abrupto con/sin espera de pendings:
      Closing 
    };
  };

  State::_v getState() const { return a_state; }

  struct OnDisconnect { enum _v { IgnorePendings, WaitPendings /* graceful unbind */ }; };

  void setOnDisconnect(const OnDisconnect::_v onDisconnect)  { a_onDisconnect = onDisconnect; }

  OnDisconnect::_v getOnDisconnect() const { return a_onDisconnect; }



  virtual const std::string& getAddress() const  = 0;

  virtual int getPort() const  = 0;

  int getSocketId() const { return a_socketId; }

  const HopByHop & getNextHopByHop() const { return a_nextHopByHop; }

  const EndToEnd & getNextEndToEnd() const { return a_nextEndToEnd; }


  void setClassCodeTimeout(const ClassCode::_v v, const anna::Millisecond & millisecond) { a_timeouts [v] = millisecond;  }

  anna::Millisecond getClassCodeTimeout(const ClassCode::_v v) const { return a_timeouts [v]; }


  bool isBound() const { return a_state == State::Bound; }


// Envia el mensaje recibido como parametro al servidor con el que estamos conectados mediante esta
// sesion diameter. Dicho mensaje puede ser una peticion o una respuesta (no temporizada).
//
// En caso de enviar una peticion se activara automaticamente un temporizador. Si este llegara a caducar
// se cancelara la busqueda y se invocara al metodo Session::eventResponse indicado que se ha producido
// un error de temporizaci�n. La duracion del temporizador sera la establecida por
// diameter::comm::TimerManager::setTimeout o el valor defecto.
//
// \param message Mensaje a enviar al servidor diameter con el que estamos conectados.
// @return Diameter response reference asociated to a request. NULL if answer sent.
// \warning Solo se podra hacer uso de este metodo cuando el metodo #isBound devuelva \em true.
  virtual const Response* send(const Message* message) noexcept(false) = 0;
  const Response* send(const Message& message) noexcept(false) { return send(&message); }

// Desconecta del extremo remoto
// Se notifica la terminaci�n de cada una de las peticiones pendientes invocando al m�todo Session::eventResponse
// \warning Despu�s de invocar a este m�todo habr�a que volver a iniciar una sesion.
  virtual bool unbind(bool forceDisconnect /* se usa en timer, para el actionTimer del tipo SessionUnbind, etc. */ = false) noexcept(false) = 0;
  // returns true if done at call time (no pendings or ignore pendings, except Disconnecting state by mean DPR/DPA)


  const anna::Millisecond & getLastIncomingActivityTime() const { return a_lastIncomingActivityTime; }

  const anna::Millisecond & getLastOutgoingActivityTime() const { return a_lastOutgoingActivityTime; }

  int getOTARequests() const { return a_responses.size(); }


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


  void notifyOrphansOnExpiration(bool defer = true) { a_notifyOrphansOnExpiration = defer; }

  virtual std::string asString() const ;


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

protected:

  // Internal, traces, etc.
  const char *a_className;

  // Main session attributes
  int a_socketId; // multiple connection functionality
  State::_v a_state;
  OnDisconnect::_v a_onDisconnect;
  anna::diameter::comm::Timer *a_actionTimer;

  // Sequencing
  HopByHop a_nextHopByHop;
  EndToEnd a_nextEndToEnd;
  virtual void initialize() ;
  void initializeSequences() ; // debe invocarse despues de haber asignado el a_parent
  void generateNextSequences() { a_nextHopByHop++; a_nextEndToEnd++; }

  // Context Responses
  struct SortById {
    static HopByHop value(const Response*) ;
  };
  typedef anna::SortedVector <Response, SortById, HopByHop> response_container;
  typedef response_container::iterator response_iterator;
  typedef response_container::const_iterator const_response_iterator;
  response_container a_responses;
  bool a_notifyOrphansOnExpiration;

  void response_add(Response* response) ;
  void response_erase(Response* response) ;
  Response* response_find(const HopByHop hopByHop) noexcept(false);

  response_iterator response_begin() { return a_responses.begin(); }
  response_iterator response_end() { return a_responses.end(); }
  static Response* response(response_iterator ii) { return response_container::data(ii); }

  const_response_iterator response_begin() const { return a_responses.begin(); }
  const_response_iterator response_end() const { return a_responses.end(); }
  static const Response* response(const_response_iterator ii) { return response_container::data(ii); }

  // Activity
  anna::timex::Engine* a_timeController;
  anna::Millisecond a_lastIncomingActivityTime;   // last unix timestamp (in milliseconds) when message reception was managed over the session
  anna::Millisecond a_lastOutgoingActivityTime;   // last unix timestamp (in milliseconds) when message sending was managed over the session
  virtual void updateIncomingActivityTime() ;
  virtual void updateOutgoingActivityTime() ;

  // Self-timer expiration handler
  virtual void expire(anna::timex::Engine *timeController) noexcept(false) {;}

  // Timming:
  anna::Millisecond a_timeouts [ClassCode::Max];

  // Handlers:
  virtual void eventPeerShutdown()  = 0;

  virtual void eventRequestRetransmission(Message *request)  = 0;

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

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


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

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



  virtual void receive(const anna::comm::Message& message) noexcept(false) = 0;
//PROTOCOL ERRORS
//The errors at the protocol level are reported in response messages that contain the �E� bit and the error code in the AVP result-Code (various errors having been produced only the first one of them is reported). Examples of these errors are:
//An unrecognized AVP with the �M� bit is received.
//An AVP is received with an unrecognized value (in the AVP failed-AVP indicates the attribute that the error caused).
//An mandatory AVP is not received.
//Length of operation incorrect.
//Length of AVP incorrect.
//Coding of some AVP incorrect.
//Erroneous inclusion of parameters.





  virtual void finalize() ; // invoked from ClientSessionReceiver::eventBreakConnection()


  virtual void expireResponse(Response*) ;
  void sendDPA(const Engine *commEngine, const anna::DataBlock &dprDataBlock) noexcept(false);
  void activateActionTimer(const anna::diameter::comm::Timer::Type::_v type) ;
  void cancelActionTimer() ;
  void activateTimer() ; // Session timer
  void cancelTimer() ; // Session timer
  virtual void timerStopped() {;}
  virtual void timerStarted() {;}


  virtual void setState(State::_v state) ;

  //anna::diameter::comm::Timer *getActionTimer() const { return (a_actionTimer); }


  // helpers
  static const char* asText(const State::_v) ;
  static const char* asText(const OnDisconnect::_v) ;


  friend class anna::diameter::comm::Timer;
  friend class Response;
};

}
}
}

#endif