Method enqueue

base/poco/Net/src/TCPServerDispatcher.cpp:142–194

    
void TCPServerDispatcher::enqueue(const StreamSocket& socket)
{
    FastMutex::ScopedLock lock(_mutex);

    ErrorHandler::logMessage(Message::PRIO_TEST, "Queue size: " + std::to_string(_queue.size()) +
                                 ", current threads: " + std::to_string(_currentThreads) +
                                 ", threads in pool: " + std::to_string(_threadPool.allocated()) +
                                 ", current connections: " + std::to_string(_currentConnections));


    if (_queue.size() < _pParams->getMaxQueued())
    {
        /// NOTE: the condition below is wrong.
        /// Since the thread pool is shared between multiple servers/TCPServerDispatchers,
        /// _currentThreads < _pParams->getMaxThreads() will be true when the pool is actually saturated.
        /// As a result, queue is useless and connections never wait in queue.
        /// Instead, we (mistakenly) think that we can create a thread for this connection, but we fail to create it
        /// and the connection get rejected.
        /// We could check _currentThreads < _threadPool.allocated() to make it work,
        /// but it's not clear if we want to make it work
        /// because it may be better to reject connection immediately if we don't have resources to handle it.
        if (!_queue.hasIdleThreads() && _currentThreads < _pParams->getMaxThreads())
        {
            try
            {
                this->duplicate();
                _threadPool.startWithPriority(_pParams->getThreadPriority(), *this, threadName);
                ++_currentThreads;
            }
            catch (Poco::Exception& exc)
            {
                ErrorHandler::logMessage(Message::PRIO_WARNING, "Got an exception while starting thread for connection from " +
                                             socket.peerAddress().toString());
                ErrorHandler::handle(exc);
                this->release();
                ++_refusedConnections;
                return;
            }
        }
        else if (!_queue.hasIdleThreads())
        {
            ErrorHandler::logMessage(Message::PRIO_TRACE, "Don't have idle threads, adding connection from " +
                                         socket.peerAddress().toString() + " to the queue, size: " + std::to_string(_queue.size()));
        }
        _queue.enqueueNotification(new TCPConnectionNotification(socket));
    }
    else
    {
        ErrorHandler::logMessage(Message::PRIO_WARNING, "Refusing connection from " + socket.peerAddress().toString() +
                                     ", reached max queue size " + std::to_string(_pParams->getMaxQueued()));
        ++_refusedConnections;
    }
}


void TCPServerDispatcher::stop()