C++ - QThread and SocketManager - c++

Question

I subclassed QTcpServer to generate SocketManagers which are workers that should run and create sockets on their own thread. I would like, if possible, to keep the worker and the QThread in a single object instance. The overall goal is to have different threads for different collections of sockets. The purpose is purely academic.
How should I go about implementing the SocketManager class ? Can I make the QThread an attribute of the worker as such ?
class SocketManager : public QObject
{
Q_OBJECT
public:
SocketManager(); // Creates managerThread and moves this to it
~SocketManager(); // Calls close on all TcpSocket instances (subclass of QTcpSocket)
// Calls managerThread->quit() without waiting.
protected:
QSharedPointer<QThread> managerThread;
QHash<quint16, QSharedPointer<TcpSocket>> socketsHash;
public slots:
void onAddSocket(qintptr socketDescriptor);
void onRemoveSocket(qintptr socketDescriptor);
};
If this is an acceptable design how should I go about handling memory management:
Using &QObject::deleteLater the socket manager never gets deleted when resetting the shared pointer held by the TcpServer instance
Usind the delete operator on the SocketManager instance (The thread and sockets use deleteLater) works fine only when there are no sockets in the container socketsHash. The following message is given (which means I'm doing something wrong)
QSocketNotifier: Socket notifiers cannot be enabled or disabled from another thread
...in the following output:
Listening on 0.0.0.0:8080
Closing server
QSocketNotifier: Socket notifiers cannot be enabled or disabled from another thread
Removing socket QSharedPointer(QSslSocket(0xcf6410)) 1 connections left
QSharedPointer(QSslSocket(0xcf6410)) onDisconnected
SocketManager(0xd0f910) Destroyed QThread(0xc74dd0) QThread(0xc801b0)
QSslSocket(0xcf6410) Destroyed 0xc74dd0 0xc801b0
QThread(0xc801b0) destroyed
I also thought about making the SocketManager class a subclass of QThread but I read multiple times that sublassing QThread is a slippery slope. Please correct me if i'm wrong.
EDIT:
tcpserver.h
class TcpServer : public QTcpServer
{
Q_OBJECT
public:
TcpServer();
~TcpServer();
bool listen(const QHostAddress &address = QHostAddress::Any, quint16 port = 0);
void close();
private:
SharedPtr<SocketManager> manager;
protected:
void incomingConnection(qintptr handle) override;
signals:
void addSocket(qintptr handle);
};
tcpserver.cpp
#include <QApplication>
#include <QThread>
TcpServer::TcpServer(): QTcpServer()
, manager(nullptr)
{
}
TcpServer::~TcpServer()
{
close();
qDebug() << this << "Destroyed" << QApplication::instance()->thread() << thread();
}
bool TcpServer::listen(const QHostAddress &address, quint16 port)
{
if (isListening()) {
qDebug() << "Server is already listening";
return false;
}
if (!QTcpServer::listen(address, port)){
qDebug() << QString("Could not listen on %1:%2").arg(address.toString(),QString::number(port));
return false;
}
qDebug() << QString("Listening on %1:%2").arg(address.toString(),QString::number(port));
if (manager) manager.reset();
manager = SharedPtr<SocketManager>(new SocketManager());
connect(this, &TcpServer::addSocket, manager.data(), &SocketManager::onAddSocket, Qt::QueuedConnection);
return true;
}
void TcpServer::close()
{
qDebug() << "Closing server";
QTcpServer::close();
if (manager) manager.reset();
}
void TcpServer::incomingConnection(qintptr handle)
{
emit addSocket(handle);
}
socketmanager.h
class SocketManager : public QObject
{
Q_OBJECT
public:
explicit SocketManager();
~SocketManager();
protected:
SharedPtr<QThread> managerThread;
QHash<quint16, QSharedPointer<TcpSocket>> connections;
public slots:
void onAddSocket(qintptr handle);
void onRemoveSocket(qintptr handle);
};
socketmanager.cpp
#include "socketmanager.h"
#include <QApplication>
SocketManager::SocketManager(): QObject()
, managerThread(SharedPtr<QThread>(new QThread(), &QThread::deleteLater))
{
moveToThread(managerThread.data());
connect(managerThread.data(), &QThread::destroyed, [&](){ qDebug() << "Thread destroyed"; });
managerThread->start();
}
SocketManager::~SocketManager()
{
for (SharedPtr<TcpSocket> socket : connections.values()){
socket->close();
}
if (managerThread) managerThread->quit();
qDebug() << this << "Destroyed" << QApplication::instance()->thread() << thread();
}
void SocketManager::onAddSocket(qintptr handle)
{
if (!handle) return;
SharedPtr<TcpSocket> socket = SharedPtr<TcpSocket>(new TcpSocket(handle), &QObject::deleteLater);
connect(socket.data(), &TcpSocket::disconnected, [=](){onRemoveSocket(handle);});
connections.insert(handle, socket);
}
void SocketManager::onRemoveSocket(qintptr handle)
{
SharedPtr<TcpSocket> socket = connections.value(handle);
if(!socket.data()) return;
qDebug() << "Removing socket" << socket << connections.count() << "connections left";
connections.remove(handle);
socket->close();
}
tcpsocket.h
#include <QSslSocket>
class TcpSocket : public QSslSocket
{
public:
TcpSocket(qintptr handle);
~TcpSocket();
private slots:
void onConnected();
void onEncrypted();
void onDisconnected();
void onErrorOccured(QAbstractSocket::SocketError error);
void onSslErrors(const QList<QSslError> &errors);
void onStateChanged(QAbstractSocket::SocketState);
void onReadyRead();
};
tcpsocket.cpp
#include "tcpsocket.h"
#include <QApplication>
TcpSocket::TcpSocket(qintptr handle): QSslSocket()
{
setSocketDescriptor(handle);
connect(this, &QTcpSocket::connected, this, &TcpSocket::onConnected);
connect(this, &QSslSocket::encrypted, this, &TcpSocket::onEncrypted);
connect(this, &QTcpSocket::disconnected, this, &TcpSocket::onDisconnected);
connect(this, &QTcpSocket::errorOccurred, this, &TcpSocket::onErrorOccured);
connect(this, &QSslSocket::sslErrors, this, &TcpSocket::onSslErrors);
connect(this, &QAbstractSocket::stateChanged, this, &TcpSocket::onStateChanged);
connect(this, &QTcpSocket::readyRead, this, &TcpSocket::onReadyRead);
}
TcpSocket::~TcpSocket()
{
qDebug() << this << "Destroyed" << QApplication::instance()->thread() << thread();
}
void TcpSocket::onConnected()
{
qDebug() << socketDescriptor() << "onConnected";
}
void TcpSocket::onEncrypted()
{
qDebug() << socketDescriptor() << "onEncrypted";
}
void TcpSocket::onDisconnected()
{
qDebug() << socketDescriptor() << "onDisconnected";
}
void TcpSocket::onErrorOccured(QAbstractSocket::SocketError error)
{
qDebug() << socketDescriptor() << "onErrorOccured" << error;
}
void TcpSocket::onSslErrors(const QList<QSslError> &errors)
{
// qDebug() << socketDescriptor() << "onSslErrors" << errors;
}
void TcpSocket::onStateChanged(QAbstractSocket::SocketState state)
{
// qDebug() << socketDescriptor() << "onStateChanged" << state;
}
void TcpSocket::onReadyRead()
{
// qDebug() << socketDescriptor() << "onReadyRead" /*<< readAll()*/;
}