#include <httpconnectionhandlerpool.h>

Inherits QObject.

Collaboration diagram for qtwebapp::HttpConnectionHandlerPool:

Public Member Functions
	HttpConnectionHandlerPool (QSettings settings, HttpRequestHandler requestHandler)

	HttpConnectionHandlerPool (const HttpListenerSettings settings, HttpRequestHandler requestHandler)

virtual	~HttpConnectionHandlerPool ()

HttpConnectionHandler *	getConnectionHandler ()

const HttpListenerSettings *	getListenerSettings () const

Private Slots
void	cleanup ()

Private Member Functions
void	loadSslConfig ()

Private Attributes
QSettings *	settings

const HttpListenerSettings *	listenerSettings

HttpRequestHandler *	requestHandler

QList< HttpConnectionHandler * >	pool

QTimer	cleanupTimer

QMutex	mutex

QSslConfiguration *	sslConfiguration

bool	useQtSettings

Detailed Description

Pool of http connection handlers. The size of the pool grows and shrinks on demand.

Example for the required configuration settings:

minThreads=4
maxThreads=100
cleanupInterval=60000
readTimeout=60000
;sslKeyFile=ssl/my.key
;sslCertFile=ssl/my.cert
maxRequestSize=16000
maxMultiPartSize=1000000

After server start, the size of the thread pool is always 0. Threads are started on demand when requests come in. The cleanup timer reduces the number of idle threads slowly by closing one thread in each interval. But the configured minimum number of threads are kept running.

For SSL support, you need an OpenSSL certificate file and a key file. Both can be created with the command

    openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout my.key -out my.cert

Visit http://slproweb.com/products/Win32OpenSSL.html to download the Light version of OpenSSL for Windows.

Please note that a listener with SSL settings can only handle HTTPS protocol. To support both HTTP and HTTPS simultaneously, you need to start two listeners on different ports - one with SLL and one without SSL.

See also: HttpConnectionHandler for description of the readTimeout; HttpRequest for description of config settings maxRequestSize and maxMultiPartSize

Definition at line 51 of file httpconnectionhandlerpool.h.

Constructor & Destructor Documentation

◆ HttpConnectionHandlerPool() [1/2]

HttpConnectionHandlerPool::HttpConnectionHandlerPool	(	QSettings *	settings,
		HttpRequestHandler *	requestHandler
	)

Constructor.

Parameters

settings	Configuration settings for the HTTP server. Must not be 0.
requestHandler	The handler that will process each received HTTP request.

Warning: The requestMapper gets deleted by the destructor of this pool

Definition at line 12 of file httpconnectionhandlerpool.cpp.

References cleanup(), cleanupTimer, listenerSettings, loadSslConfig(), requestHandler, settings, and sslConfiguration.

     : QObject(), useQtSettings(true)
 {
     Q_ASSERT(settings != 0);
     this->settings = settings;
     this->listenerSettings = 0;
     this->requestHandler = requestHandler;
     this->sslConfiguration = 0;
     loadSslConfig();
     cleanupTimer.start(settings->value("cleanupInterval",1000).toInt());
     connect(&cleanupTimer, SIGNAL(timeout()), SLOT(cleanup()));
 }

Here is the call graph for this function:

◆ HttpConnectionHandlerPool() [2/2]

HttpConnectionHandlerPool::HttpConnectionHandlerPool	(	const HttpListenerSettings *	settings,
		HttpRequestHandler *	requestHandler
	)

Constructor.

Parameters

settings	Configuration settings for the HTTP server as structure
requestHandler	The handler that will process each received HTTP request.

Warning: The requestMapper gets deleted by the destructor of this pool

Definition at line 25 of file httpconnectionhandlerpool.cpp.

References cleanup(), qtwebapp::HttpListenerSettings::cleanupInterval, cleanupTimer, listenerSettings, loadSslConfig(), requestHandler, settings, and sslConfiguration.

     : QObject(), useQtSettings(false)
 {
     Q_ASSERT(settings != 0);
     this->settings = 0;
     this->listenerSettings = settings;
     this->requestHandler = requestHandler;
     this->sslConfiguration = 0;
     loadSslConfig();
     cleanupTimer.start(settings->cleanupInterval);
     connect(&cleanupTimer, SIGNAL(timeout()), SLOT(cleanup()));
 }

Here is the call graph for this function:

◆ ~HttpConnectionHandlerPool()

HttpConnectionHandlerPool::~HttpConnectionHandlerPool ( )

virtual

Destructor

Definition at line 38 of file httpconnectionhandlerpool.cpp.

References handler(), pool, and sslConfiguration.

 {
     // delete all connection handlers and wait until their threads are closed
     foreach(HttpConnectionHandler* handler, pool)
     {
        delete handler;
     }
     delete sslConfiguration;
     qDebug("HttpConnectionHandlerPool (%p): destroyed", this);
 }

Here is the call graph for this function:

Member Function Documentation

◆ cleanup

void HttpConnectionHandlerPool::cleanup ( )

privateslot

Received from the clean-up timer.

Definition at line 85 of file httpconnectionhandlerpool.cpp.

References handler(), qtwebapp::HttpConnectionHandler::isBusy(), listenerSettings, qtwebapp::HttpListenerSettings::minThreads, mutex, pool, settings, and useQtSettings.

Referenced by HttpConnectionHandlerPool().

 {
     int maxIdleHandlers = useQtSettings ? settings->value("minThreads",1).toInt() : listenerSettings->minThreads;
     int idleCounter=0;
     mutex.lock();
     foreach(HttpConnectionHandler* handler, pool)
     {
         if (!handler->isBusy())
         {
             if (++idleCounter > maxIdleHandlers)
             {
                 pool.removeOne(handler);
                 qDebug("HttpConnectionHandlerPool: Removed connection handler (%p), pool size is now %i",handler,pool.size());
                 delete handler;
                 break; // remove only one handler in each interval
             }
         }
     }
     mutex.unlock();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getConnectionHandler()

HttpConnectionHandler * HttpConnectionHandlerPool::getConnectionHandler ( )

Get a free connection handler, or 0 if not available.

Definition at line 50 of file httpconnectionhandlerpool.cpp.

References handler(), qtwebapp::HttpConnectionHandler::isBusy(), listenerSettings, qtwebapp::HttpListenerSettings::maxThreads, mutex, pool, requestHandler, qtwebapp::HttpConnectionHandler::setBusy(), settings, sslConfiguration, and useQtSettings.

Referenced by qtwebapp::HttpListener::incomingConnection().

 {
     HttpConnectionHandler* freeHandler=0;
     mutex.lock();
     // find a free handler in pool
     foreach(HttpConnectionHandler* handler, pool)
     {
         if (!handler->isBusy())
         {
             freeHandler=handler;
             freeHandler->setBusy();
             break;
         }
     }
     // create a new handler, if necessary
     if (!freeHandler)
     {
         int maxConnectionHandlers = useQtSettings ? settings->value("maxThreads",100).toInt() : listenerSettings->maxThreads;
         if (pool.count()<maxConnectionHandlers)
         {
             if (useQtSettings) {
                 freeHandler = new HttpConnectionHandler(settings, requestHandler, sslConfiguration);
             } else {
                 freeHandler = new HttpConnectionHandler(listenerSettings, requestHandler, sslConfiguration);
             }
 
             freeHandler->setBusy();
             pool.append(freeHandler);
         }
     }
     mutex.unlock();
     return freeHandler;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getListenerSettings()

const HttpListenerSettings* qtwebapp::HttpConnectionHandlerPool::getListenerSettings ( ) const

inline

Get a listener settings const reference. Can be changed on the HttpListener only.

Returns: The current listener settings

Definition at line 82 of file httpconnectionhandlerpool.h.

82 { return listenerSettings; }

qtwebapp::HttpConnectionHandlerPool::listenerSettings

const HttpListenerSettings * listenerSettings

Definition: httpconnectionhandlerpool.h:90

◆ loadSslConfig()

void HttpConnectionHandlerPool::loadSslConfig ( )

private

Load SSL configuration

Definition at line 107 of file httpconnectionhandlerpool.cpp.

References listenerSettings, settings, qtwebapp::HttpListenerSettings::sslCertFile, sslConfiguration, qtwebapp::HttpListenerSettings::sslKeyFile, and useQtSettings.

Referenced by HttpConnectionHandlerPool().

 {
     // If certificate and key files are configured, then load them
     QString sslKeyFileName = useQtSettings ? settings->value("sslKeyFile","").toString() : listenerSettings->sslKeyFile;
     QString sslCertFileName = useQtSettings ? settings->value("sslCertFile","").toString() : listenerSettings->sslCertFile;
     if (!sslKeyFileName.isEmpty() && !sslCertFileName.isEmpty())
     {
         #ifdef QT_NO_OPENSSL
             qWarning("HttpConnectionHandlerPool::loadSslConfig: SSL is not supported");
         #else
             // Convert relative fileNames to absolute, based on the directory of the config file.
             QFileInfo configFile(settings->fileName());
             #ifdef Q_OS_WIN32
                 if (QDir::isRelativePath(sslKeyFileName) && settings->format()!=QSettings::NativeFormat)
             #else
                 if (QDir::isRelativePath(sslKeyFileName))
             #endif
             {
                 sslKeyFileName=QFileInfo(configFile.absolutePath(),sslKeyFileName).absoluteFilePath();
             }
             #ifdef Q_OS_WIN32
                 if (QDir::isRelativePath(sslCertFileName) && settings->format()!=QSettings::NativeFormat)
             #else
                 if (QDir::isRelativePath(sslCertFileName))
             #endif
             {
                 sslCertFileName=QFileInfo(configFile.absolutePath(),sslCertFileName).absoluteFilePath();
             }
 
             // Load the SSL certificate
             QFile certFile(sslCertFileName);
             if (!certFile.open(QIODevice::ReadOnly))
             {
                 qCritical("HttpConnectionHandlerPool: cannot open sslCertFile %s", qPrintable(sslCertFileName));
                 return;
             }
             QSslCertificate certificate(&certFile, QSsl::Pem);
             certFile.close();
 
             // Load the key file
             QFile keyFile(sslKeyFileName);
             if (!keyFile.open(QIODevice::ReadOnly))
             {
                 qCritical("HttpConnectionHandlerPool: cannot open sslKeyFile %s", qPrintable(sslKeyFileName));
                 return;
             }
             QSslKey sslKey(&keyFile, QSsl::Rsa, QSsl::Pem);
             keyFile.close();
 
             // Create the SSL configuration
             sslConfiguration=new QSslConfiguration();
             sslConfiguration->setLocalCertificate(certificate);
             sslConfiguration->setPrivateKey(sslKey);
             sslConfiguration->setPeerVerifyMode(QSslSocket::VerifyNone);
             sslConfiguration->setProtocol(QSsl::TlsV1SslV3);
 
             qDebug("HttpConnectionHandlerPool: SSL settings loaded");
          #endif
     }
 }