Communicator.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_comm_Communicator_hpp
#define anna_comm_Communicator_hpp

#include <vector>

#include <anna/config/defines.hpp>
#include <anna/core/DataBlock.hpp>
#include <anna/core/util/Recycler.hpp>
#include <anna/core/util/SortedVector.hpp>

#include <anna/app/Component.hpp>

#include <anna/comm/INetAddress.hpp>
#include <anna/comm/Socket.hpp>
#include <anna/comm/Status.hpp>

#include <anna/comm/internal/ConnectionRecover.hpp>

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

namespace anna {

// MT
class ThreadManager;

namespace xml {
class Node;
}

namespace comm {

class Application;
class Transport;
class Message;
class ServerSocket;
class ClientSocket;
class LocalConnection;
class RemoteConnection;
class DatagramSocket;
class INetAddress;
class Handler;
class Server;
class Service;
class BinderSocket;
class ConnectionRecover;

namespace handler {
class LocalConnection;
class RemoteConnection;
class ClientSocket;
}

// ST
class Poll;

class Communicator : public app::Component {
  struct SortByFileDescriptor {
    static int value(const Handler*) ;
  };

  static Millisecond st_ReceivingChunkSize;

public:
  struct WorkMode {
    enum _v {
      Single,
      Clone
    };
  };

  static const Millisecond MinRecoveryTime;

  static const Millisecond DefaultRecoveryTime;

  static const Millisecond MaxRecoveryTime;

  static const Millisecond MinTryingConnectionTime;

  static const Millisecond DefaultTryingConnectionTime;

  static const Millisecond MaxTryingConnectionTime;

  static const int MinReceivingChunkSize = 2 * 1024;

  static const int MaxReceivingChunkSize = 64 * 1024;

  static const Millisecond DefaultTimeout;

  static const int DefaultChunkSize = 16 * 1024;

  typedef SortedVector <Handler, SortByFileDescriptor> Handlers; 
  typedef Handlers::const_iterator const_handler_iterator; 
  typedef Handlers::iterator handler_iterator; 
  typedef std::vector <const Service*> Services; 
  typedef Services::const_iterator const_service_iterator; 
  Communicator(const WorkMode::_v acceptMode = WorkMode::Single);

  virtual ~Communicator();

  const Millisecond &getRecoveryTime() const { return a_recoveryTime; }

  const Status& getStatus() const { return a_status; }

  const Millisecond &getTimeout() const { return a_timeout; }

  WorkMode::_v getWorkMode() const { return a_workMode; }

  bool isServing() const { return a_isServing; }

  bool hasRequestedStop() const { return a_requestedStop; }

  void notifyPendingClose() { a_pendingClose = true; }

  void setRecoveryTime(const Millisecond &recoveryTime) noexcept(false);

  void setTryingConnectionTime(const Millisecond &tryingConnectionTime) noexcept(false);

  const Millisecond &getTryingConnectionTime() const { return a_tryingConnectionTime; }

  static void setReceivingChunkSize(const int receivingChunkSize) noexcept(false);

  static int getReceivingChunkSize() { return st_ReceivingChunkSize; }

  void setTimeout(const Millisecond & timeout) { a_timeout = timeout; }

  void setLevelOfDenialService(const int levelOfDenialService) noexcept(false);

  int getLevelOfDenialService() const { return a_levelOfDenialService; }

  void attach(ServerSocket* serverSocket) noexcept(false);

  void attach(LocalConnection* localConnection) noexcept(false);

  void attach(ClientSocket* clientSocket) noexcept(false);

  void attach(DatagramSocket* datagramSocket) noexcept(false);

  void attach(Handler* handler) noexcept(false);

  void attach(Service* service) noexcept(false);

  void detach(ServerSocket* serverSocket) ;

  void detach(ClientSocket* clientSocket) ;

  void detach(Handler* handler) ;

  const Handler* getHandler(const ClientSocket& clientSocket) noexcept(false);

  void accept() noexcept(false);

  void requestStop() ;

  bool isUsable(const ClientSocket* clientSocket) ;

  int handler_size() const { return a_handlers.size(); }

  handler_iterator handler_begin() { return a_handlers.begin(); }

  handler_iterator handler_end() { return a_handlers.end(); }

  const_handler_iterator handler_begin() const { return a_handlers.begin(); }

  const_handler_iterator handler_end() const { return a_handlers.end(); }

  const_service_iterator service_begin() const { return a_services.begin(); }

  const_service_iterator service_end() const { return a_services.end(); }

  virtual void eventUser(const char* id, const void* context) {;}

  virtual void eventBreakAddress(const in_addr_t& address) ;

  virtual void eventRecoverAddress(const in_addr_t& address) ;

  virtual bool eventAcceptConnection(const ClientSocket& clientSocket) noexcept(false);

  virtual void eventCreateConnection(const Server* server) ;

  virtual void eventCreateConnection(const Service* service) ;

  virtual void eventReceiveMessage(ClientSocket& clientSocket, const Message& message)
  noexcept(false) { ; }

  virtual void eventOverQuota(const ClientSocket& clientSocket) {;}

  virtual void eventDiscardConnection(const ClientSocket& clientSocket) {;}

  virtual void eventIgnoreBurst(const ClientSocket& clientSocket, const DataBlock& burst) {;}

  std::string asString() const ;

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

  static Handler* handler(handler_iterator& ii) { return Handlers::data(ii); }

  static const Handler* handler(const_handler_iterator& ii) { return Handlers::data(ii); }

  static const Service* service(const_service_iterator& ii) { return *ii; }

  static const char* getClassName() { return "anna::comm::Communicator"; }

protected:
  virtual void eventBreakConnection(const ClientSocket& clientSocket) {;}

  virtual void eventBreakLocalConnection(const ClientSocket& clientSocket) {;}


  virtual void eventBreakConnection(const Server* server) ;

  virtual void eventBreakConnection(const Service* service) ;

  virtual void do_initialize() noexcept(false) {;}

  void do_stop() { requestStop(); }

  virtual void setStatus(const Status& status) ;

  void attach(BinderSocket* binderSocket) noexcept(false);

  void detach(BinderSocket* binderSocket) ;

  virtual void eventStartup() noexcept(false) {;}

  virtual void eventShutdown() ;

private:
  const WorkMode::_v a_workMode;
  bool a_isServing;
  bool a_requestedStop;
  Handlers a_handlers;
  Millisecond a_recoveryTime;
  Status a_status;
  Services a_services;
  Millisecond a_timeout;
  comm::Handler* a_mainHandler;
  ConnectionRecover* a_connectionRecover;
  bool a_pendingClose;
  Millisecond a_tryingConnectionTime;
  int a_levelOfDenialService;

  // ST
  Poll* a_poll;
  Handlers a_timedouts;
  void singlethreadedAccept() noexcept(false);

  // MT
  ThreadManager* a_threadManager;
  void multithreadedAccept() noexcept(false);

  ConnectionRecover* getConnectionRecover() { return a_connectionRecover; }

  void attach(RemoteConnection* remoteConnection) noexcept(false);

  void insert(Handler*) noexcept(false);
  Handler* find(const int fd) { return a_handlers.find(fd); }

  // Reimplementado de app::Component
  void do_cloneParent() noexcept(false);
  void do_cloneChild() ;

  friend class Handler;

  friend class Server;
  // attach (RemoteConnection)

  friend class handler::RemoteConnection;
  // getConnectionRecover, eventBreakConnection

  friend class handler::ClientSocket;
  // eventBreakConnection

  // EDU
  friend class handler::LocalConnection;
  // eventBreakLocalConnection
};

}
}

#endif