include/anna/comm/Communicator.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_comm_Communicator_hpp
  10 #define anna_comm_Communicator_hpp
  11
  12 #include <vector>
  13
  14 #include <anna/config/defines.hpp>
  15 #include <anna/core/DataBlock.hpp>
  16 #include <anna/core/util/Recycler.hpp>
  17 #include <anna/core/util/SortedVector.hpp>
  18
  19 #include <anna/app/Component.hpp>
  20
  21 #include <anna/comm/INetAddress.hpp>
  22 #include <anna/comm/Socket.hpp>
  23 #include <anna/comm/Status.hpp>
  24
  25 #include <anna/comm/internal/ConnectionRecover.hpp>
  26
  27 #include <anna/core/util/Millisecond.hpp>
  28
  29 namespace anna {
  30
  31 // MT
  32 class ThreadManager;
  33
  34 namespace xml {
  35 class Node;
  36 }
  37
  38 namespace comm {
  39
  40 class Application;
  41 class Transport;
  42 class Message;
  43 class ServerSocket;
  44 class ClientSocket;
  45 class LocalConnection;
  46 class RemoteConnection;
  47 class DatagramSocket;
  48 class INetAddress;
  49 class Handler;
  50 class Server;
  51 class Service;
  52 class BinderSocket;
  53 class ConnectionRecover;
  54
  55 namespace handler {
  56 class LocalConnection;
  57 class RemoteConnection;
  58 class ClientSocket;
  59 }
  60
  61 // ST
  62 class Poll;
  63
  64 /**
  65    Clase que integra todos los elementos implicados en la recepcin y/o envio y tratamiento de mensajes
  66    de red.
  67
  68    Los mensajes recibidos y/o enviados a la capa de transporte seran tratados por el protocolo asociado
  69    al socket cliente. Normalmente todos los socket clientes asociados a un comunicador tendran asociado
  70    un mismo tipo de protocolo. Ver Transport.
  71
  72    Normalmente, y una vez que recibimos un mensaje (ver #eventReceiveMessage) aplicaremos algun codec (ver @ref Codec)
  73    para interpretar el contenido del mensaje, de forma analoga, para enviar un mensaje a la capa de transporte
  74    usando cualquier protocolo lo normal sera haber codificado cierta informacion usando algun codec.
  75
  76    \warning Siempre que usemos un Communicator debemos establecer una clase Application heredada
  77    de comm::Application.
  78 */
  79 class Communicator : public app::Component {
  80   struct SortByFileDescriptor {
  81     static int value(const Handler*) throw();
  82   };
  83
  84   /**
  85    * Tamaño del búfer usado para leer los mensajes de la red.
  86    * Se puede establecer desde comm::Communicator::setReceivingChunkSize.
  87    */
  88   static Millisecond st_ReceivingChunkSize;
  89
  90 public:
  91   /**
  92    * Modo de aceptar peticiones en el caso de una arquitectura ST.
  93    * \warning Solo tiene efecto en caso de generar la libreria en modo ST.
  94    * \see Communicator
  95    */
  96   struct WorkMode {
  97     enum _v {
  98       /**
  99        * Un único proceso atiende todas las peticiones, el reparto de atención implementado asegura que todos
 100        * los clientes tendrán un tiempo de respuesta similar, el tratamiento de N peticiones que llegan simultáneamente
 101        * se realiza de forma secuencial. Es el modo usado hasta ahora en modo ST. Tiene la ventaja de ser el método que
 102        * origina código más simple y fácil de mantener.
 103        */
 104       Single,
 105       /**
 106        *  Cada cliente tiene su propia copia del servidor original que trata sus peticiones de forma particular.
 107        * De esta forma se podrían llegar a servir simultáneamente cada una de las peticiones de cada uno de los
 108        * clientes conectados al servidor. Puede ser una buena opción si tenemos en cuenta la relación entre el
 109        * rendimiento y la complejidad de desarrollo.
 110        *
 111        * Podria ser la mejor opcion para implementar un servidor de base de datos.
 112        *
 113        * \warning Solo puede usarse para implementar servidores finales, es decir, procesos que no requieran de la
 114        * respuesta de ningun otro proceso remoto para realizar su operacion.
 115        */
 116       Clone
 117     };
 118   };
 119
 120   /**
 121    * Numero de mínimo milisegundos esperados para intentar la recuperacion de la conexion con los
 122    * servidores en caso de detectar algun error.
 123    */
 124   static const Millisecond MinRecoveryTime;
 125
 126   /**
 127      Numero de milisegundos esperados para intentar la recuperacion de la conexion con los
 128      servidores en caso de detectar algun error.
 129   */
 130   static const Millisecond DefaultRecoveryTime;
 131
 132   /**
 133    * Numero de mínimo milisegundos esperados para intentar la recuperacion de la conexion con los
 134    * servidores en caso de detectar algun error.
 135    */
 136   static const Millisecond MaxRecoveryTime;
 137
 138   /**
 139    * Periodo de tiempo mínimo que estará intentando conectar con servidores cada vez que se cumpla el periodo de
 140    * comprobación de conexiones.
 141    */
 142   static const Millisecond MinTryingConnectionTime;
 143
 144   /**
 145    * Periodo de tiempo usado por defectoque estará intentando conectar con servidores cada vez que se cumpla el
 146    * periodo de comprobación de conexiones.
 147    */
 148   static const Millisecond DefaultTryingConnectionTime;
 149
 150   /**
 151    * Periodo de tiempo máximo que estará intentando conectar con servidores cada vez que se cumpla el periodo de
 152    * comprobación de conexiones.
 153    */
 154   static const Millisecond MaxTryingConnectionTime;
 155
 156   /**
 157    * Tamaño mínimo de la cola de entrada de mensajes que se puede establecer.
 158    */
 159   static const int MinReceivingChunkSize = 2 * 1024;
 160
 161   /**
 162    * Tamaño máximo de la cola de entrada de mensajes que se puede establecer.
 163    */
 164   static const int MaxReceivingChunkSize = 64 * 1024;
 165
 166   /**
 167      Numero de milisegundos esperados para considerar que un cliente remoto ha abandonado
 168      la conexion.
 169   */
 170   static const Millisecond DefaultTimeout;
 171
 172   /**
 173    * Tamaño máximo del búfer a tratar de forma ininterrumpida.
 174    */
 175   static const int DefaultChunkSize = 16 * 1024;
 176
 177   typedef SortedVector <Handler, SortByFileDescriptor> Handlers; /**< Definicion para gestionar los controladores asociados a este comunicador */
 178   typedef Handlers::const_iterator const_handler_iterator; /**< Definicion para el iterador de controladores */
 179   typedef Handlers::iterator handler_iterator; /**< Definicion para el iterador de controladores */
 180
 181   typedef std::vector <const Service*> Services; /**< Definicion para gestionar los servicios asociados a este comunicador */
 182   typedef Services::const_iterator const_service_iterator; /**< Definicion para el iterador de servicios */
 183
 184   /**
 185      Constructor.
 186      \param acceptMode Modo en que se trata las peticiones.
 187   */
 188   Communicator(const WorkMode::_v acceptMode = WorkMode::Single);
 189
 190   /**
 191    * Destructor
 192    */
 193   virtual ~Communicator();
 194
 195   /**
 196      Devuelve el numero de segundos esperado para intentar recuperar las conexiones de los servidores
 197      con los que se han detectado errores de conexion.
 198      @return El numero de segundos esperado para intentar recuperar las conexiones de los servidores
 199      con los que se han detectado errores de conexion.
 200   */
 201   const Millisecond &getRecoveryTime() const throw() { return a_recoveryTime; }
 202
 203   /**
 204      Devuelve el estado de este proceso con respecto al sistema de comunicaciones.
 205      \return El estado de este proceso con respecto al sistema de comunicaciones.
 206   */
 207   const Status& getStatus() const throw() { return a_status; }
 208
 209   /**
 210      Devuelve el numero de milisegundos maximo que puede estar un manejador de conexion local
 211      sin recibir mensajes antes de ser cerrado por el nucleo.
 212      \return el numero de milisegundos maximo que puede estar un manejador de conexion local
 213      sin recibir mensajes antes de ser cerrado por el nucleo.
 214   */
 215   const Millisecond &getTimeout() const throw() { return a_timeout; }
 216
 217   /**
 218    * Devuelve el modo de tratamiento de conexiones establecido en el constructor.
 219    */
 220   WorkMode::_v getWorkMode() const throw() { return a_workMode; }
 221
 222   /**
 223      Devuelve \em true si este comunicador esta atendiendo peticiones como servidor o \em false en otro
 224      caso.
 225      @return \em true si este comunicador esta atendiendo peticiones como servidor o \em false en otro
 226      caso.
 227   */
 228   bool isServing() const throw() { return a_isServing; }
 229
 230   /**
 231      Devuelve el estado del indicador de peticion de parada.
 232      \return el estado del indicador de peticion de parada.
 233   */
 234   bool hasRequestedStop() const throw() { return a_requestedStop; }
 235
 236   /**
 237    * Informa al comunicador de que hay algún socket que ha solicitado el cierre de la conexión.
 238    */
 239   void notifyPendingClose() throw() { a_pendingClose = true; }
 240
 241   /**
 242      Establece el numero de milisegundos esperado para intentar recuperar las conexiones de los servidores
 243      con los que se han detectado errores de conexion.
 244
 245      @param recoveryTime numero de milisegundos esperado para intentar recuperar las conexiones de los
 246      servidores con los que se han detectado errores de conexion.
 247
 248      \warning el valor indicado deberá estar entre #MinRecoveryTime y #MaxRecoveryTime
 249   */
 250   void setRecoveryTime(const Millisecond &recoveryTime) throw(RuntimeException);
 251
 252   /**
 253      Establece el numero de milisegundos empleados en intentar conectar con los servidores caídos cada
 254      vez que se cumple el periodo de recuperación y hay servidores caídos.
 255
 256      @param tryingConnectionTime numero de milisegundos empleados en intentar recuperar las conexiones
 257      de los servidores con los que se han detectado errores de conexion.
 258
 259      \warning el valor indicado deberá estar entre #MinTryingConnectionTime y #MaxTryingConnectionTime
 260   */
 261   void setTryingConnectionTime(const Millisecond &tryingConnectionTime) throw(RuntimeException);
 262
 263   /**
 264    * Devuelve el numero de milisegundos empleados en intentar conectar con los servidores caídos.
 265    */
 266   const Millisecond &getTryingConnectionTime() const throw() { return a_tryingConnectionTime; }
 267
 268   /**
 269    * Establece el tamaño del bloque de memoria usado para procesar los mensajes entrantes. Todos
 270    * los mensajes completos contenidos en el chunk se procesarán de forma ininterrumpida.
 271    * \param receivingChunkSize Número de bytes a leer/procesar de forma ininterrumpida.
 272    *
 273    * \warning el valor indicado deberá estar entre #MinReceivingChunkSize y #MaxReceivingChunkSize
 274    * \warning Experimentalmente se ha comprobado que los mejores rendimientos se obtiene cuando
 275    * este valor y el MaxPendingBytes del control de congestión tiene valores cercanos, así que
 276    * cuando se cambia este valor también se invocará a CongestionController::setMaxPendingBytes para
 277    * establecer este mismo valor.
 278    */
 279   static void setReceivingChunkSize(const int receivingChunkSize) throw(RuntimeException);
 280
 281   /**
 282    * Obtiene el tamaño máximo del bloque de memoria a procesar de forma ininterrumpida.
 283    * \return el tamaño máximo del bloque de memoria a procesar de forma ininterrumpida.
 284    */
 285   static int getReceivingChunkSize() throw() { return st_ReceivingChunkSize; }
 286
 287   /**
 288      Establece el numero de milisegundos maximo que puede estar un manejador de conexion local
 289      sin recibir mensajes antes de ser cerrado por el nucleo.
 290      \param timeout Numero de milisegundos maximo sin recibir mensajes.
 291   */
 292   void setTimeout(const Millisecond & timeout) throw() { a_timeout = timeout; }
 293
 294   /**
 295    * Establece el nivel de congestión global a partir del cual un servidor no aceptará nuevas conexiones. Su valor
 296    * por defecto será comm::CongestionController::MaxLevel.
 297    *
 298    * \param levelOfDenialService Nivel de congestión global a partir del cual no se permitirán nuevas conexiones.
 299    *
 300    * \warning Debe estar entre [comm::CongestionController::MaxLevel - 2, comm::CongestionController::MaxLevel].
 301    */
 302   void setLevelOfDenialService(const int levelOfDenialService) throw(RuntimeException);
 303
 304   /**
 305    * Devuelve el nivel de congestión a partir del cual un servidor no aceptará nuevas conexiones.
 306    * \return el nivel de congestión a partir del cual un servidor no aceptará nuevas conexiones.
 307    */
 308   int getLevelOfDenialService() const throw() { return a_levelOfDenialService; }
 309
 310   /**
 311      Registra un servidor de socket a la lista de peticiones por las que atiende peticiones este
 312      Communicator. Un Communicator puede atender peticiones por un numero indeterminado de direcciones
 313      lo que nos permite disear facilmente sistemas tolerantes a fallos.
 314
 315      \param serverSocket Servidor de socket por el que vamos a atender el establecimiento de conexiones
 316      una vez que invoquemos al Metodo #accept.
 317   */
 318   void attach(ServerSocket* serverSocket) throw(RuntimeException);
 319
 320   /**
 321      Registra una conexion Local entre alguno de los ServerSocket definidos en nuestra aplicacion
 322      y algun cliente remoto que solicita la conexion.
 323
 324      Antes de pasar a gestionar esta conexion debera de haber sido acceptada en el metodo
 325      #eventAcceptConnection (a no ser que re-escribamos su comportamiento aceptara conexiones
 326      de cualquier cliente).
 327
 328      \param localConnection Instancia de la conexion local que vamos a controlar.
 329
 330      \warning Exclusivamente uso interno
 331   */
 332   void attach(LocalConnection* localConnection) throw(RuntimeException);
 333
 334   /**
 335      Establece la conexion entre el comunicador y un ClientSocket recibido como parametro.
 336      El socket recibido se inicializa se fuera necesario.
 337
 338      \param clientSocket Instancia del socket que vamos a controlar.
 339   */
 340   void attach(ClientSocket* clientSocket) throw(RuntimeException);
 341
 342   /**
 343      Establece la conexion entre el comunicador y un DatagramSocket recibido como parametro.
 344      El socket recibido se inicializa se fuera necesario.
 345
 346      \param datagramSocket Instancia del socket que vamos a controlar.
 347   */
 348   void attach(DatagramSocket* datagramSocket) throw(RuntimeException);
 349
 350   /**
 351      Conecta un conector externo a este comunicador.
 352      \param handler Controlador de comunicaciones externas.
 353      \warning Debe de haber sido creado como de tipo Handler::Type::Custom.
 354   */
 355   void attach(Handler* handler) throw(RuntimeException);
 356
 357   /**
 358      Conecta un servicio de reparto de comunicaciones con este comunicador. El estado de
 359      disponibilidad/indisponibilidad de este comunicador estara definido en base a la
 360      disponibilidad de todos los servicios definidos como criticos.
 361      \param service Instancia del servicio.
 362      \warning Todos los servicios registrados como criticos deberian estar asociados al comunicador.
 363   */
 364   void attach(Service* service) throw(RuntimeException);
 365
 366   /**
 367      Desconecta el ServerSocket que fue previamente conectado con #attach
 368      \param serverSocket Instancia del socket que vamos a desconectar.
 369      \warning Este metodo es invocado automaticamente desde el nucleo de anna.comm y no deberia
 370      ser usado por el programador final.
 371   */
 372   void detach(ServerSocket* serverSocket) throw();
 373
 374   /**
 375      Desconecta el ClientSocket que fue previamente conectado con #attach
 376      \param clientSocket Instancia del socket que vamos a desconectar.
 377      \warning Este metodo es invocado automaticamente desde el nucleo de ANNA.comm y no deberia
 378      ser usado por el programador final.
 379   */
 380   void detach(ClientSocket* clientSocket) throw();
 381
 382   /**
 383      Desconecta el conector externo de este comunicador. Supone que todas las operaciones
 384      adicionales necesarias para liberar los recursos de este fichero seran realizadas
 385      externamente.
 386
 387      \param handler Controlador de comunicaciones externas.
 388
 389      \warning Exclusivamente uso interno
 390   */
 391   void detach(Handler* handler) throw();
 392
 393   /**
 394      Devuelve el manejador asociado al ClientSocket recibido como parametro.
 395      \param clientSocket Socket cliente del que queremos obtener en handler.
 396      \return El manejador asociado al socket recibido como parametro. Puede ser NULL.
 397   */
 398   const Handler* getHandler(const ClientSocket& clientSocket) throw(RuntimeException);
 399
 400   /**
 401       El thread que invoca a este Metodo entra en un proceso continuo de comprobacin/recepcin
 402       de mensajes, todos los eventos que pueden afectar al comportamiento de nuestro comunicador como son
 403       aceptacin y cierre de conexiones, caidas, recepcin de mensajes, etc, etc se notifican a
 404       traves de los Metodos manejadores de eventos de esta misma clase.
 405       El thread saldra de este bucle tras la invocacion del Metodo #requestStop.
 406    */
 407   void accept() throw(RuntimeException);
 408
 409   /**
 410      Solicita la parada de este comunicador.
 411   */
 412   void requestStop() throw();
 413
 414   /**
 415      Devuelve \em true si el ClientSocket recibido como parametro sigue siendo valido o \em false
 416      en caso de que haya dejado de ser valido debido al cierre del extremo remoto, por ejemplo.
 417
 418      Si el ClientSocket recibido es NULL siempre devolvera \em false.
 419
 420      \return \em true si el ClientSocket recibido como parametro sigue siendo valido o \em false
 421      en caso de que haya dejado de ser valido debido al cierre del extremo remoto, por ejemplo.
 422   */
 423   bool isUsable(const ClientSocket* clientSocket) throw();
 424
 425   /**
 426      Devuelve el numero handlers activos.
 427      \return el numero handlers activos.
 428   */
 429   int handler_size() const throw() { return a_handlers.size(); }
 430
 431   /**
 432      Devuelve un iterador que apunta el primer controlador.
 433      \return un iterador que apunta el primer controlador.
 434   */
 435   handler_iterator handler_begin() throw() { return a_handlers.begin(); }
 436
 437   /**
 438      Devuelve un iterador que apunta al final de la lista de controladores.
 439      \return un iterador que apunta al final de la lista de controladores.
 440   */
 441   handler_iterator handler_end() throw() { return a_handlers.end(); }
 442
 443   /**
 444      Devuelve un iterador que apunta el primer controlador.
 445      \return un iterador que apunta el primer controlador.
 446   */
 447   const_handler_iterator handler_begin() const throw() { return a_handlers.begin(); }
 448
 449   /**
 450      Devuelve un iterador que apunta al final de la lista de controladores.
 451      \return un iterador que apunta al final de la lista de controladores.
 452   */
 453   const_handler_iterator handler_end() const throw() { return a_handlers.end(); }
 454
 455   /**
 456      Devuelve un iterador que apunta el primer servicio.
 457      \return un iterador que apunta el primer service.
 458   */
 459   const_service_iterator service_begin() const throw() { return a_services.begin(); }
 460
 461   /**
 462      Devuelve un iterador que apunta al final de la lista de servicios.
 463      \return un iterador que apunta al final de la lista de servicios.
 464   */
 465   const_service_iterator service_end() const throw() { return a_services.end(); }
 466
 467   /**
 468      Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador ante
 469      un evento generado por el propio programador.
 470
 471      Sera invocado por algun Metodo del programador con el objetivo de actuar sobre su comunicador
 472      en una situacin indeterminada.
 473
 474      La interpretacin del identificador y el contenido de este contexto sera problema exclusivo
 475      del programador ya que ANNA.comm no impone ninguna regla ni realiza ningn tipo de proceso
 476      adicional con estos datos.
 477
 478      @param id Identifica el evento generado.
 479      @param context Contexto asociado al evento que ha generado el usuario.
 480
 481      \warning Este Metodo no debera generar ningn tipo de excepcin.
 482   */
 483   virtual void eventUser(const char* id, const void* context) throw() {;}
 484
 485   /**
 486      Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
 487      el nucleo de ANNA.comm notifica la perdida de conexion con la direccion IP indicada.
 488
 489      \param address Interfaz de red que ha dejado de estar disponible.
 490
 491      \warning
 492      \li La forma en que detectara la caida del interfaz de red no esta dentro del ambito
 493      del problema de ANNA.comm debera haber una capa superior que se encargue de comprobar las
 494      interfaces.
 495      \li El nucleo de ANNA.comm necesita conocer este evento por lo que cualquier implementacin
 496      debera invocar al Metodo eventBreakAddress de su clase base.
 497   */
 498   virtual void eventBreakAddress(const in_addr_t& address) throw();
 499
 500   /**
 501      Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
 502      el nucleo de ANNA.comm notifica la recuperacin de conexion con la direccion IP indicada.
 503
 504      \param address Interfaz de red que ha vuelto a estar disponible.
 505
 506      \warning
 507      \li La forma en que detectara la recuperacin del interfaz de red no esta dentro del ambito
 508      del problema de ANNA.comm debera haber una capa superior que se encargue de comprobar las
 509      interfaces.
 510      \li El nucleo de ANNA.comm necesita conocer este evento por lo que cualquier implementacin
 511      debera invocar al Metodo eventRecoverAddress de su clase base.
 512   */
 513   virtual void eventRecoverAddress(const in_addr_t& address) throw();
 514
 515   /**
 516      Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
 517      el nucleo de ANNA.comm notifica que ha detectado una peticion de conexion desde un
 518      proceso remoto a un ServerSocket asociado a este comunicador.
 519      Cualquier re-implementacion de este metodo debe invocar al metodo de la clase base y
 520      devolver \em false en caso de que este lo devuelva.
 521
 522      @param clientSocket Socket cliente que solicita acceso.
 523
 524      \return \em true si la conexion es acceptada a \em false en otro caso, en cuyo caso se liberaran
 525      automaticamente todos los recursos asociados a la peticion de conexion.
 526
 527      \warning Desde ANNA.comm 1.11.18 se mide el nivel de carga del proceso y si se evalúa como
 528      congestionado no permitirá aceptar la nueva conexión.
 529   */
 530   virtual bool eventAcceptConnection(const ClientSocket& clientSocket) throw(RuntimeException);
 531
 532   /**
 533       Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
 534       el nucleo de ANNA.comm notifica la creacion de una nueva conexion con el proceso servidor
 535       recibido como parametro.
 536
 537       En la mayoria de los casos no sera necesario indicar ninguna accion ya que ANNA.comm realiza
 538       todas las operaciones necesarias.
 539
 540       \warning Cualquier reimplementacion de este metodo debe comenzar invocando al metodo original de la
 541       clase Communicator de la que herede nuestra clase.
 542
 543       @param server Proceso servidor con el que hemos establecido la conexion.
 544
 545       \see Host::createServer
 546    */
 547   virtual void eventCreateConnection(const Server* server) throw();
 548
 549   /**
 550       Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
 551       el nucleo de ANNA.comm notifica la creacion de una nueva conexion con el servicio de reparto
 552       recibido como parametro.
 553
 554       En la mayoria de los casos no sera necesario indicar ninguna accion ya que ANNA.comm realiza
 555       todas las operaciones necesarias.
 556
 557       \warning  Cualquier reimplementacion de este metodo debe comenzar invocando al metodo original de la
 558       clase Communicator de la que herede nuestra clase.
 559
 560       @param service Servicio con el que hemos establecido la conexion.
 561
 562       \see Host::createServer
 563    */
 564   virtual void eventCreateConnection(const Service* service) throw();
 565
 566   /**
 567      Establece las acciones a realizar cuando la clase Communicator detecta la llegada de un
 568      mensaje completo analizado con el protocolo indicado.
 569
 570      Se invocara desde el Metodo #accept cuando se detecta la llegada de un mensaje.
 571
 572      En entorno MT todos los threads actuaran sobre la unica instancia del comm::Communicator
 573      lo que restara eficacia debido al bajo nivel de paralelismo.
 574
 575      @param clientSocket Socket cliente por el que ha llegado el mensaje.
 576      @param message Ultimo mensaje recibido. El bloque de datos recibido ya ha sido
 577      decodificado aplicando las reglas establecidas por la capa de transporte asociado
 578      al ClientSocket por el que llega el mensaje.
 579
 580      \warning Para ANNA.comm version 1.5.2 y posteriores se deberian usar el sistema de
 581      receiveres (anna::comm::Receiver) que ofrece mayor rendimiento y facilita la programacion
 582      en entorno MT.
 583   */
 584   virtual void eventReceiveMessage(ClientSocket& clientSocket, const Message& message)
 585   throw(RuntimeException) { ; }
 586
 587   /**
 588      Establece las acciones a realizar cuando el nucleo de ANNA.comm notifica que ha
 589      cerrado un anna::comm::ClientSocket debido a un consumo excesivo de memoria.
 590      \param clientSocket Socket cliente que va a ser cerrado por el nucleo de ANNA.comm.
 591   */
 592   virtual void eventOverQuota(const ClientSocket& clientSocket) throw() {;}
 593
 594   /**
 595      Establece las acciones a realizar cuando el núcleo de ANNA.comm notifica que ha
 596      cerrado un anna::comm::ClientSocket debido a que ha recibido un mensaje que no
 597      ha sido analizado correctamente.
 598      \param clientSocket Socket cliente que va a ser cerrado por el nucleo de ANNA.comm.
 599   */
 600   virtual void eventDiscardConnection(const ClientSocket& clientSocket) throw() {;}
 601
 602   /**
 603    * Método manejador invocado cuando un client socket que tiene activado el indicador de ignorar los
 604    * mensajes entrantes recibe un mensaje.
 605    * \param clientSocket ClientSocket por el que se recibe el mensaje.
 606    * \param burst Bloque de datos que contiene la trama recibida.
 607    */
 608   virtual void eventIgnoreBurst(const ClientSocket& clientSocket, const DataBlock& burst) throw() {;}
 609
 610   /**
 611      Devuelve una cadena con la informacion mas relevante de esta instancia.
 612      \return Una cadena con la informacion mas relevante de esta instancia.
 613   */
 614   std::string asString() const throw();
 615
 616   /**
 617      Devuelve un documento XML con la informacion mas relevante de esta instancia.
 618      \param parent Nodo XML del que colgar la informacion referente a esta instancia.
 619      \return Un documento XML con la informacion mas relevante de esta instancia.
 620   */
 621   virtual xml::Node* asXML(xml::Node* parent) const throw();
 622
 623   /**
 624      Devuelve el controlador apuntado por el iterador recibido.
 625      \param ii Iterador con el que estamos recorriendo los controladores.
 626      \return el controlador apuntado por el iterador recibido.
 627   */
 628   static Handler* handler(handler_iterator& ii) throw() { return Handlers::data(ii); }
 629
 630   /**
 631      Devuelve el controlador apuntado por el iterador recibido.
 632      \param ii Iterador con el que estamos recorriendo los controladores.
 633      \return el controlador apuntado por el iterador recibido.
 634   */
 635   static const Handler* handler(const_handler_iterator& ii) throw() { return Handlers::data(ii); }
 636
 637   /**
 638      Devuelve el servicio apuntado por el iterador recibido.
 639      \param ii Iterador con el que estamos recorriendo los servicios.
 640      \return el servicio apuntado por el iterador recibido.
 641   */
 642   static const Service* service(const_service_iterator& ii) throw() { return *ii; }
 643
 644   /**
 645      Devuelve la cadena por la que podemos buscar el componente.
 646      \return La cadena por la que podemos buscar el componente.
 647      \see Application::find
 648   */
 649   static const char* getClassName() { return "anna::comm::Communicator"; }
 650
 651 protected:
 652   /**
 653      Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
 654      el nucleo de ANNA.comm notifica la perdida de conexion con un servidor remoto.
 655
 656      En la mayoria de los casos no sera necesario indicar ninguna accion ya que ANNA.comm realiza
 657      todas las operaciones necesarias.
 658
 659      @param clientSocket Socket cliente asociado a esta rotura de conexion.
 660
 661      \warning despues de llamar a este Metodo el clientSocket pasado como parametro se liberara por lo
 662      que despues de este Metodo esta instancia no debera utilizarse.
 663      \warning Estado MT: \code [Tx] -> Communicator \endcode
 664   */
 665   virtual void eventBreakConnection(const ClientSocket& clientSocket) throw() {;}
 666
 667   /**
 668      Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
 669      el nucleo de ANNA.comm notifica la perdida de conexion de una conexion generada por un server socket.
 670
 671      En la mayoria de los casos no sera necesario indicar ninguna accion ya que ANNA.comm realiza
 672      todas las operaciones necesarias.
 673
 674      @param clientSocket Socket cliente asociado a esta rotura de conexion.
 675   */
 676   virtual void eventBreakLocalConnection(const ClientSocket& clientSocket) throw() {;}
 677
 678
 679   /**
 680      Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
 681      el nucleo de ANNA.comm notifica la perdida de conexion con el proceso servidor recibido como
 682      parametro.
 683
 684      Se invocara desde #accept(ServerSocket&) cuando no se detecta la rotura de conexion con un
 685      socket asociado a uno de nuestros servidores.
 686
 687      En la mayoria de los casos no sera necesario indicar ninguna accion ya que ANNA.comm realiza
 688      todas las operaciones necesarias.
 689
 690      Las acciones realizadas por este metodo incluyen:
 691      \li Cierre del socket asociado al proceso servidor cuya conexion ha caido.
 692      \li Reorganizacion del sistema de reparto de carga para que marque el proceso servidor como no disponible.
 693      \li Activar los sistemas de recuperacion de conexion en el caso de que el servidor que ha caido
 694      vuelva a estar disponible.
 695
 696      \warning Cualquier reimplementacion de este metodo debe comenzar invocando al metodo original de la
 697      clase Communicator de la que herede nuestra clase.
 698      \warning Estado MT: \code [Tx] -> Communicator \endcode
 699
 700      @param server Proceso servidor con el que hemos perdido la conexion.
 701   */
 702   virtual void eventBreakConnection(const Server* server) throw();
 703
 704   /**
 705      Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador
 706      cuando el nucleo de anna.comm notifica la perdida de conexion con todos los procesos
 707      asociados al servicio recibido como parametro.
 708
 709      \param service Servicio que ha dejado de estar disponible.
 710      \warning Estado MT: \code [Tx] -> Communicator \endcode
 711   */
 712   virtual void eventBreakConnection(const Service* service) throw();
 713
 714   /**
 715      Establecer la configuracin de este comunicador. El cargador de configuracin se encarga de establecer
 716      los ServerSocket por los que este comunicador va a atender peticiones y/o los procesos servidores
 717      remotos con los que tenemos que establecer el canal de comunicaciones.
 718
 719      \warning Este Metodo debe invocarse desde las clases heredadas.
 720   */
 721   virtual void do_initialize() throw(RuntimeException) {;}
 722
 723   /**
 724      Solicita la parada de este comunicador. Se reimplementa para mantener el interfaz de la clase
 725      Component de la que hereda este Communicator.
 726   */
 727   void do_stop() throw() { requestStop(); }
 728
 729   /**
 730      Establece el estado de este proceso con respecto al sistema de comunicaciones
 731      @param status Estado del sistema de comunicaciones que deseamos establecer.
 732   */
 733   virtual void setStatus(const Status& status) throw();
 734
 735   /**
 736      Establece la conexion entre el comunicador y un socket dedicado a la comparticion de una
 737      determinada direccion IP:puerto.
 738
 739      \param binderSocket Define un socket por el que tratar las peticiones de comparticion
 740      de una determinada direccion IP:puerto.
 741
 742      \internal
 743   */
 744   void attach(BinderSocket* binderSocket) throw(RuntimeException);
 745
 746   /**
 747      Desconecta el BinderSocket que fue previamente conectado con attach(BinderSocket*).
 748      \param binderSocket Instancia del BinderSocket a desconectar.
 749      \warning Exclusivamente uso interno
 750   */
 751   void detach(BinderSocket* binderSocket) throw();
 752
 753   /**
 754      Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
 755      el nucleo de ANNA.comm notifica que este comunicador esta preparado para comenzar a
 756      aceptar y/o enviar mensajes.
 757
 758      Se invocara desde el metodo #accept inmediatamente antes de comenzar a
 759      comprobar la llegada de mensajes.
 760
 761      En la mayoria de los casos no sera necesario indicar ninguna accion ya que ANNA.comm realiza
 762      todas las operaciones necesarias.
 763   */
 764   virtual void eventStartup() throw(RuntimeException) {;}
 765
 766   /**
 767      Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
 768      el nucleo de ANNA.comm notifica que este va a dejar de atender peticiones.
 769
 770      En la mayoria de los casos no sera necesario indicar ninguna accion ya que ANNA.comm realiza
 771      todas las operaciones necesarias.
 772   */
 773   virtual void eventShutdown() throw();
 774
 775 private:
 776   const WorkMode::_v a_workMode;
 777   bool a_isServing;
 778   bool a_requestedStop;
 779   Handlers a_handlers;
 780   Millisecond a_recoveryTime;
 781   Status a_status;
 782   Services a_services;
 783   Millisecond a_timeout;
 784   comm::Handler* a_mainHandler;
 785   ConnectionRecover* a_connectionRecover;
 786   bool a_pendingClose;
 787   Millisecond a_tryingConnectionTime;
 788   int a_levelOfDenialService;
 789
 790   // ST
 791   Poll* a_poll;
 792   Handlers a_timedouts;
 793   void singlethreadedAccept() throw(RuntimeException);
 794
 795   // MT
 796   ThreadManager* a_threadManager;
 797   void multithreadedAccept() throw(RuntimeException);
 798
 799   ConnectionRecover* getConnectionRecover() throw() { return a_connectionRecover; }
 800
 801   void attach(RemoteConnection* remoteConnection) throw(RuntimeException);
 802
 803   void insert(Handler*) throw(RuntimeException);
 804   Handler* find(const int fd) throw() { return a_handlers.find(fd); }
 805
 806   // Reimplementado de app::Component
 807   void do_cloneParent() throw(RuntimeException);
 808   void do_cloneChild() throw();
 809
 810   friend class Handler;
 811
 812   friend class Server;
 813   // attach (RemoteConnection)
 814
 815   friend class handler::RemoteConnection;
 816   // getConnectionRecover, eventBreakConnection
 817
 818   friend class handler::ClientSocket;
 819   // eventBreakConnection
 820
 821   // EDU
 822   friend class handler::LocalConnection;
 823   // eventBreakLocalConnection
 824 };
 825
 826 }
 827 }
 828
 829 #endif
 830