ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR > Class Template Reference

#include <Acceptor.h>

Inheritance diagram for ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >:

ASSA::EventHandler

List of all members.

Public Member Functions

 Acceptor (Reactor *r_)
 Default constructor.
virtual ~Acceptor ()
 Do-nothing destructor.
virtual int open (const Address &local_addr_)
 Initialize listener endpoint and Acceptor with Reactor.
virtual int close (void)
 Close PEER_ACCEPTOR stream.
int handle_read (int fd)
 Callback invoked by Reactor when new connection requests is detected.
virtual int handle_close (int fd)
 Callback invoked by Reactor if PEER_ACCEPTOR stream went bad, or Reactor has been commanded to stop event processing.

Protected Member Functions

virtual SERVICE_HANDLER * makeServiceHandler (PEER_ACCEPTOR *sock_)
 Defines creation strategy for ServiceHandler.
virtual int acceptServiceHandler (PEER_ACCEPTOR *&new_socket_)
 Default strategy is to accept new connection.
virtual int activateServiceHandler (PEER_ACCEPTOR *new_socket_)
 Defines the concurrency strategy.

Protected Attributes

PEER_ACCEPTOR m_listenSocket
 Underlying communication stream.

Private Attributes

Reactorm_reactor
 Reactor to use.


Detailed Description

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
class ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >

Definition at line 43 of file Acceptor.h.


Constructor & Destructor Documentation

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::Acceptor ( Reactor r_  )  [inline]

Default constructor.

Parameters:
r_ Reactor to use

Definition at line 144 of file Acceptor.h.

References trace.

00145     : m_reactor (r_)
00146 {
00147     trace("Acceptor::Acceptor");
00148 }

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::~Acceptor (  )  [inline, virtual]

Do-nothing destructor.

Underlying PEER_ACCEPTOR stream will be closed during its own destruction sequence.

Definition at line 153 of file Acceptor.h.

References trace.

00154 {
00155     trace("Acceptor::~Acceptor");
00156 }


Member Function Documentation

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
int ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::open ( const Address local_addr_  )  [inline, virtual]

Initialize listener endpoint and Acceptor with Reactor.

Derive classes can change this strategy by overloading this method.

Returns:
0 on success, -1 on error. An error can be if either PEER_ACCEPTOR's open() or bind() failed.

Definition at line 224 of file Acceptor.h.

References DL, ASSA::Address::getAddress(), ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::m_listenSocket, ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::m_reactor, ASSA::READ_EVENT, ASSA::Reactor::registerIOHandler(), ASSA::TRACE, and trace.

00225 {
00226     trace("Acceptor::open");
00227     
00228     if ( !m_listenSocket.open (local_addr_.getAddress ()->sa_family) ) {
00229         return -1;
00230     }
00231 
00232     if ( !m_listenSocket.bind (local_addr_) ) {
00233         return -1;
00234     }
00235 
00236     m_reactor->registerIOHandler (
00237         this, m_listenSocket.getHandler (), READ_EVENT);
00238     
00239     DL((TRACE,"Opened acceptor for fd=%d\n", 
00240         m_listenSocket.getHandler ()));
00241 
00242     return 0;
00243 }

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
int ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::close ( void   )  [inline, virtual]

Close PEER_ACCEPTOR stream.

Returns:
0 on success, -1 on error.

Definition at line 161 of file Acceptor.h.

References ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::m_listenSocket, and trace.

00162 {
00163     trace("Acceptor::close");
00164     m_listenSocket.close ();
00165     return 0;
00166 }

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
int ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::handle_read ( int  fd  )  [inline, virtual]

Callback invoked by Reactor when new connection requests is detected.

Default strategy is to accept ALL awaiting incoming connections at once. Derived class can change this strategy by overloading this method.

Returns:
0 on success, -1 on error. Returning -1 will effectively instruct Reactor to remove this Handler from the Reactor.

Reimplemented from ASSA::EventHandler.

Definition at line 252 of file Acceptor.h.

References ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::acceptServiceHandler(), ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::activateServiceHandler(), ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::m_listenSocket, PA, ASSA::FdSet::reset(), ASSA::FdSet::setFd(), and trace.

00253 {
00254     trace("Acceptor<>::handle_read");
00255 
00256     FdSet mask;
00257     timeval poll = {0, 0};
00258     PA* new_socket = 0;
00259 
00260     int fd = m_listenSocket.getHandler ();
00261 
00262     if (fd != fd_) {
00263         return -1;
00264     }
00265 
00266     do {
00267         if ( acceptServiceHandler (new_socket) == -1 ) {
00268             return -1;
00269         }
00270         if ( !activateServiceHandler (new_socket) == -1 ) {
00271             return -1;
00272         }
00273         mask.reset ();
00274         mask.setFd (fd);
00275     }
00276     while ((::select (fd+1, &mask, NULL, NULL, &poll) == 1));
00277 
00278     return 0;
00279 }

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
int ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::handle_close ( int  fd  )  [inline, virtual]

Callback invoked by Reactor if PEER_ACCEPTOR stream went bad, or Reactor has been commanded to stop event processing.

This method should always return -1, if stream cannot be repared. Derived class can change this strategy by overloading this method. If called object is other then Reactor, an explicit call to Reactor::removeHandler (this->id()) is required. By default behavior, Acceptor will destroy itself.

Returns:
-1 always

Reimplemented from ASSA::EventHandler.

Definition at line 171 of file Acceptor.h.

References DL, ASSA::EventHandler::get_id(), ASSA::REACT, and trace.

00172 {
00173     trace("Acceptor::handle_close");
00174     
00175     // Reactor::get_instance ()->removeHandler (this->id());
00176     
00177     // NOT IMPLEMENTED: This spot requires validation
00178     // whether Acceptor is created on the heap or in
00179     // automatic memory.
00180     DL ((REACT,"Deleted acceptor \"%s\"\n", get_id ().c_str ()));
00181     delete this;
00182     return -1;
00183 }

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
SERVICE_HANDLER * ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::makeServiceHandler ( PEER_ACCEPTOR *  sock_  )  [inline, protected, virtual]

Defines creation strategy for ServiceHandler.

Returns:
pointer to SERVICE_HANDLER

Definition at line 188 of file Acceptor.h.

References trace.

Referenced by ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::activateServiceHandler().

00189 {
00190     trace("Acceptor<>::makeServiceHandler");
00191     
00192     return new SERVICE_HANDLER (sock_);
00193 }

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
int ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::acceptServiceHandler ( PEER_ACCEPTOR *&  new_socket_  )  [inline, protected, virtual]

Default strategy is to accept new connection.

Derived class can change this strategy by overloading this method.

Parameters:
new_socket_ On return will have a pointer to newly created PEER_STREAM, or =0 if failed
Returns:
0 on success, -1 on error.

Definition at line 198 of file Acceptor.h.

References ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::m_listenSocket, and trace.

Referenced by ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::handle_read().

00199 {
00200     trace("Acceptor::acceptServiceHandler");
00201     
00202     new_socket_ = m_listenSocket.accept ();
00203     return new_socket_ ? 0 : -1;
00204 }

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
int ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::activateServiceHandler ( PEER_ACCEPTOR *  new_socket_  )  [inline, protected, virtual]

Defines the concurrency strategy.

Default is to create SERVICE_HANDLERin current process(thread), call its open() methid and let Reactor handle its I/O events. Derived class changes this strategy by overloading this class.

Parameters:
new_socket_ [in] PEER_STREAM pointer to activate
Returns:
0 on success, -1 on error.

Definition at line 208 of file Acceptor.h.

References ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::makeServiceHandler(), SH, and trace.

Referenced by ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::handle_read().

00209 {
00210     trace("Acceptor::activateServiceHandler");
00211 
00212     if (!new_socket_) {
00213         return -1;
00214     }
00215     SH* sh = makeServiceHandler (new_socket_);
00216     if (sh->open () < 0) {
00217         sh->close ();
00218     }
00219     return 0;
00220 }


Member Data Documentation

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
PEER_ACCEPTOR ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::m_listenSocket [protected]

Underlying communication stream.

Definition at line 123 of file Acceptor.h.

Referenced by ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::acceptServiceHandler(), ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::close(), ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::handle_read(), and ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::open().

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
Reactor* ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::m_reactor [private]

Reactor to use.

Definition at line 129 of file Acceptor.h.

Referenced by ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::open().


The documentation for this class was generated from the following file:
Generated on Sun Feb 10 14:34:38 2008 for libassa by  doxygen 1.5.4