Revision control
Copy as Markdown
// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QtHttpServer/qhttpserver.h>
#include <QtHttpServer/qhttpserverrequest.h>
#include <QtHttpServer/qhttpserverrouterrule.h>
#include <QtTest/qtest.h>
#include <QtConcurrent/qtconcurrentrun.h>
#include <QtCore/qbytearray.h>
#include <QtCore/qlist.h>
#include <QtCore/qurl.h>
#include <QtCore/qstring.h>
#include <QtCore/qsemaphore.h>
#include <QtCore/qtimer.h>
#include <QtNetwork/qnetworkaccessmanager.h>
#include <QtNetwork/qtcpserver.h>
#include <QtNetwork/qtcpsocket.h>
#ifndef QTEST_THROW_ON_FAIL
# error This test requires QTEST_THROW_ON_FAIL being active.
#endif
#if QT_CONFIG(localserver)
#include <QtNetwork/qlocalsocket.h>
#include <QtNetwork/qlocalserver.h>
#endif
#if QT_CONFIG(ssl)
// TODO check if guards are necessary
#include <QtNetwork/qsslconfiguration.h>
#include <QtNetwork/qsslkey.h>
#include <QtNetwork/qsslserver.h>
#include <QtTest/private/qtesthelpers_p.h>
constexpr char g_privateKey[] = R"(-----BEGIN RSA PRIVATE KEY-----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-----END RSA PRIVATE KEY-----)";
constexpr char g_certificate[] = R"(-----BEGIN CERTIFICATE-----
MIIFszCCA5ugAwIBAgIUfpP54qSLfus/pFUIBDizbnrDjE4wDQYJKoZIhvcNAQEL
BQAwaDELMAkGA1UEBhMCRlIxDzANBgNVBAgMBkZyYW5jZTERMA8GA1UEBwwIR3Jl
bm9ibGUxFjAUBgNVBAoMDVF0Q29udHJpYnV0b3IxHTAbBgNVBAMMFHFodHRwc3Nl
cnZlcnRlc3QuY29tMCAXDTIyMDIwNzE0MzE0NVoYDzIyNjgwNzA3MTQzMTQ1WjBo
MQswCQYDVQQGEwJGUjEPMA0GA1UECAwGRnJhbmNlMREwDwYDVQQHDAhHcmVub2Js
ZTEWMBQGA1UECgwNUXRDb250cmlidXRvcjEdMBsGA1UEAwwUcWh0dHBzc2VydmVy
dGVzdC5jb20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC92u1m1Wq7
CIbXb693c6NFWJt0rY5vvcM45aBvmsiBD4HZTNw4VrTGyJHJz9tqb0IQSqCflgdK
f3kske83d1uwDy+sWohdOSKwUC4cmqyaxhlsAiIJfy3W2VxSZCwmaNnUgqGTfuWA
YwqRzbw6H8IdtOuEllZ1DKgFs1vwp6pIeR49i7T8Ey07+WuRcmNXoFeArwGA6ol8
6qsYKwG9b6ypnP0PnVkEFVvdgKsFk/bQ1UDnFlSo4XBLeOf72E7VeUlzCIUDdXNT
u5JW3bOPOFfSIfDoY5VuNHghK2of/LShr1H2ZBrSGbNDstxX02KCFfmQzw+yBP2L
peG/aeayOk+t4tiBeheqkNGsvQ9HQJK2za5xF1+EyFjxWI2hqtnXZnYJNo3GIc8b
M1g0k9pAbjSjcsRtDcY/uKBnyCj999JX6RklLmO4AcKxS81QDiC8V9VcvHOgbqp7
AtdIJeioPIn1PuDgvzVbX2GwHFWnyAOpUCIGemD4ZMtoLr1Y6b04xcRE5M6WKfuD
GVDSlk77b8ze4UWj+FeUgf8xvk08qWk0GqAumojC0Yy6C3sPH0mgzBa8QGXMyB7J
xiY1fBIex1DmTEVLm5i5kSuLrZeuT9ZaV6/88MJF1xJSGuNVI2i0VC94YpLALnPY
U4AhmKgDSY/GwGLFJpBjx+GJoLnJ1TDgXQIDAQABo1MwUTAdBgNVHQ4EFgQUK7Un
0JA3DBUVhclrm6pIZsO60U4wHwYDVR0jBBgwFoAUK7Un0JA3DBUVhclrm6pIZsO6
0U4wDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAgEAuvSFAgfgurDT
/dbXuJ0O+FuGg4NOTNRil5ji3DnMzReIHpSiKiXu76PHHRFnlosvfAFOHlpYntun
LhbUAxim/iIgWZR33uzvqXMXBORZ0zffjy2SjGCW8ZJYyTmg9c0tc0jEjv7owtlU
m6tUXMOs9U0CzvEKLt0K0dMALaLkXtscuzEWA4PHVvnvTu0Wyjj/8n+DgYzY09kC
YF0lJfcG6bddDgspmYyFpULeGGP7+qwgGh4cVBtY5I4Htr3p7hDo6UGDF6AsMQZF
1CAEgBVRbJgI2GTnptpm9k3EFKwQ81z5O+NnP3ZsuuZ3CEVaPHyQf/POLAIhmZLt
0vS9qoRiS4uMUJDXz2kJFBOFHki073eMvHiKtlpYOlJXMQ4MkHCydjeeuhHcgUCq
ZDWuQMmq/8tMwf4YtvxYtXzAMVW9dM8BgWu2G8/JwPMGUGhLfKkHmc8dlQzGDe/W
K/uVHlJZNF4Y0eXVlq9DUhpvKOjGc8A208wQlsTUgPxljgJ2+4F3D+t0luc3h65m
25iw8eRGuYDoCQLG7u7MI0g8A0H+0h9Xrt8PQql86vmQhmTUhKfedVGOo2t2Bcfn
ignL7f4e1m2jh0oWTLhuP1hnVFN4KAKpVIJXhbEkH59cLCN6ARXiEHCM9rmK5Rgk
NQZlAZc2w1Ha9lqisaWWpt42QVhQM64=
-----END CERTIFICATE-----)";
#endif // QT_CONFIG(ssl)
#include <atomic>
QT_BEGIN_NAMESPACE
using namespace Qt::StringLiterals;
using namespace std::chrono_literals;
enum ServerType
{
HTTP1_0,
HTTP1_1,
#if QT_CONFIG(ssl)
SSL,
#endif
#if QT_CONFIG(localserver)
LOCAL
#endif
};
static int port = 0;
#if QT_CONFIG(ssl)
static int sslPort = 0;
#endif
static const QString local = u"tst_qhttpservermultithreaded"_s + QString::number(QCoreApplication::applicationPid());
// Simple HTTP 1.1 client
class LocalHttpClient
{
public:
LocalHttpClient(ServerType type);
~LocalHttpClient();
QString get(const QString &url, const QHttpHeaders &headers = {});
QString getSlowRead(const QString &url, qsizetype chunkSize, qsizetype mSleep,
const QHttpHeaders &headers);
void pipelinedSendGet(const QString &url);
QString piplinedFetchResults();
QString postSlow(const QString &url, const QHttpHeaders &headers, qsizetype mSleep);
private:
void sendGet(const QString &url, const QHttpHeaders &headers = {});
QString fetchResults();
void fetchStatusLine();
void fetchCrLf();
QIODevice *socket = nullptr;
QByteArray version;
ServerType serverType;
};
LocalHttpClient::LocalHttpClient(ServerType type)
: version(type == HTTP1_0 ? "HTTP/1.0" : "HTTP/1.1"), serverType(type)
{
if (type == HTTP1_0 || type == HTTP1_1) {
QTcpSocket *tcpSocket = new QTcpSocket();
tcpSocket->connectToHost("localhost", port);
tcpSocket->waitForConnected();
QVERIFY2(tcpSocket->waitForConnected(),
"Failed waiting for client TCP socket to be connected");
socket = tcpSocket;
#if QT_CONFIG(ssl)
} else if (type == SSL) {
QVERIFY2(QSslSocket::supportsSsl(),
"Client SSL socket requested even though it is not supported");
QSslSocket *sslSocket = new QSslSocket();
const QList<QSslError> expectedSslErrors = {
QSslError(QSslError::SelfSignedCertificate, QSslCertificate(g_certificate)),
// Non-OpenSSL backends are not able to report a specific error code
// for self-signed certificates.
QSslError(QSslError::CertificateUntrusted, QSslCertificate(g_certificate)),
QSslError(QSslError::HostNameMismatch, QSslCertificate(g_certificate)),
};
sslSocket->ignoreSslErrors(expectedSslErrors);
sslSocket->connectToHostEncrypted("localhost", sslPort);
QVERIFY2(sslSocket->waitForEncrypted(),
"Failed waiting for client SSL socket to be encrypted");
socket = sslSocket;
#endif
#if QT_CONFIG(localserver)
} else if (type == LOCAL) {
QLocalSocket *localSocket = new QLocalSocket();
#ifdef Q_OS_LINUX
localSocket->setSocketOptions(QLocalSocket::AbstractNamespaceOption);
#endif
localSocket->connectToServer(local);
QVERIFY2(localSocket->waitForConnected(),
"Failed waiting for client local socket to be connected");
socket = localSocket;
#endif
} else {
QFAIL("Unknown server type");
}
}
LocalHttpClient::~LocalHttpClient()
{
delete socket;
}
void LocalHttpClient::pipelinedSendGet(const QString &url)
{
sendGet(url);
}
QString LocalHttpClient::piplinedFetchResults()
{
return fetchResults();
}
QString LocalHttpClient::get(const QString &url, const QHttpHeaders &headers)
{
sendGet(url, headers);
return fetchResults();
}
QString LocalHttpClient::getSlowRead(const QString &url, qsizetype chunkSize, qsizetype mSleep,
const QHttpHeaders &headers)
{
sendGet(url, headers);
qint64 contentLength = -1;
constexpr qint64 headerBufferSize = 4 * 1024;
char headerBuffer[headerBufferSize];
qint64 read = 0;
forever {
while (!socket->canReadLine()) {
socket->waitForReadyRead(10);
}
read = socket->readLine(headerBuffer, headerBufferSize);
QVERIFY2(read >= 0, "IO error reading headers");
if (read <= 2)
break; // End of headers
QByteArrayView line(headerBuffer, read);
auto colon = line.indexOf(':');
if (colon != -1 && colon + 1 < line.size()) {
auto headerTitle = line.first(colon);
if (headerTitle.compare("Content-Length", Qt::CaseInsensitive) == 0)
contentLength = line.sliced(colon + 1).trimmed().toLongLong();
}
};
QVERIFY2(contentLength != -1, "Content-Length field missing");
if (contentLength == 0)
return u""_s; // No content
read = 0;
QByteArray buffer(contentLength, Qt::Uninitialized);
forever {
qint64 result = socket->read(&buffer[read], qMin(contentLength - read, chunkSize));
QVERIFY2(result >= 0, "IO error reading content");
read += result;
if (read == contentLength)
break;
if (mSleep > 0)
QThread::msleep(mSleep);
socket->waitForReadyRead(10);
};
return QString::fromUtf8(buffer);
}
QString LocalHttpClient::postSlow(const QString &url, const QHttpHeaders &headers, qsizetype mSleep)
{
Q_ASSERT(socket);
qint64 result = socket->write(u"POST %1 %2\r\n"_s.arg(url, version).toUtf8());
QVERIFY2(result != -1, "Error writing POST method");
for (qsizetype i = 0; i < headers.size(); ++i) {
QByteArray output;
output.append(headers.nameAt(i));
output.append(": ");
output.append(headers.valueAt(i));
output.append("\r\n");
result = socket->write(output);
QVERIFY2(result >= 0, "Error writing header line");
QTimer timer;
timer.setSingleShot(true);
timer.start(mSleep);
socket->waitForBytesWritten(mSleep);
int remaining = timer.remainingTime();
if (remaining > 0)
QThread::msleep(remaining);
}
result = socket->write("\r\n");
QVERIFY2(result >= 0, "Error ending headers");
return fetchResults();
}
void LocalHttpClient::sendGet(const QString &url, const QHttpHeaders &headers)
{
Q_ASSERT(socket);
socket->write(u"GET %1 %2\r\n"_s.arg(url, version).toUtf8());
for (qsizetype i = 0; i < headers.size(); ++i) {
QByteArray output;
output.append(headers.nameAt(i));
output.append(": ");
output.append(headers.valueAt(i));
output.append("\r\n");
socket->write(output);
}
socket->write("\r\n");
}
void LocalHttpClient::fetchStatusLine()
{
Q_ASSERT(socket);
constexpr qint64 bufferSize = 4 * 1024;
char buffer[bufferSize];
qint64 read = 0;
while (!socket->canReadLine())
socket->waitForReadyRead(10);
read = socket->readLine(buffer, bufferSize);
QVERIFY2(read > 2, "Status line too short");
QByteArrayView line(buffer, read);
auto space = line.indexOf(' ');
QVERIFY2(space != -1, "Error parsing status line");
auto httpVersion = line.first(space);
QCOMPARE(httpVersion, version);
}
QString LocalHttpClient::fetchResults()
{
Q_ASSERT(socket);
fetchStatusLine();
qint64 contentLength = -1;
QByteArray transferEncoding;
constexpr qint64 bufferSize = 4 * 1024;
char buffer[bufferSize];
qint64 read = 0;
forever {
while (!socket->canReadLine()) {
socket->waitForReadyRead(10);
}
read = socket->readLine(buffer, bufferSize);
QVERIFY2(read >= 0, "IO error reading header");
if (read <= 2)
break; // End of headers
QByteArrayView line(buffer, read);
auto colon = line.indexOf(':');
if (colon != -1 && colon + 1 < line.size()) {
auto headerTitle = line.first(colon);
if (headerTitle.compare("Content-Length", Qt::CaseInsensitive) == 0)
contentLength = line.sliced(colon + 1).trimmed().toLongLong();
else if (headerTitle.compare("Transfer-Encoding", Qt::CaseInsensitive) == 0)
transferEncoding = line.sliced(colon + 1).trimmed().toByteArray();
}
};
QVERIFY2(contentLength < bufferSize, "Buffer too small");
if (contentLength == 0)
return u""_s; // No content
if (contentLength > 0) {
read = 0;
while (read < contentLength) {
socket->waitForReadyRead(10);
qint64 result = socket->read(&buffer[read], contentLength - read);
QVERIFY2(result >= 0, "IO Error reading content");
read += result;
};
} else if (transferEncoding.compare("chunked", Qt::CaseInsensitive) == 0) {
QVERIFY2(serverType != HTTP1_0, "Chunked encoding not supported for HTTP/1.0");
read = 0;
forever {
while (!socket->canReadLine())
socket->waitForReadyRead(10);
QByteArray line = socket->readLine();
qint64 result = line.trimmed().toInt(nullptr, 16);
if (result == 0) {
fetchCrLf();
contentLength = read;
break;
}
qint64 toRead = qMin(result, bufferSize - read);
while (toRead > 0) {
result = socket->read(&buffer[read], toRead);
QVERIFY2(result >= 0, "Read error decoding chunked encoding");
read += result;
toRead -= result;
if (toRead)
socket->waitForReadyRead(10);
}
fetchCrLf();
};
} else {
// Read until closed
read = 0;
while (read < bufferSize) {
socket->waitForReadyRead(10);
qint64 result = socket->read(&buffer[read], bufferSize - read);
if (result == -1) {
contentLength = read;
break;
}
read += result;
};
}
return QString::fromUtf8(buffer, contentLength);
}
void LocalHttpClient::fetchCrLf()
{
qint64 read = 0;
char buffer[2];
while (read < 2) {
qint64 toRead = 2 - read;
qint64 result = socket->read(&buffer[read], toRead);
QVERIFY2(result >= 0, "Read error decoding chunked encoding");
read += result;
if (read < 2)
socket->waitForReadyRead(10);
}
QVERIFY2(buffer[0] == '\r' && buffer[1] == '\n', "Read error decoding chunked encoding");
}
class SequentialIODevice : public QIODevice
{
Q_OBJECT
public:
SequentialIODevice(const QByteArray &data, int times, std::chrono::milliseconds readInterval)
: message(data), times(times)
{
setOpenMode(QIODeviceBase::ReadOnly);
timer = new QTimer(this);
timer->callOnTimeout(this, &SequentialIODevice::onTimeout);
timer->setSingleShot(false);
timer->setInterval(readInterval);
timer->start();
}
bool isSequential() const override { return true; }
qint64 bytesAvailable() const override { return buffer.size() - readPos; }
qint64 bytesToWrite() const override { return 0; }
bool seek(qint64) override
{
return false; // No random accesss on sequential devices
}
qint64 readData(char *data, qint64 maxSize) override
{
qint64 length = qMin(maxSize, buffer.size() - readPos);
if (length == 0)
return finishedReading ? -1 : 0;
QVERIFY(length + readPos <= buffer.size());
memcpy(data, buffer.constData() + readPos, length);
readPos += length;
if (readPos == buffer.size()) {
readPos = 0;
buffer.clear();
}
return length;
}
qint64 writeData(const char *, qint64) override { return -1; }
void onTimeout()
{
if (times > 0) {
buffer.append(message);
emit readyRead();
}
if (--times <= 0) {
timer->stop();
finishedReading = true;
emit readChannelFinished();
}
}
private:
QTimer *timer;
const QByteArray message;
QByteArray buffer;
qsizetype readPos = 0;
int times;
bool finishedReading = false;
};
class tst_QHttpServerMultithreaded final : public QObject
{
Q_OBJECT
private:
QString toUpper(const QString &input) const;
QString toLower(const QString &input) const;
QString toString(qsizetype input) const;
void clearCallCount();
qsizetype getCallCount() const;
private slots:
void initTestCase_data();
void initTestCase();
void init();
void singleCall_data();
void singleCall();
void multipleCallsOnEachConnection();
void moreConnectionsThanServerThreads();
void readSlow();
void postSlow();
void useSemaphores();
void waitingInParallel();
void waitPipelined();
void waitPipelinedQnam();
void manyWaitingToRespond();
void oneSlowManyFast();
void multipartBack();
void sequentialDevice();
private:
static constexpr qsizetype NumberOfThreads = 6;
QSemaphore readySem, routeSem;
QThreadPool threadPool;
QHttpServer httpserver;
mutable qsizetype callCounter = 0;
mutable QMutex mutex;
};
void tst_QHttpServerMultithreaded::clearCallCount()
{
QMutexLocker locker(&mutex);
callCounter = 0;
}
qsizetype tst_QHttpServerMultithreaded::getCallCount() const
{
QMutexLocker locker(&mutex);
return callCounter;
}
QString tst_QHttpServerMultithreaded::toUpper(const QString &input) const
{
QMutexLocker locker(&mutex);
++callCounter;
return input.toUpper();
}
QString tst_QHttpServerMultithreaded::toLower(const QString &input) const
{
QMutexLocker locker(&mutex);
++callCounter;
return input.toLower();
}
QString tst_QHttpServerMultithreaded::toString(qsizetype input) const
{
QMutexLocker locker(&mutex);
++callCounter;
return QString::number(input);
}
void tst_QHttpServerMultithreaded::initTestCase_data()
{
QTest::addColumn<ServerType>("serverType");
QTest::addRow("HTTP/1.0") << ServerType::HTTP1_0;
QTest::addRow("HTTP/1.1") << ServerType::HTTP1_1;
#if QT_CONFIG(ssl)
if (QSslSocket::supportsSsl() && !QTestPrivate::isSecureTransportBlockingTest())
QTest::addRow("SSL") << ServerType::SSL;
else if (QSslSocket::supportsSsl())
qInfo("Not testing TLS, keychain access will block the test");
#endif
#if QT_CONFIG(localserver)
QTest::addRow("LOCAL") << ServerType::LOCAL;
#endif
}
void tst_QHttpServerMultithreaded::initTestCase()
{
threadPool.setMaxThreadCount(NumberOfThreads);
httpserver.route("/convert-uppercase/<arg>", [&](const QString &input) {
return QtConcurrent::run(&threadPool, [this, input] () {
return QHttpServerResponse(toUpper(input));
});
});
httpserver.route("/convert-lowercase/<arg>", [&](const QString &input) {
return QtConcurrent::run(&threadPool, [this, input] () {
return QHttpServerResponse(toLower(input));
});
});
httpserver.route("/wait/<arg>", [&](qsizetype wait) {
return QtConcurrent::run(&threadPool, [this, wait] () {
QThread::msleep(wait);
return QHttpServerResponse(toString(wait));
});
});
httpserver.route("/semroute/<arg>", [this](int i){
return QtConcurrent::run(&threadPool, [this, i] () {
readySem.release();
routeSem.acquire();
return QHttpServerResponse(QString::number(i));
});
});
httpserver.route("/headers/", QHttpServerRequest::Method::Post,
[this](const QHttpServerRequest &request) {
auto headers = request.headers().toListOfPairs();
return QtConcurrent::run(&threadPool, [headers]() {
QString result;
for (auto header : headers)
result += QString::fromUtf8(header.first) + "\n";
return QHttpServerResponse(result);
});
});
httpserver.route("/multipart/<arg>/<arg>",
[this](QString message, int times, QHttpServerResponder &responder) {
++callCounter;
if (times > 0) {
QByteArray ba = message.toUtf8();
responder.writeBeginChunked("text/plain"_ba);
for (int i = 1; i < times; ++i)
responder.writeChunk(ba);
responder.writeEndChunked(ba);
} else {
responder.write();
}
});
httpserver.route(
"/sequential/<arg>/<arg>",
[this](QString message, int times, QHttpServerResponder &&responder) {
auto r = std::make_shared<QHttpServerResponder>(std::move(responder));
return QtConcurrent::run(
&threadPool,
[this, message = std::move(message), times, r = std::move(r)]() {
++callCounter;
auto device = new SequentialIODevice(message.toUtf8(), times, 50ms);
r->write(device, QHttpHeaders());
});
});
auto tcpserver = std::make_unique<QTcpServer>();
QVERIFY2(tcpserver->listen(), "HTTP server listen failed");
port = tcpserver->serverPort();
QVERIFY2(httpserver.bind(tcpserver.get()), "HTTP server bind failed");
tcpserver.release();
#if QT_CONFIG(localserver)
auto localserver = std::make_unique<QLocalServer>();
#ifdef Q_OS_LINUX
localserver->setSocketOptions(QLocalServer::AbstractNamespaceOption);
#endif
localserver->removeServer(local);
QVERIFY2(localserver->listen(local), "Local server listen failed");
QVERIFY2(httpserver.bind(localserver.get()), "Local server bind failed");
localserver.release();
#endif
#if QT_CONFIG(ssl)
if (QSslSocket::supportsSsl()) {
auto sslserver = std::make_unique<QSslServer>();
QSslConfiguration serverConfig = QSslConfiguration::defaultConfiguration();
serverConfig.setLocalCertificate(QSslCertificate(g_certificate));
serverConfig.setPrivateKey(QSslKey(g_privateKey, QSsl::Rsa));
sslserver->setSslConfiguration(serverConfig);
QVERIFY2(sslserver->listen(), "HTTPS server listen failed");
sslPort = sslserver->serverPort();
QVERIFY2(httpserver.bind(sslserver.get()), "HTTPS server bind failed");
sslserver.release();
}
#endif
}
void tst_QHttpServerMultithreaded::init()
{
clearCallCount();
}
void tst_QHttpServerMultithreaded::singleCall_data()
{
QTest::addColumn<QString>("url");
QTest::addColumn<QString>("result");
QTest::addRow("Downcase title case")
<< "/convert-lowercase/Hey"
<< "hey";
QTest::addRow("Upcase title case")
<< "/convert-uppercase/Hey"
<< "HEY";
QTest::addRow("Downcase lower case")
<< "/convert-lowercase/hey"
<< "hey";
QTest::addRow("Upcase lower case")
<< "/convert-uppercase/hey"
<< "HEY";
QTest::addRow("Downcase upper case")
<< "/convert-lowercase/HEY"
<< "hey";
QTest::addRow("Upcase upper case")
<< "/convert-uppercase/HEY"
<< "HEY";
}
void tst_QHttpServerMultithreaded::singleCall()
{
QFETCH_GLOBAL(ServerType, serverType);
QFETCH(QString, url);
QFETCH(QString, result);
QFuture<QString> future = QtConcurrent::run([&]() {
LocalHttpClient client(serverType);
return client.get(url);
});
// Wait for incoming requests to be handled in main thread before they are
// processed in separate threads
QTRY_VERIFY(future.isFinished());
QString returned = future.result();
QCOMPARE(returned, result);
QCOMPARE(getCallCount(), 1);
}
void tst_QHttpServerMultithreaded::multipleCallsOnEachConnection()
{
QFETCH_GLOBAL(ServerType, serverType);
QList<QString> inputs(100);
for (qsizetype i = 0; i < inputs.size(); ++i)
inputs[i] = u"Hey%1"_s.arg(i);
QThreadPool clientThreadPool;
clientThreadPool.setMaxThreadCount(2);
QFuture<QList<QString>> futureLower = QtConcurrent::run(&clientThreadPool, [&]() {
LocalHttpClient client(serverType);
QHttpHeaders headers;
headers.append(QHttpHeaders::WellKnownHeader::Connection, "keep-alive");
QList<QString> results;
for (auto &input : inputs)
results.push_back(client.get(u"/convert-lowercase/%1"_s.arg(input), headers));
return results;
});
QFuture<QList<QString>> futureUpper = QtConcurrent::run(&clientThreadPool, [&]() {
LocalHttpClient client(serverType);
QHttpHeaders headers;
headers.append(QHttpHeaders::WellKnownHeader::Connection, "keep-alive");
QList<QString> results;
for (auto &input : inputs)
results.push_back(client.get(u"/convert-uppercase/%1"_s.arg(input), headers));
return results;
});
QTRY_VERIFY_WITH_TIMEOUT(futureLower.isFinished() && futureUpper.isFinished(), 10s);
QList<QString> convertedToLower = futureLower.result();
QList<QString> convertedToUpper = futureUpper.result();
QCOMPARE(convertedToLower.size(), inputs.size());
QCOMPARE(convertedToUpper.size(), inputs.size());
QCOMPARE(getCallCount(), inputs.size() * 2);
for (qsizetype i = 0; i < inputs.size(); ++i) {
QCOMPARE(convertedToLower[i], inputs[i].toLower());
QCOMPARE(convertedToUpper[i], inputs[i].toUpper());
}
}
void tst_QHttpServerMultithreaded::moreConnectionsThanServerThreads()
{
QFETCH_GLOBAL(ServerType, serverType);
QList<QString> inputs(25);
for (qsizetype i = 0; i < inputs.size(); ++i)
inputs[i] = u"Hey%1"_s.arg(i);
constexpr qsizetype NumberOfTasks = NumberOfThreads * 2;
QThreadPool clientThreadPool;
clientThreadPool.setMaxThreadCount(NumberOfTasks);
QList<QFuture<QList<std::pair<QString, QString>>>> futures(NumberOfTasks);
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
futures[i] = QtConcurrent::run(&clientThreadPool, [&]() {
LocalHttpClient client(serverType);
QList<std::pair<QString, QString>> results;
QHttpHeaders headers;
headers.append(QHttpHeaders::WellKnownHeader::Connection, "keep-alive");
for (auto &input : inputs) {
QString lower = client.get(u"/convert-lowercase/%1"_s.arg(input), headers);
QString upper = client.get(u"/convert-uppercase/%1"_s.arg(input), headers);
results.push_back(std::make_pair(lower, upper));
}
return results;
});
};
QTRY_VERIFY_WITH_TIMEOUT(std::all_of(futures.begin(), futures.end(),
[](auto &future) { return future.isFinished(); }),
10s);
QCOMPARE(getCallCount(), inputs.size() * NumberOfTasks * 2);
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
QList<std::pair<QString, QString>> converted = futures[i].result();
for (qsizetype j = 0; j < inputs.size(); ++j) {
QCOMPARE(converted[j].first, inputs[j].toLower());
QCOMPARE(converted[j].second, inputs[j].toUpper());
}
}
}
void tst_QHttpServerMultithreaded::readSlow()
{
QFETCH_GLOBAL(ServerType, serverType);
QString input(u"ReadThisSlowly"_s);
constexpr qsizetype NumberOfTasks = NumberOfThreads;
QList<QFuture<QString>> futures(NumberOfTasks);
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
futures[i] = QtConcurrent::run([&](QPromise<QString> &promise) {
LocalHttpClient client(serverType);
QHttpHeaders headers;
headers.append(QHttpHeaders::WellKnownHeader::Connection, "keep-alive");
promise.addResult(
client.getSlowRead(u"/convert-lowercase/%1"_s.arg(input), 10, 3000, headers));
promise.addResult(
client.getSlowRead(u"/convert-uppercase/%1"_s.arg(input), 10, 1000, headers));
});
}
QTRY_VERIFY_WITH_TIMEOUT(std::all_of(futures.begin(), futures.end(),
[](auto &future) { return future.isFinished(); }),
20s);
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
QList<QString> returned = futures[i].results();
QCOMPARE(returned.size(), 2);
QCOMPARE(returned[0], input.toLower());
QCOMPARE(returned[1], input.toUpper());
}
QCOMPARE(getCallCount(), 2 * NumberOfTasks);
}
void tst_QHttpServerMultithreaded::postSlow()
{
QFETCH_GLOBAL(ServerType, serverType);
constexpr qsizetype NumberOfTasks = NumberOfThreads;
QHttpHeaders headers;
QString headerName1 = "custom-header1";
QString headerValue1 = "1";
QString headerName2 = "custom-header2";
QString headerValue2 = "2";
headers.append(headerName1, headerValue1);
headers.append(headerName2, headerValue2);
QList<QFuture<QString>> futures(NumberOfTasks);
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
futures[i] = QtConcurrent::run([&](QPromise<QString> &promise) {
LocalHttpClient client(serverType);
promise.addResult(client.postSlow(u"/headers/"_s, headers, 3000));
});
}
QTRY_VERIFY_WITH_TIMEOUT(std::all_of(futures.begin(), futures.end(),
[](auto &future) { return future.isFinished(); }),
30s);
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
QList<QString> returned = futures[i].results();
QCOMPARE(returned.size(), 1);
auto headerNames = returned[0].split('\n', Qt::SkipEmptyParts);
QCOMPARE(headerNames.size(), 2);
QCOMPARE(headerNames[0], headerName1);
QCOMPARE(headerNames[1], headerName2);
}
}
void tst_QHttpServerMultithreaded::useSemaphores()
{
if (NumberOfThreads < 1)
QSKIP("This test is only run with at least one server thread");
QFETCH_GLOBAL(ServerType, serverType);
QCOMPARE(readySem.available(), 0);
QCOMPARE(routeSem.available(), 0);
constexpr qsizetype NumberProcessed = NumberOfThreads;
QThreadPool clientThreadPool;
clientThreadPool.setMaxThreadCount(NumberProcessed);
QList<QFuture<QString>> futures(NumberProcessed);
std::atomic<qsizetype> startedThreads = 0;
for (qsizetype i = 0; i < NumberProcessed; ++i) {
futures[i] = QtConcurrent::run(&clientThreadPool, [&, i]() {
LocalHttpClient client(serverType);
++startedThreads;
return client.get(u"/semroute/%1"_s.arg(i));
});
}
QTest::qWait(2000);
QTRY_COMPARE(startedThreads, NumberOfThreads);
readySem.acquire(NumberProcessed);
routeSem.release(NumberProcessed);
QTRY_VERIFY(std::all_of(futures.begin(), futures.end(),
[](auto &future) { return future.isFinished(); }));
for (qsizetype i = 0; i < NumberProcessed; ++i)
QCOMPARE(futures[i].result(), QString::number(i));
QCOMPARE(readySem.available(), 0);
QCOMPARE(routeSem.available(), 0);
}
void tst_QHttpServerMultithreaded::waitingInParallel()
{
QFETCH_GLOBAL(ServerType, serverType);
QThreadPool clientThreadPool;
clientThreadPool.setMaxThreadCount(2);
QFuture<QString> future1 = QtConcurrent::run(&clientThreadPool, [&]() {
LocalHttpClient client(serverType);
QHttpHeaders headers;
headers.append(QHttpHeaders::WellKnownHeader::Connection, "keep-alive");
QString result = client.get(u"/wait/2001"_s, headers);
result += client.get(u"/wait/9"_s, headers);
return result;
});
QFuture<QString> future2 = QtConcurrent::run(&clientThreadPool, [&]() {
LocalHttpClient client(serverType);
QHttpHeaders headers;
headers.append(QHttpHeaders::WellKnownHeader::Connection, "keep-alive");
QString result = client.get(u"/wait/2000"_s, headers);
result += client.get(u"/wait/10"_s, headers);
return result;
});
QTRY_VERIFY(future1.isFinished() && future2.isFinished());
QCOMPARE(getCallCount(), 4);
}
void tst_QHttpServerMultithreaded::waitPipelined()
{
QFETCH_GLOBAL(ServerType, serverType);
if (serverType == HTTP1_0)
QSKIP("Pipelining is not supported for HTTP/1.0");
QList<qsizetype> waitTimes = { 3000, 1000, 1 };
constexpr qsizetype NumberOfTasks = NumberOfThreads;
QList<QFuture<QString>> futures(NumberOfTasks);
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
futures[i] = QtConcurrent::run([&](QPromise<QString> &promise) {
LocalHttpClient client(serverType);
for (auto times : waitTimes) {
client.pipelinedSendGet(u"/wait/%1"_s.arg(times));
}
for (qsizetype j = 0; j < waitTimes.size(); ++j)
promise.addResult(client.piplinedFetchResults());
});
}
QTRY_VERIFY_WITH_TIMEOUT(std::all_of(futures.begin(), futures.end(),
[](auto &future) { return future.isFinished(); }),
20s);
QCOMPARE(getCallCount(), waitTimes.size() * NumberOfTasks);
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
QList<QString> returned = futures[i].results();
QCOMPARE(returned.size(), waitTimes.size());
for (qsizetype j = 0; j < waitTimes.size() ; ++j)
QCOMPARE(returned[j], QString::number(waitTimes[j]));
}
}
void tst_QHttpServerMultithreaded::waitPipelinedQnam()
{
QFETCH_GLOBAL(ServerType, serverType);
if (serverType != HTTP1_1)
QSKIP("This test only supports HTTP/1.1 over TCP");
QList<qsizetype> waitTimes = { 3000, 1000, 1 };
constexpr qsizetype NumberOfTasks = NumberOfThreads;
QNetworkAccessManager manager;
QList<QList<QNetworkReply *>> repliesForTasks;
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
repliesForTasks.push_back(QList<QNetworkReply *>());
for (auto times : waitTimes) {
QUrl url;
url.setScheme(QStringLiteral("http"));
url.setHost("localhost");
url.setPort(port);
url.setPath(u"/wait/%1"_s.arg(times));
QNetworkRequest request(url);
request.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, QVariant(true));
auto *reply = manager.get(request);
if (reply)
repliesForTasks[i].push_back(reply);
}
}
auto allRepliesFinished = [](QList<QNetworkReply *> &replies) {
return std::all_of(replies.begin(), replies.end(),
[](QNetworkReply *reply) { return reply->isFinished(); });
};
QTRY_VERIFY_WITH_TIMEOUT(std::all_of(repliesForTasks.begin(), repliesForTasks.end(),
[&](auto &task) { return allRepliesFinished(task); }),
10s);
QCOMPARE(getCallCount(), waitTimes.size() * NumberOfTasks);
QCOMPARE(repliesForTasks.size(), NumberOfTasks);
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
QList<QNetworkReply *> &replies = repliesForTasks[i];
QCOMPARE(replies.size(), waitTimes.size());
for (qsizetype j = 0; j < waitTimes.size(); ++j) {
QNetworkReply *reply = replies[j];
QCOMPARE(QString::fromUtf8(reply->readAll()), QString::number(waitTimes[j]));
reply->close();
reply->deleteLater();
}
}
}
void tst_QHttpServerMultithreaded::manyWaitingToRespond()
{
constexpr qsizetype NumberOfTasks = NumberOfThreads * 3;
if (NumberOfThreads < 1)
QSKIP("This test is only run with at least one server thread");
QFETCH_GLOBAL(ServerType, serverType);
QList<QFuture<QString>> futures(NumberOfTasks);
for (qsizetype i = 0; i < NumberOfTasks; ++i) {
futures[i] = QtConcurrent::run([&]() {
LocalHttpClient client(serverType);
return client.get(u"/wait/50"_s);
});
}
QTRY_VERIFY(std::all_of(futures.begin(), futures.end(),
[](auto &future) { return future.isFinished(); }));
QCOMPARE(getCallCount(), NumberOfTasks);
}
void tst_QHttpServerMultithreaded::oneSlowManyFast()
{
constexpr qsizetype NumberOfFastTasks = NumberOfThreads - 1;
if (NumberOfThreads <= 1)
QSKIP("This test is only run with more than one server thread");
QFETCH_GLOBAL(ServerType, serverType);
QThreadPool clientThreadPool;
clientThreadPool.setMaxThreadCount(NumberOfFastTasks + 1);
QFuture<QString> slowFuture = QtConcurrent::run(&clientThreadPool, [&]() {
LocalHttpClient client(serverType);
return client.get(u"/wait/2000"_s);
});
QList<QFuture<QString>> fastFutures(NumberOfFastTasks);
for (qsizetype i = 0; i < NumberOfFastTasks; ++i) {
fastFutures[i] = QtConcurrent::run(&clientThreadPool, [&]() {
LocalHttpClient client(serverType);
return client.get(u"/wait/200"_s);
});
}
QTRY_VERIFY(slowFuture.isFinished());
QVERIFY(std::all_of(fastFutures.begin(), fastFutures.end(),
[](auto &future) { return future.isFinished(); }));
QCOMPARE(getCallCount(), NumberOfFastTasks + 1);
}
void tst_QHttpServerMultithreaded::multipartBack()
{
QFETCH_GLOBAL(ServerType, serverType);
QFuture<QString> future = QtConcurrent::run([&]() {
LocalHttpClient client(serverType);
return client.get("/multipart/Hey/3");
});
QTRY_VERIFY(future.isFinished());
QString returned = future.result();
QCOMPARE(returned, u"HeyHeyHey"_s);
QCOMPARE(getCallCount(), 1);
}
void tst_QHttpServerMultithreaded::sequentialDevice()
{
QFETCH_GLOBAL(ServerType, serverType);
QFuture<QString> future = QtConcurrent::run([&]() {
LocalHttpClient client(serverType);
return client.get("/sequential/Hey/3");
});
QTRY_VERIFY(future.isFinished());
QString returned = future.result();
QCOMPARE(returned, u"HeyHeyHey"_s);
QCOMPARE(getCallCount(), 1);
}
QT_END_NAMESPACE
QTEST_MAIN(tst_QHttpServerMultithreaded)
#include "tst_qhttpservermultithreaded.moc"