Server.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_Server_hpp
#define anna_diameter_comm_Server_hpp


// STL
#include <string>
#include <vector>
#include <map>

// Project
#include <anna/core/util/Millisecond.hpp>
#include <anna/core/RuntimeException.hpp>
#include <anna/diameter/defines.hpp>
#include <anna/config/defines.hpp>
#include <anna/diameter.comm/ClassCode.hpp>
#include <anna/diameter.comm/MessageStatistics.hpp>




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


namespace anna {

namespace diameter {

namespace comm {

class Engine;
class Entity;
class ClientSession;
class Response;
class Message;
class OriginHost;


class Server {

  // Parent information
  Entity *a_parent;

  // Main server attributes
  socket_t a_socket;

  // ClientSessions
  std::vector<ClientSession*> a_clientSessions;
  int a_maxClientSessions; // -1 means "no limit to add client-sessions" (sockets per server)
  std::vector<ClientSession*>::iterator a_deliveryIterator;
  ClientSession *a_lastUsedResource;

  // Activity
  anna::Millisecond a_lastIncomingActivityTime;   // last unix timestamp (in milliseconds) when message reception was managed over this server
  anna::Millisecond a_lastOutgoingActivityTime;   // last unix timestamp (in milliseconds) when message sending was managed over this server
  void updateIncomingActivityTime() ;
  void updateOutgoingActivityTime() ;

  // Engine
  Engine *a_engine;

  // Statistics
  MessageStatistics a_messageStatistics;
  void initializeStatisticResources() ;
  void resetStatistics() ;

  // Availability
  bool a_available; // any of the client-sessions must be bound
  void availabilityLost() ;
  void availabilityRecovered() ;
  bool refreshAvailability() ; // return true if change
  void assertReady() noexcept(false);
  void initialize() ;
  void childIdle() const ;

  // Private close/destroy method
  void close(bool destroy) noexcept(false);


public:


  Server(int maxClientSessions = 1) : a_maxClientSessions(maxClientSessions) { initialize(); }

  virtual ~Server() {;}


  void addClientSession(int socketId) noexcept(false);

  void setClassCodeTimeout(const ClassCode::_v v, const anna::Millisecond & millisecond) ;

  bool bind() noexcept(false);

  void raiseAutoRecovery(bool autoRecovery = true) noexcept(false);


// Sent a message to the server using a certain client-session by mean round-robin between socketId's for
//  multiple client client-sessions functionality. If a specific socketId is provided, then uses such specific client-session.
// Last used delivery resource could be known through #getLastUsedResource().
  bool send(const Message*, int socketId = -1 /* client-sessions round-robin */) noexcept(false);
  bool send(const Message& message, int socketId = -1 /* client-sessions round-robin */) noexcept(false) { return send(&message, socketId); }

  ClientSession *getLastUsedResource() const { return (a_lastUsedResource); }

  bool broadcast(const Message*) noexcept(false);
  bool broadcast(const Message& message) noexcept(false) { return broadcast(&message); }

  void close() noexcept(false) { close(false /* no destroy */); }


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

  bool isAvailable() const { return a_available; }


  std::vector<ClientSession*>::iterator begin() { return a_clientSessions.begin(); }
  std::vector<ClientSession*>::iterator end() { return a_clientSessions.end(); }
  std::vector<ClientSession*>::const_iterator begin() const { return a_clientSessions.begin(); }
  std::vector<ClientSession*>::const_iterator end() const { return a_clientSessions.end(); }

  int getNumberOfClientSessions() const { return a_clientSessions.size(); }
  int getMaxClientSessions() const { return a_maxClientSessions; }
  void setMaxClientSessions(int maxClientSessions) { a_maxClientSessions = maxClientSessions; }

  const std::string& getAddress() const { return a_socket.first; }

  int getPort() const { return a_socket.second; }


  std::string socketAsString() const ;


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

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


  int getOTARequests() const ;

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


  void hide() ;

  void show() ;

  bool hidden() const ;

  bool shown() const ;


  std::string asString() const ;

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


  // Statistics
  void updateProcessingTimeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) ;
  void updateReceivedMessageSizeStatisticConcept(const double &value, const anna::diameter::CommandId &cid) ;
//  int getProcessingTimeStatisticConcept() const { return a_processing_time__StatisticConceptId; }
//  int getReceivedMessageSizeStatisticConcept() const { return a_received_message_size__StatisticConceptId; }

protected:

  virtual void eventPeerShutdown(const ClientSession*) ;

  virtual void eventRequestRetransmission(const ClientSession*, Message *request) ;

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

  virtual void eventRequest(ClientSession *clientSession, const anna::DataBlock &request, const anna::diameter::comm::OriginHost *myNode) noexcept(false);

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

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



  friend class Engine;
  friend class ClientSession;
};

}
}
}

#endif