ClientSession.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_ClientSession_hpp
#define anna_diameter_comm_ClientSession_hpp


// STL
#include <string>

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

#include <anna/diameter.comm/Session.hpp>
#include <anna/diameter/defines.hpp>
#include <anna/diameter.comm/Message.hpp>
#include <anna/diameter.comm/ClientSessionReceiver.hpp>
#include <anna/diameter.comm/ReceiverFactoryImpl.hpp>


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

namespace comm {
class Server;
}
}


namespace anna {

namespace diameter {

namespace comm {

class Server;


class ClientSession : public Session {

  // Helper:
  static std::string getKey(const std::string & addr, int port, int socketId) {
    return (anna::functions::asString("%s:%d|%d", addr.c_str(), port, socketId));
  }

  bool a_hidden; // hide resource for restricted delivery over servers/entities


public:

  ClientSession();


  /* virtual */void initialize() ;

  static const anna::Millisecond DefaultWatchdogPeriod;

  std::string getKey() const { return ClientSession::getKey(getAddress(), getPort(), getSocketId()); }

  /* virtual */const std::string& getAddress() const ;

  /* virtual */int getPort() const ;

  const Server *getParent() const { return a_parent; }

  anna::comm::Server * getServer() { return a_server; }

  void disable() { a_server->disable(); }

  void setAutoRecovery(bool autoRecovery = true) { a_autoRecovery = autoRecovery; a_server->setAutoRecovery(autoRecovery); }

  bool getAutoRecovery() const { return a_autoRecovery; }

  void setMaxConnectionDelay(const anna::Millisecond & maxConnectionDelay) { a_server->setMaxConnectionDelay(maxConnectionDelay); }

  const anna::Millisecond & getMaxConnectionDelay() { return a_server->getMaxConnectionDelay(); }

  // Internal
  void bind() noexcept(false);

  /* virtual */const Response* send(const Message* message) noexcept(false);
  /* virtual */bool unbind(bool forceDisconnect /* se usa en timer, para el actionTimer del tipo SessionUnbind, etc. */ = false) noexcept(false); // returns true if done at call time (no pendings or ignore pendings, except Disconnecting state by mean DPR/DPA)

  void hide() { a_hidden = true; }

  void show() { a_hidden = false; }

  bool hidden() const { return a_hidden; }

  bool shown() const { return !a_hidden; }


  /* virtual */std::string asString() const ;


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


private:

  // Receiver factory
  ReceiverFactoryImpl<ClientSession, ClientSessionReceiver> a_receiverFactory;

  // Parent information
  Server *a_parent;

  // ClientSession messages:
  Engine *a_engine; // it is unique for a client session (not in server session, which have one per origin host)
  Message a_cer;
  Message a_dwr;

  // Connectivity
  bool a_autoRecovery;

  // Server
  anna::comm::Server *a_server;

  // Watchdog control:
  struct WatchdogState {
    enum _v {
      TimerStopped,           // Until CEA (bound state), timer is stopped
      WaitingTimerExpiration, // DWA has been received and we wait for next expiration to send DWR
      WaitingDWA              // DWR has been sent, but DWA hasn't been received yet
    };
  };
  WatchdogState::_v a_watchdogState;
  void setWatchdogState(WatchdogState::_v wState) ;

  /* virtual */void expire(anna::timex::Engine *timeController) noexcept(false);
  void setWatchdogPeriod(const anna::Millisecond & watchdogPeriod) ;

  /*virtual*/ void timerStopped() ;
  /*virtual*/ void timerStarted() ;


  // Activity:
  /* virtual */void updateIncomingActivityTime() ;
  /* virtual */void updateOutgoingActivityTime() ;
  void countSendings(const diameter::CommandId & cid, unsigned int aid, bool ok) ;

  // Handlers:
  void eventPeerShutdown() ;

  void eventRequestRetransmission(Message *request) ;

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

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

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

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



  /* virtual */void receive(const anna::comm::Message& message) noexcept(false);
  /* virtual */void finalize() ;
  void recover() ;

  /* virtual */void expireResponse(Response*) ;
  /* virtual */void setState(State::_v state) ;

  void sendDWAToServer(const anna::DataBlock& dwrDB) noexcept(false); // non-usual behaviour, but DWR could be received from server

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


  friend class Server;
  friend class Engine;
  friend class ClientSessionReceiver;
};

}
}
}

#endif