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 143 of file Acceptor.h.

References trace.

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

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 151 of file Acceptor.h.

References trace.

00152 {
00153     trace("Acceptor::~Acceptor");
00154 }


Member Function Documentation

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 192 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().

00193 {
00194     trace("Acceptor::acceptServiceHandler");
00195     
00196     new_socket_ = m_listenSocket.accept ();
00197     return new_socket_ ? 0 : -1;
00198 }

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
int ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::activateServiceHandler PEER_ACCEPTOR *  new_socket_  )  [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 201 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().

00202 {
00203     trace("Acceptor::activateServiceHandler");
00204 
00205     if (!new_socket_) {
00206         return -1;
00207     }
00208     SH* sh = makeServiceHandler (new_socket_);
00209     sh->open ();
00210     return 0;
00211 }

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 158 of file Acceptor.h.

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

00159 {
00160     trace("Acceptor::close");
00161     m_listenSocket.close ();
00162     return 0;
00163 }

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 167 of file Acceptor.h.

References trace.

00168 {
00169     trace("Acceptor::handle_close");
00170     
00171     // Reactor::get_instance ()->removeHandler (this->id());
00172     
00173     // NOT IMPLEMENTED: This spot requires validation
00174     // whether Acceptor is created on the heap or
00175     // automatic memory.
00176     
00177     delete this;
00178     return -1;
00179 }

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
int ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::handle_read int  fd  )  [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 239 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.

00240 {
00241     trace("Acceptor<>::handle_read");
00242 
00243     int fd = m_listenSocket.getHandler ();
00244 
00245     if (fd != fd_) return -1;
00246 
00247     FdSet mask;
00248     timeval poll = {0, 0};
00249     PA* new_socket;
00250 
00251     do {
00252         if ( acceptServiceHandler (new_socket) == -1 ) {
00253             return -1;
00254         }
00255         if ( !activateServiceHandler (new_socket) == -1 ) {
00256             return -1;
00257         }
00258         mask.reset ();
00259         mask.setFd (fd);
00260     }
00261     while ( (::select (fd+1, &mask, NULL, NULL, &poll) == 1) );
00262 
00263     return 0;
00264 }

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 183 of file Acceptor.h.

References trace.

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

00184 {
00185     trace("Acceptor<>::makeServiceHandler");
00186     
00187     return new SERVICE_HANDLER (sock_);
00188 }

template<class SERVICE_HANDLER, class PEER_ACCEPTOR>
int ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::open const Address local_addr_  )  [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 214 of file Acceptor.h.

References ASSA::Address::getAddress(), ASSA::Acceptor< SERVICE_HANDLER, PEER_ACCEPTOR >::m_listenSocket, and trace.

00215 {
00216     trace("Acceptor::open");
00217     
00218     if ( !m_listenSocket.open (local_addr_.getAddress ()->sa_family) ) {
00219         return -1;
00220     }
00221 
00222     if ( !m_listenSocket.bind (local_addr_) ) {
00223         return -1;
00224     }
00225 
00226     m_reactor->registerIOHandler (
00227         this, m_listenSocket.getHandler (), READ_EVENT);
00228     
00229     DL((TRACE,"Acceptor on FD - %d\n", m_listenSocket.getHandler ()));
00230     return 0;
00231 }


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.


The documentation for this class was generated from the following file:
Generated on Wed Jun 21 18:54:02 2006 for libassa by  doxygen 1.4.6