/// This class implements the Acceptor part of the Acceptor-Connector design pattern.

/// Only the difference from single-threaded version is documented here, For full

/// description see Poco::Net::SocketAcceptor documentation.

///

/// This is a multi-threaded version of SocketAcceptor, it differs from the

/// single-threaded version in number of reactors (defaulting to number of processors)

/// that can be specified at construction time and is rotated in a round-robin fashion

/// by event handler. See ParallelSocketAcceptor::onAccept and

/// ParallelSocketAcceptor::createServiceHandler documentation and implementation for

/// details.

{

typedef Poco::Net::ParallelSocketReactor<SR> ParallelReactor;

explicit ParallelSocketAcceptor(ServerSocket& socket,

unsigned threads = Poco::Environment::processorCount()):

_socket(socket),

_pReactor(0),

_threads(threads),

_next(0)

/// Creates a ParallelSocketAcceptor using the given ServerSocket,

/// sets number of threads and populates the reactors vector.

{

init();

}

ParallelSocketAcceptor(ServerSocket& socket,

SocketReactor& reactor,

unsigned threads = Poco::Environment::processorCount()):

_socket(socket),

_pReactor(0),

_threads(threads),

_next(0)

/// Creates a ParallelSocketAcceptor using the given ServerSocket, sets the

/// number of threads, populates the reactors vector and registers itself

/// with the given SocketReactor.

{

init();

registerAcceptor(reactor);

}

virtual ~ParallelSocketAcceptor()

/// Destroys the ParallelSocketAcceptor.

{

unregisterAcceptor();

}

virtual void registerAcceptor(SocketReactor& reactor)

/// Registers the ParallelSocketAcceptor with a SocketReactor.

///

/// A subclass can override this and, for example, also register

/// an event handler for a timeout event.

///

/// The overriding method must call the baseclass implementation first.

{

_pReactor = &reactor;

_pReactor->addEventHandler(_socket,

Poco::Observer<ParallelSocketAcceptor,

ReadableNotification>(*this, &ParallelSocketAcceptor::onAccept));

}

virtual void unregisterAcceptor()

/// Unregisters the ParallelSocketAcceptor.

///

/// A subclass can override this and, for example, also unregister

/// its event handler for a timeout event.

///

/// The overriding method must call the baseclass implementation first.

{

_pReactor->removeEventHandler(_socket,

Poco::Observer<ParallelSocketAcceptor,

ReadableNotification>(*this, &ParallelSocketAcceptor::onAccept));

}

void onAccept(ReadableNotification* pNotification)

/// Accepts connection and creates event handler.

{

pNotification->release();

StreamSocket sock = _socket.acceptConnection();

createServiceHandler(sock);

}

virtual ServiceHandler* createServiceHandler(StreamSocket& socket)

/// Create and initialize a new ServiceHandler instance.

///

/// Subclasses can override this method.

{

std::size_t next = _next++;

if (_next == _reactors.size()) _next = 0;

return new ServiceHandler(socket, *_reactors[next]);

}

SocketReactor* reactor()

/// Returns a pointer to the SocketReactor where

/// this SocketAcceptor is registered.

///

/// The pointer may be null.

{

return _pReactor;

}

Socket& socket()

/// Returns a reference to the SocketAcceptor's socket.

{

return _socket;

}

void init()

/// Populates the reactors vector.

{

poco_assert (_threads > 0);

for (unsigned i = 0; i < _threads; ++i)

_reactors.push_back(new ParallelReactor);

}

typedef std::vector<typename ParallelReactor::Ptr> ReactorVec;

ParallelSocketAcceptor();

ParallelSocketAcceptor(const ParallelSocketAcceptor&);

ParallelSocketAcceptor& operator = (const ParallelSocketAcceptor&);

ServerSocket _socket;

SocketReactor* _pReactor;

unsigned _threads;

ReactorVec _reactors;

std::size_t _next;