Apply clang-format to Lts/Common and DTC/enum headers

- Formatted all CodeGen module files (9 files)
- Formatted LtsAppDescriptor module files
- Formatted LtsAppManager/AppChooser files
- Applied clang-format to all DTC and enum headers across modules
- Removed coordTransTests from CommonUnitTestsPlaceholder (moved to tests/)

Cosmetic changes only, no functional modifications.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
torstenandCopilot committed 2026-08-19 14:46:29 +02:00
1 parent 1881d68aef
commit d6b6ffce7c
848 files changed
+89305 -100020

No files matched your search

+12 -16
View File
@@ -9,30 +9,26 @@
namespace LtsWebSocket
{
InvalidMessage::InvalidMessage(ReplyHandler *client, const QString &uuid, const QString &errorText)
: AbstractClientMessage(client, QString(), 1, uuid)
, m_errorText(errorText)
{}
InvalidMessage::InvalidMessage(ReplyHandler* client, const QString& uuid, const QString& errorText)
: AbstractClientMessage(client, QString(), 1, uuid), m_errorText(errorText)
{
}
void InvalidMessage::process()
{
ErrorMessage::ErrorData errorData;
ErrorMessage::ErrorData errorData;
errorData.errorClass = 1;
errorData.errorMessage = m_errorText;
errorData.uuid = m_uuid;
errorData.errorClass = 1;
errorData.errorMessage = m_errorText;
errorData.uuid = m_uuid;
m_client->addReply(new ErrorMessage(errorData));
m_client->addReply(new ErrorMessage(errorData));
}
bool InvalidMessage::hasValidData() const
{
return true;
return true;
}
}
} // namespace LtsWebSocket
+29 -45
View File
@@ -5,66 +5,50 @@
#include "ltswebsocketcommon_export.h"
#include "reply_message.h"
#include <QString>
#include <QJsonValue>
#include <QString>
namespace LtsWebSocket
{
class LTSWEBSOCKETCOMMON_EXPORT AbstractClientMessage
{
public:
AbstractClientMessage(ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data = QJsonValue())
: m_type(type)
, m_typeId(typeId)
, m_uuid(uuid)
, m_data(data)
, m_client(client)
{}
public:
AbstractClientMessage(ReplyHandler* client, const QString& type, const int typeId, const QString& uuid,
const QJsonValue& data = QJsonValue())
: m_type(type), m_typeId(typeId), m_uuid(uuid), m_data(data), m_client(client)
{
}
virtual ~AbstractClientMessage() = default;
virtual void process() = 0;
virtual bool hasValidData() const = 0;
void reply(ReplyMessage *reply)
{
m_client->addReply(reply);
}
protected:
const QString m_type;
const int m_typeId;
const QString m_uuid;
const QJsonValue m_data;
ReplyHandler *m_client;
};
virtual ~AbstractClientMessage() = default;
virtual void process() = 0;
virtual bool hasValidData() const = 0;
void reply(ReplyMessage* reply)
{
m_client->addReply(reply);
}
protected:
const QString m_type;
const int m_typeId;
const QString m_uuid;
const QJsonValue m_data;
ReplyHandler* m_client;
};
class LTSWEBSOCKETCOMMON_EXPORT InvalidMessage final : public AbstractClientMessage
{
public:
explicit InvalidMessage(ReplyHandler *client, const QString &uuid, const QString &errorText);
public:
explicit InvalidMessage(ReplyHandler* client, const QString& uuid, const QString& errorText);
void process() override;
bool hasValidData() const override;
void process() override;
bool hasValidData() const override;
private:
QString m_errorText;
private:
QString m_errorText;
};
};
}
} // namespace LtsWebSocket
+38 -44
View File
@@ -1,6 +1,5 @@
#include "client_message_factory.h"
#include "client_connection.h"
@@ -11,59 +10,54 @@
namespace LtsWebSocket
{
QJsonParseError AbstractClientMessageFactory::parseMessage(const QString &message)
QJsonParseError AbstractClientMessageFactory::parseMessage(const QString& message)
{
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(message.toUtf8(), &error);
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(message.toUtf8(), &error);
if (error.error != QJsonParseError::NoError)
return error;
QJsonObject obj = doc.object();
m_data = obj.value(JsonKeys::DATA());
m_type = obj.value(JsonKeys::TYPE()).toString();
m_typeId = obj.value(JsonKeys::TYPEID()).toInt();
m_uuid = obj.value(JsonKeys::UUID_()).toString();
if (error.error != QJsonParseError::NoError)
return error;
QJsonObject obj = doc.object();
m_data = obj.value(JsonKeys::DATA());
m_type = obj.value(JsonKeys::TYPE()).toString();
m_typeId = obj.value(JsonKeys::TYPEID()).toInt();
m_uuid = obj.value(JsonKeys::UUID_()).toString();
return error;
}
AbstractClientMessage *AbstractClientMessageFactory::checkAttributes(ReplyHandler *client,
const QString &message) const
AbstractClientMessage* AbstractClientMessageFactory::checkAttributes(ReplyHandler* client, const QString& message) const
{
if (!m_uuid.isEmpty() && !m_type.isEmpty())
return nullptr;
if (m_uuid.isEmpty())
{
WARNING_LOG(m_logger) << "Got message without uuid: " << message << "'";
return new LtsWebSocket::InvalidMessage(client, QString(), QStringLiteral("Got message without uuid"));
}
WARNING_LOG(m_logger) << "Got message no type: " << message << "'";
return new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Message has no type"));
if (!m_uuid.isEmpty() && !m_type.isEmpty())
return nullptr;
if (m_uuid.isEmpty())
{
WARNING_LOG(m_logger) << "Got message without uuid: " << message << "'";
return new LtsWebSocket::InvalidMessage(client, QString(), QStringLiteral("Got message without uuid"));
}
WARNING_LOG(m_logger) << "Got message no type: " << message << "'";
return new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Message has no type"));
}
AbstractClientMessage *AbstractClientMessageFactory::checkResult(ReplyHandler *client,
const QString &message,
AbstractClientMessage *result) const
AbstractClientMessage* AbstractClientMessageFactory::checkResult(ReplyHandler* client, const QString& message,
AbstractClientMessage* result) const
{
if (result == nullptr)
{
WARNING_LOG(m_logger) << "Could not parse message: " << message;
result = new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Invalid type"));
}
if (result == nullptr)
{
WARNING_LOG(m_logger) << "Could not parse message: " << message;
result = new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Invalid type"));
}
if (!result->hasValidData())
{
WARNING_LOG(m_logger) << "Resulting JSon message has invalid data... " << message;
delete result;
result = new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Has invalid data part"));
}
if (!result->hasValidData())
{
WARNING_LOG(m_logger) << "Resulting JSon message has invalid data... " << message;
delete result;
result = new LtsWebSocket::InvalidMessage(client, m_uuid, QStringLiteral("Has invalid data part"));
}
return result;
return result;
}
}
} // namespace LtsWebSocket
+28 -42
View File
@@ -1,64 +1,50 @@
#pragma once
#include <QObject>
#include <QtNetwork/QHostAddress>
#include <QtWebSockets/qwebsocketprotocol.h>
#include <QtWebSockets/QWebSocketServer>
#include "logger.h"
#include <QObject>
#include <QtNetwork/QHostAddress>
#include <QtWebSockets/QWebSocketServer>
#include <QtWebSockets/qwebsocketprotocol.h>
namespace LtsWebSocket
{
class MessageHandler;
class ClientConnection;
class ReplyMessage;
class ConnectionHandler
: public QObject
class ConnectionHandler : public QObject
{
Q_OBJECT
public:
Q_OBJECT
public:
explicit ConnectionHandler(QObject* parent = nullptr);
~ConnectionHandler();
explicit ConnectionHandler(QObject *parent = nullptr);
~ConnectionHandler();
bool init(const QString& serviceName, unsigned short port);
void sendToAllClients(ReplyMessage* message);
bool init(const QString &serviceName, unsigned short port);
unsigned short webSocketPort()
{
return m_server->serverPort();
}
signals:
void sendToAllClients(ReplyMessage *message);
void newTextMessageFromClient(ClientConnection* client, const QString& message);
void clientDisconnected(ClientConnection* client);
unsigned short webSocketPort() { return m_server->serverPort(); }
void clientConnected(ClientConnection* client);
signals:
private slots:
void onServerError(QWebSocketProtocol::CloseCode closeCode);
void onNewConnection();
void newTextMessageFromClient(ClientConnection *client, const QString &message);
void clientDisconnected(ClientConnection *client);
void clientConnected(ClientConnection *client);
private slots:
void onServerError(QWebSocketProtocol::CloseCode closeCode);
void onNewConnection();
private:
NGL::INGLLogger &m_logger;
QWebSocketServer *m_server;
QSet<ClientConnection *> m_connections;
private:
NGL::INGLLogger& m_logger;
QWebSocketServer* m_server;
QSet<ClientConnection*> m_connections;
};
}
} // namespace LtsWebSocket
+27 -34
View File
@@ -1,47 +1,40 @@
#pragma once
#include <memory>
#include <NGLLogger/INGLLogger.h>
#include "reply_message.h"
#include <NGLLogger/INGLLogger.h>
#include <memory>
namespace LtsWebSocket
{
template<typename T>
class DataManagerBaseDl
template <typename T> class DataManagerBaseDl
{
protected:
explicit DataManagerBaseDl(const std::shared_ptr<T> &dbInterface, NGL::INGLLogger &logger)
: m_logger(logger)
, m_dbInterface(dbInterface)
{}
template<typename DbType, typename MessageType>
ReplyMessage *toBaseDataMessageFromDb(const QString &uuid) const
{
QVector<DbType> dataVec;
if (!m_dbInterface->select(dataVec))
protected:
explicit DataManagerBaseDl(const std::shared_ptr<T>& dbInterface, NGL::INGLLogger& logger)
: m_logger(logger), m_dbInterface(dbInterface)
{
const QString errorMessage = QStringLiteral("Error reading data from database!");
ERROR_LOG(m_logger) << errorMessage;
ErrorMessage::ErrorData errData;
errData.errorMessage = errorMessage;
errData.uuid = uuid;
return new ErrorMessage(errData);
}
return new MessageType (m_dbInterface->template toJson<DbType>(dataVec), uuid);
}
template <typename DbType, typename MessageType> ReplyMessage* toBaseDataMessageFromDb(const QString& uuid) const
{
QVector<DbType> dataVec;
protected:
std::shared_ptr<T> m_dbInterface;
};
}
if (!m_dbInterface->select(dataVec))
{
const QString errorMessage = QStringLiteral("Error reading data from database!");
ERROR_LOG(m_logger) << errorMessage;
ErrorMessage::ErrorData errData;
errData.errorMessage = errorMessage;
errData.uuid = uuid;
return new ErrorMessage(errData);
}
return new MessageType(m_dbInterface->template toJson<DbType>(dataVec), uuid);
}
protected:
std::shared_ptr<T> m_dbInterface;
};
} // namespace LtsWebSocket
+35 -13
View File
@@ -7,20 +7,42 @@
namespace LtsWebSocket
{
namespace JsonKeys
{
inline QString DATA() { return QStringLiteral("data"); }
inline QString UUID_() { return QStringLiteral("uuid"); }
inline QString TYPE() { return QStringLiteral("type"); }
inline QString TYPEID() { return QStringLiteral("typeId"); }
inline QString ERROR_() { return QStringLiteral("error"); }
inline QString DATA()
{
return QStringLiteral("data");
}
inline QString ERROR_MESSAGE() { return QStringLiteral("errorMessage"); }
inline QString ERROR_CLASS() { return QStringLiteral("errorClass"); }
}
}
inline QString UUID_()
{
return QStringLiteral("uuid");
}
inline QString TYPE()
{
return QStringLiteral("type");
}
inline QString TYPEID()
{
return QStringLiteral("typeId");
}
inline QString ERROR_()
{
return QStringLiteral("error");
}
inline QString ERROR_MESSAGE()
{
return QStringLiteral("errorMessage");
}
inline QString ERROR_CLASS()
{
return QStringLiteral("errorClass");
}
} // namespace JsonKeys
} // namespace LtsWebSocket
+17 -19
View File
@@ -1,6 +1,5 @@
#include "logger.h"
#include <NGLLogger/NGLLoggerBootstrap.h>
@@ -8,25 +7,24 @@
namespace LtsWebSocket
{
LOGGER_T getLogger(const char *name)
LOGGER_T getLogger(const char* name)
{
static const char ns[] = "Lts.WebSocket.";
std::string loggerName;
const size_t len = strlen(name);
loggerName.reserve(sizeof(ns) + len);
loggerName.append(ns, sizeof(ns) - 1);
loggerName.append(name, len);
static const char ns[] = "Lts.WebSocket.";
std::string loggerName;
const size_t len = strlen(name);
loggerName.reserve(sizeof(ns) + len);
loggerName.append(ns, sizeof(ns) - 1);
loggerName.append(name, len);
try
{
return NGL::NGLLoggerBootstrap::getNGLRootLogger().
getNGLLogger(loggerName);
}
catch (const std::exception &ex)
{
fprintf(stderr, "Error retrieving logger: %s", ex.what());
abort();
}
try
{
return NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger(loggerName);
}
catch (const std::exception& ex)
{
fprintf(stderr, "Error retrieving logger: %s", ex.what());
abort();
}
}
}
} // namespace LtsWebSocket
+7 -6
View File
@@ -1,18 +1,19 @@
#pragma once
#include "ltswebsocketcommon_export.h"
#include <NGLLogger/INGLLogger.h>
namespace LtsWebSocket
{
typedef NGL::INGLLogger &LOGGER_T;
typedef NGL::INGLLogger& LOGGER_T;
LTSWEBSOCKETCOMMON_EXPORT LOGGER_T getLogger(const char *name);
inline LOGGER_T getLogger(const QString &loggerName)
LTSWEBSOCKETCOMMON_EXPORT LOGGER_T getLogger(const char* name);
inline LOGGER_T getLogger(const QString& loggerName)
{
return getLogger(loggerName.toUtf8().constData());
return getLogger(loggerName.toUtf8().constData());
}
}
} // namespace LtsWebSocket
+116 -124
View File
@@ -2,199 +2,191 @@
#include "lts_web_socket_client.h"
#include "client_connection.h"
#include <QThread>
#include <QUrl>
#include <QWebSocket>
#include "client_connection.h"
namespace LtsWebSocket
{
class WebSocketHelper : public QObject
{
Q_OBJECT
public:
WebSocketHelper(AbstractClientMessageFactory *messageFactory,
LtsWebSocketClient *webSocketClient,
NGL::INGLLogger &logger);
~WebSocketHelper();
Q_OBJECT
public:
WebSocketHelper(AbstractClientMessageFactory* messageFactory, LtsWebSocketClient* webSocketClient,
NGL::INGLLogger& logger);
~WebSocketHelper();
public Q_SLOTS:
void doOpen(const QString &hostname, const unsigned short port);
void doClose();
void doSendTextMessage(const QString &msg);
void onConnected();
void onDisconnected();
void onError(QAbstractSocket::SocketError error);
void parseMessage(const QString &message);
Q_SIGNALS:
void messageParsed(AbstractClientMessage *clientMessage);
void connected();
void disconnected();
void dataReceived();
void error(QAbstractSocket::SocketError);
private:
AbstractClientMessageFactory *m_messageFactory;
LtsWebSocketClient *m_webSocketClient;
QWebSocket *m_socket;
public Q_SLOTS:
void doOpen(const QString& hostname, const unsigned short port);
void doClose();
void doSendTextMessage(const QString& msg);
void onConnected();
void onDisconnected();
void onError(QAbstractSocket::SocketError error);
void parseMessage(const QString& message);
Q_SIGNALS:
void messageParsed(AbstractClientMessage* clientMessage);
void connected();
void disconnected();
void dataReceived();
void error(QAbstractSocket::SocketError);
private:
AbstractClientMessageFactory* m_messageFactory;
LtsWebSocketClient* m_webSocketClient;
QWebSocket* m_socket;
};
WebSocketHelper::WebSocketHelper(AbstractClientMessageFactory *messageFactory,
LtsWebSocketClient *webSocketClient,
NGL::INGLLogger &logger)
: QObject()
, m_messageFactory(messageFactory)
, m_webSocketClient(webSocketClient)
, m_socket(new QWebSocket(QString(), QWebSocketProtocol::VersionLatest, this))
, m_logger(logger)
WebSocketHelper::WebSocketHelper(AbstractClientMessageFactory* messageFactory, LtsWebSocketClient* webSocketClient,
NGL::INGLLogger& logger)
: QObject(), m_messageFactory(messageFactory), m_webSocketClient(webSocketClient),
m_socket(new QWebSocket(QString(), QWebSocketProtocol::VersionLatest, this)), m_logger(logger)
{
connect(m_socket, &QWebSocket::textMessageReceived, this, &WebSocketHelper::parseMessage);
connect(m_socket, &QWebSocket::textFrameReceived, this, &WebSocketHelper::dataReceived);
connect(m_socket, &QWebSocket::connected, this, &WebSocketHelper::onConnected);
connect(m_socket, &QWebSocket::disconnected, this, &WebSocketHelper::onDisconnected);
connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error), this, &WebSocketHelper::error);
connect(m_socket, &QWebSocket::textMessageReceived, this, &WebSocketHelper::parseMessage);
connect(m_socket, &QWebSocket::textFrameReceived, this, &WebSocketHelper::dataReceived);
connect(m_socket, &QWebSocket::connected, this, &WebSocketHelper::onConnected);
connect(m_socket, &QWebSocket::disconnected, this, &WebSocketHelper::onDisconnected);
connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error), this, &WebSocketHelper::error);
}
WebSocketHelper::~WebSocketHelper()
{
m_socket->close();
delete m_socket;
m_socket->close();
delete m_socket;
}
void WebSocketHelper::doOpen(const QString &hostname, const unsigned short port)
void WebSocketHelper::doOpen(const QString& hostname, const unsigned short port)
{
const QUrl url(QStringLiteral("ws://%1:%2/").arg(hostname).arg(port));
const QUrl url(QStringLiteral("ws://%1:%2/").arg(hostname).arg(port));
if (m_socket->state() == QAbstractSocket::SocketState::ConnectedState)
{
if (m_socket->requestUrl() != url)
doClose();
else
if (m_socket->state() == QAbstractSocket::SocketState::ConnectedState)
{
INFO_LOG(m_logger) << "Web socket to url: " << url.toDisplayString() << " is already open.";
return;
if (m_socket->requestUrl() != url)
doClose();
else
{
INFO_LOG(m_logger) << "Web socket to url: " << url.toDisplayString() << " is already open.";
return;
}
}
}
INFO_LOG(m_logger) << "Opening web socket to url: " << url.toDisplayString();
m_socket->open(url);
INFO_LOG(m_logger) << "Opening web socket to url: " << url.toDisplayString();
m_socket->open(url);
}
void WebSocketHelper::doClose()
{
INFO_LOG(m_logger) << "Closing web socket to url:" << m_socket->requestUrl().toDisplayString();
m_socket->close();
INFO_LOG(m_logger) << "Closing web socket to url:" << m_socket->requestUrl().toDisplayString();
m_socket->close();
}
void WebSocketHelper::doSendTextMessage(const QString &msg)
void WebSocketHelper::doSendTextMessage(const QString& msg)
{
if (!m_socket || m_socket->state() != QAbstractSocket::ConnectedState)
{
ERROR_LOG(m_logger) << "Message could not be send, socket is not connected.";
return;
}
DEBUG_LOG(m_logger) << "Sending message: " << msg;
m_socket->sendTextMessage(msg);
if (!m_socket || m_socket->state() != QAbstractSocket::ConnectedState)
{
ERROR_LOG(m_logger) << "Message could not be send, socket is not connected.";
return;
}
DEBUG_LOG(m_logger) << "Sending message: " << msg;
m_socket->sendTextMessage(msg);
}
void WebSocketHelper::onConnected()
{
INFO_LOG(m_logger) << "Connected to server url: " << m_socket->requestUrl().toDisplayString()
<< " using local port: " << m_socket->localPort();
emit connected();
INFO_LOG(m_logger) << "Connected to server url: " << m_socket->requestUrl().toDisplayString()
<< " using local port: " << m_socket->localPort();
emit connected();
}
void WebSocketHelper::onDisconnected()
{
INFO_LOG(m_logger) << "Disconnected from server url: " << m_socket->requestUrl().toDisplayString();
emit disconnected();
INFO_LOG(m_logger) << "Disconnected from server url: " << m_socket->requestUrl().toDisplayString();
emit disconnected();
}
void WebSocketHelper::onError(QAbstractSocket::SocketError error)
{
ERROR_LOG(m_logger) << "Error occured: " << error << " closing socket.";
m_socket->close();
ERROR_LOG(m_logger) << "Error occured: " << error << " closing socket.";
m_socket->close();
}
void WebSocketHelper::parseMessage(const QString &message)
void WebSocketHelper::parseMessage(const QString& message)
{
const QString pingMsg(QStringLiteral("ping"));
if (message.startsWith(pingMsg))
{
doSendTextMessage(PongMessage(message.mid(pingMsg.size())).toJsonString());
return;
}
const QString pingMsg(QStringLiteral("ping"));
if (message.startsWith(pingMsg))
{
doSendTextMessage(PongMessage(message.mid(pingMsg.size())).toJsonString());
return;
}
AbstractClientMessage *clientMessage = nullptr;
auto result = m_messageFactory->parseMessage(message);
if (QJsonParseError::NoError == result.error)
clientMessage = m_messageFactory->createMessage(m_webSocketClient, message);
else
{
WARNING_LOG(m_logger) << "Could not parse incoming message: '" << message
<< "', error: " << result.errorString();
clientMessage = new InvalidMessage(m_webSocketClient, QString(),
QStringLiteral("Got message which is not JSON conform (%1)").arg(result.errorString()));
}
if (clientMessage)
emit messageParsed(clientMessage);
AbstractClientMessage* clientMessage = nullptr;
auto result = m_messageFactory->parseMessage(message);
if (QJsonParseError::NoError == result.error)
clientMessage = m_messageFactory->createMessage(m_webSocketClient, message);
else
{
WARNING_LOG(m_logger) << "Could not parse incoming message: '" << message
<< "', error: " << result.errorString();
clientMessage =
new InvalidMessage(m_webSocketClient, QString(),
QStringLiteral("Got message which is not JSON conform (%1)").arg(result.errorString()));
}
if (clientMessage)
emit messageParsed(clientMessage);
}
LtsWebSocketClient::LtsWebSocketClient(AbstractClientMessageFactory *messageFactory, QObject *parent)
: QObject(parent)
, m_messageFactory(messageFactory)
, m_webSocketHelperThread(new QThread(this))
LtsWebSocketClient::LtsWebSocketClient(AbstractClientMessageFactory* messageFactory, QObject* parent)
: QObject(parent), m_messageFactory(messageFactory), m_webSocketHelperThread(new QThread(this))
{
m_webSocketHelper = new WebSocketHelper(m_messageFactory, this, m_logger);
m_webSocketHelper->moveToThread(m_webSocketHelperThread);
m_webSocketHelperThread->start();
m_webSocketHelper = new WebSocketHelper(m_messageFactory, this, m_logger);
m_webSocketHelper->moveToThread(m_webSocketHelperThread);
m_webSocketHelperThread->start();
connect(m_webSocketHelper, &WebSocketHelper::connected, this, &LtsWebSocketClient::connected);
connect(m_webSocketHelper, &WebSocketHelper::disconnected, this, &LtsWebSocketClient::disconnected);
connect(m_webSocketHelper, &WebSocketHelper::dataReceived, this, &LtsWebSocketClient::dataReceived);
connect(m_webSocketHelper, &WebSocketHelper::messageParsed, this, &LtsWebSocketClient::onNewClientMessage);
connect(m_webSocketHelper, &WebSocketHelper::connected, this, &LtsWebSocketClient::connected);
connect(m_webSocketHelper, &WebSocketHelper::disconnected, this, &LtsWebSocketClient::disconnected);
connect(m_webSocketHelper, &WebSocketHelper::dataReceived, this, &LtsWebSocketClient::dataReceived);
connect(m_webSocketHelper, &WebSocketHelper::messageParsed, this, &LtsWebSocketClient::onNewClientMessage);
connect(this, &LtsWebSocketClient::onOpen, m_webSocketHelper, &WebSocketHelper::doOpen);
connect(this, &LtsWebSocketClient::onClose, m_webSocketHelper, &WebSocketHelper::doClose);
connect(this, &LtsWebSocketClient::onSendTextMessage, m_webSocketHelper, &WebSocketHelper::doSendTextMessage);
connect(this, &LtsWebSocketClient::onOpen, m_webSocketHelper, &WebSocketHelper::doOpen);
connect(this, &LtsWebSocketClient::onClose, m_webSocketHelper, &WebSocketHelper::doClose);
connect(this, &LtsWebSocketClient::onSendTextMessage, m_webSocketHelper, &WebSocketHelper::doSendTextMessage);
}
LtsWebSocketClient::~LtsWebSocketClient()
{
m_webSocketHelper->disconnect(this);
m_webSocketHelperThread->quit();
m_webSocketHelperThread->wait();
delete m_webSocketHelper;
m_webSocketHelper->disconnect(this);
m_webSocketHelperThread->quit();
m_webSocketHelperThread->wait();
delete m_webSocketHelper;
}
void LtsWebSocketClient::open(const QString &hostname, const unsigned short port)
void LtsWebSocketClient::open(const QString& hostname, const unsigned short port)
{
emit onOpen(hostname, port);
emit onOpen(hostname, port);
}
void LtsWebSocketClient::close()
{
emit onClose();
emit onClose();
}
void LtsWebSocketClient::addReply(ReplyMessage *message)
void LtsWebSocketClient::addReply(ReplyMessage* message)
{
const QString msg(message->toJsonString());
emit onSendTextMessage(msg);
delete message;
const QString msg(message->toJsonString());
emit onSendTextMessage(msg);
delete message;
}
void LtsWebSocketClient::onNewClientMessage(AbstractClientMessage *clientMessage)
void LtsWebSocketClient::onNewClientMessage(AbstractClientMessage* clientMessage)
{
if (!clientMessage)
return;
clientMessage->process();
delete clientMessage;
if (!clientMessage)
return;
clientMessage->process();
delete clientMessage;
}
}
} // namespace LtsWebSocket
#include "lts_web_socket_client.moc"
+28 -42
View File
@@ -2,65 +2,51 @@
#pragma once
#include <QObject>
#include <QAbstractSocket>
#include "ltswebsocketclient_export.h"
#include "client_message_factory.h"
#include "logger.h"
#include "ltswebsocketclient_export.h"
#include <QAbstractSocket>
#include <QObject>
class QThread;
namespace LtsWebSocket
{
class WebSocketHelper;
class LTSWEBSOCKETCLIENT_EXPORT LtsWebSocketClient
: public QObject
, public ReplyHandler
class LTSWEBSOCKETCLIENT_EXPORT LtsWebSocketClient : public QObject, public ReplyHandler
{
Q_OBJECT
public:
Q_OBJECT
public:
explicit LtsWebSocketClient(AbstractClientMessageFactory* messageFactory, QObject* parent = nullptr);
~LtsWebSocketClient();
explicit LtsWebSocketClient(AbstractClientMessageFactory *messageFactory, QObject *parent = nullptr);
~LtsWebSocketClient();
void open(const QString& hostname, const unsigned short port);
void close();
void open(const QString &hostname, const unsigned short port);
void addReply(ReplyMessage* message) override;
signals:
void connected();
void disconnected();
void dataReceived();
void close();
private slots:
void onNewClientMessage(AbstractClientMessage* clientMessage);
void addReply(ReplyMessage *message) override;
signals:
void onOpen(const QString& hostname, const unsigned short port);
void onClose();
void onSendTextMessage(const QString& msg);
signals:
void connected();
void disconnected();
void dataReceived();
private:
NGL::INGLLogger& m_logger;
AbstractClientMessageFactory* m_messageFactory;
private slots:
void onNewClientMessage(AbstractClientMessage *clientMessage);
signals:
void onOpen(const QString &hostname, const unsigned short port);
void onClose();
void onSendTextMessage(const QString &msg);
private:
NGL::INGLLogger &m_logger;
AbstractClientMessageFactory *m_messageFactory;
QThread *m_webSocketHelperThread;
WebSocketHelper *m_webSocketHelper;
QThread* m_webSocketHelperThread;
WebSocketHelper* m_webSocketHelper;
};
}
} // namespace LtsWebSocket
+68 -65
View File
@@ -2,117 +2,120 @@
#include "lts_web_socket_server.h"
#include "connection_handler.h"
#include "client_connection.h"
#include "connection_handler.h"
#include <QTimer>
namespace LtsWebSocket
{
LtsWebSocketServer::LtsWebSocketServer(AbstractClientMessageFactory *messageFactory, QObject *parent)
: QObject(parent)
, m_queueTimer(new QTimer(this))
, m_messageFactory(messageFactory)
, m_connectionHandler(nullptr)
LtsWebSocketServer::LtsWebSocketServer(AbstractClientMessageFactory* messageFactory, QObject* parent)
: QObject(parent), m_queueTimer(new QTimer(this)), m_messageFactory(messageFactory), m_connectionHandler(nullptr)
{
connect(m_queueTimer, &QTimer::timeout,
this, &LtsWebSocketServer::onQueueTimerTimeout);
connect(m_queueTimer, &QTimer::timeout, this, &LtsWebSocketServer::onQueueTimerTimeout);
m_queueTimer->setSingleShot(true);
m_queueTimer->setSingleShot(true);
}
LtsWebSocketServer::~LtsWebSocketServer() = default;
bool LtsWebSocketServer::init(const QString &serviceName, const unsigned short port)
bool LtsWebSocketServer::init(const QString& serviceName, const unsigned short port)
{
m_connectionHandler.reset(new ConnectionHandler(this));
m_connectionHandler.reset(new ConnectionHandler(this));
if (!m_connectionHandler->init(serviceName, port))
{
ERROR_LOG(m_logger) << "Could not init m_connectionHandler with servicename: " << serviceName << ((port == 0) ? QStringLiteral(" random port") : QStringLiteral(" port: ") + QString::number(port));
m_connectionHandler.reset();
return false;
}
if (!m_connectionHandler->init(serviceName, port))
{
ERROR_LOG(m_logger) << "Could not init m_connectionHandler with servicename: " << serviceName
<< ((port == 0) ? QStringLiteral(" random port")
: QStringLiteral(" port: ") + QString::number(port));
m_connectionHandler.reset();
return false;
}
connect(m_connectionHandler.get(), &ConnectionHandler::newTextMessageFromClient, this, &LtsWebSocketServer::onNewTextMessage);
connect(m_connectionHandler.get(), &ConnectionHandler::clientDisconnected, this, &LtsWebSocketServer::clientDisconnected);
connect(m_connectionHandler.get(), &ConnectionHandler::clientConnected, this, &LtsWebSocketServer::clientConnected);
connect(m_connectionHandler.get(), &ConnectionHandler::newTextMessageFromClient, this,
&LtsWebSocketServer::onNewTextMessage);
connect(m_connectionHandler.get(), &ConnectionHandler::clientDisconnected, this,
&LtsWebSocketServer::clientDisconnected);
connect(m_connectionHandler.get(), &ConnectionHandler::clientConnected, this, &LtsWebSocketServer::clientConnected);
m_queueTimer->start(m_messageDelay);
m_queueTimer->start(m_messageDelay);
return true;
return true;
}
bool LtsWebSocketServer::init(const QString &serviceName, const QPair<quint16, quint16> &portRange)
bool LtsWebSocketServer::init(const QString& serviceName, const QPair<quint16, quint16>& portRange)
{
if (portRange.first < 1025 || portRange.first > portRange.second)
if (portRange.first < 1025 || portRange.first > portRange.second)
return init(serviceName);
for (quint16 currentPort = portRange.first; currentPort <= portRange.second; ++currentPort)
{
if (init(serviceName, currentPort))
return true;
}
return init(serviceName);
for (quint16 currentPort = portRange.first; currentPort <= portRange.second; ++ currentPort)
{
if (init(serviceName, currentPort))
return true;
}
return init(serviceName);
}
void LtsWebSocketServer::sendToAllClients(ReplyMessage *message)
void LtsWebSocketServer::sendToAllClients(ReplyMessage* message)
{
DEBUG_LOG(m_logger) << "Sending message to all clients: " << message->toJsonString();
m_connectionHandler->sendToAllClients(message);
DEBUG_LOG(m_logger) << "Sending message to all clients: " << message->toJsonString();
m_connectionHandler->sendToAllClients(message);
}
unsigned short LtsWebSocketServer::webSocketPort() const
{
return m_connectionHandler->webSocketPort();
return m_connectionHandler->webSocketPort();
}
void LtsWebSocketServer::setMessageDelay(qint32 delay)
{
m_messageDelay = delay;
m_messageDelay = delay;
}
void LtsWebSocketServer::onNewTextMessage(ReplyHandler *client, const QString &message)
void LtsWebSocketServer::onNewTextMessage(ReplyHandler* client, const QString& message)
{
const QString pingMsg(QStringLiteral("ping"));
if (message.startsWith(pingMsg))
{
client->addReply(new PongMessage(message.mid(pingMsg.size())));
return;
}
DEBUG_LOG(m_logger) << "Got new message: " << message;
const QString pingMsg(QStringLiteral("ping"));
if (message.startsWith(pingMsg))
{
client->addReply(new PongMessage(message.mid(pingMsg.size())));
return;
}
DEBUG_LOG(m_logger) << "Got new message: " << message;
m_messageQueue.append({client, message});
m_messageQueue.append({client, message});
if (!m_queueTimer->isActive())
m_queueTimer->start(m_messageDelay);
if (!m_queueTimer->isActive())
m_queueTimer->start(m_messageDelay);
}
void LtsWebSocketServer::onQueueTimerTimeout()
{
if (m_messageQueue.isEmpty())
return;
if (m_messageQueue.isEmpty())
return;
MessageCredentials credentials = m_messageQueue.takeFirst();
AbstractClientMessage *clientMessage = nullptr;
auto result = m_messageFactory->parseMessage(credentials.message);
MessageCredentials credentials = m_messageQueue.takeFirst();
AbstractClientMessage* clientMessage = nullptr;
auto result = m_messageFactory->parseMessage(credentials.message);
if (QJsonParseError::NoError == result.error)
clientMessage = m_messageFactory->createMessage(credentials.client, credentials.message);
else
{
WARNING_LOG(m_logger) << "Could not parse incoming message: '" << credentials.message << "', error: " << result.errorString();
if (QJsonParseError::NoError == result.error)
clientMessage = m_messageFactory->createMessage(credentials.client, credentials.message);
else
{
WARNING_LOG(m_logger) << "Could not parse incoming message: '" << credentials.message
<< "', error: " << result.errorString();
clientMessage = new InvalidMessage(credentials.client, QString(), QStringLiteral("Got message which is not JSON conform"));
}
clientMessage =
new InvalidMessage(credentials.client, QString(), QStringLiteral("Got message which is not JSON conform"));
}
if (clientMessage)
clientMessage->process();
if (clientMessage)
clientMessage->process();
delete clientMessage;
delete clientMessage;
m_queueTimer->start(m_messageDelay);
m_queueTimer->start(m_messageDelay);
}
}
} // namespace LtsWebSocket
+35 -60
View File
@@ -1,15 +1,14 @@
#pragma once
#include <QObject>
#include <QtCore/QObject>
#include "ltswebsocketserver_export.h"
#include "client_message_factory.h"
#include "logger.h"
#include <memory>
#include "ltswebsocketserver_export.h"
#include <QObject>
#include <QQueue>
#include <QtCore/QObject>
#include <memory>
class QTimer;
@@ -18,72 +17,48 @@ namespace LtsWebSocket
class ConnectionHandler;
class ClientConnection;
class LTSWEBSOCKETSERVER_EXPORT LtsWebSocketServer
: public QObject
class LTSWEBSOCKETSERVER_EXPORT LtsWebSocketServer : public QObject
{
Q_OBJECT
public:
Q_OBJECT
public:
explicit LtsWebSocketServer(AbstractClientMessageFactory* messageFactory, QObject* parent = nullptr);
virtual ~LtsWebSocketServer();
explicit LtsWebSocketServer(AbstractClientMessageFactory *messageFactory, QObject *parent = nullptr);
virtual ~LtsWebSocketServer();
bool init(const QString& serviceName, const unsigned short port = 0);
bool init(const QString& serviceName, const QPair<quint16, quint16>& portRange);
bool init(const QString &serviceName, const unsigned short port = 0);
void sendToAllClients(ReplyMessage* message);
unsigned short webSocketPort() const;
bool init(const QString &serviceName, const QPair<quint16, quint16> &portRange);
void setMessageDelay(qint32 delay);
signals:
void clientDisconnected(ClientConnection* client);
void sendToAllClients(ReplyMessage *message);
void clientConnected(ClientConnection* client);
private slots:
unsigned short webSocketPort() const;
void onNewTextMessage(ReplyHandler* client, const QString& message);
void onQueueTimerTimeout();
void setMessageDelay(qint32 delay);
signals:
private:
struct MessageCredentials
{
ReplyHandler* client{nullptr};
QString message;
void clientDisconnected(ClientConnection *client);
MessageCredentials(ReplyHandler* client, const QString& message) : client(client), message(message) {}
};
void clientConnected(ClientConnection *client);
private slots:
void onNewTextMessage(ReplyHandler *client, const QString &message);
void onQueueTimerTimeout();
private:
struct MessageCredentials
{
ReplyHandler *client {nullptr};
QString message;
MessageCredentials(ReplyHandler *client, const QString &message)
: client(client)
, message(message)
{}
};
QQueue<MessageCredentials> m_messageQueue;
QTimer *m_queueTimer { nullptr };
AbstractClientMessageFactory *m_messageFactory { nullptr };
std::unique_ptr<ConnectionHandler> m_connectionHandler;
qint32 m_messageDelay { 0 };
LOGGER_T m_logger;
QQueue<MessageCredentials> m_messageQueue;
QTimer* m_queueTimer{nullptr};
AbstractClientMessageFactory* m_messageFactory{nullptr};
std::unique_ptr<ConnectionHandler> m_connectionHandler;
qint32 m_messageDelay{0};
LOGGER_T m_logger;
};
}
} // namespace LtsWebSocket
+3 -8
View File
@@ -1,17 +1,12 @@
namespace LtsWebSocketServer
{
class ReplyMessage;
class MessageHandler
{
public:
virtual void addMessage(ReplyMessage *message) = 0;
public:
virtual void addMessage(ReplyMessage* message) = 0;
};
}
} // namespace LtsWebSocketServer
+12 -19
View File
@@ -1,6 +1,5 @@
#include "reply_message.h"
#include "json_keys.h"
@@ -10,32 +9,26 @@
namespace LtsWebSocket
{
QString ReplyMessage::toJsonString() const
{
return QString::fromUtf8(QJsonDocument(m_jsonRepresentation).toJson(QJsonDocument::Compact));
return QString::fromUtf8(QJsonDocument(m_jsonRepresentation).toJson(QJsonDocument::Compact));
}
ReplyMessage::ReplyMessage(const QString &type, const int typeId, const QString &uuid)
ReplyMessage::ReplyMessage(const QString& type, const int typeId, const QString& uuid)
{
m_jsonRepresentation.insert(JsonKeys::TYPE(), type);
m_jsonRepresentation.insert(JsonKeys::TYPEID(), typeId);
m_jsonRepresentation.insert(JsonKeys::TYPE(), type);
m_jsonRepresentation.insert(JsonKeys::TYPEID(), typeId);
if (!uuid.isEmpty())
m_jsonRepresentation.insert(JsonKeys::UUID_(), uuid);
if (!uuid.isEmpty())
m_jsonRepresentation.insert(JsonKeys::UUID_(), uuid);
}
ErrorMessage::ErrorMessage(const ErrorMessage::ErrorData &data)
: ReplyMessage(JsonKeys::ERROR_(), -1, QUuid::createUuid().toString())
ErrorMessage::ErrorMessage(const ErrorMessage::ErrorData& data)
: ReplyMessage(JsonKeys::ERROR_(), -1, QUuid::createUuid().toString())
{
m_jsonRepresentation.insert(JsonKeys::DATA(),
QJsonObject({{JsonKeys::UUID_(), data.uuid},
{JsonKeys::ERROR_CLASS(), data.errorClass},
{JsonKeys::ERROR_MESSAGE(), data.errorMessage}
}));
m_jsonRepresentation.insert(JsonKeys::DATA(), QJsonObject({{JsonKeys::UUID_(), data.uuid},
{JsonKeys::ERROR_CLASS(), data.errorClass},
{JsonKeys::ERROR_MESSAGE(), data.errorMessage}}));
}
}
} // namespace LtsWebSocket
+29 -44
View File
@@ -4,67 +4,52 @@
#include "ltswebsocketcommon_export.h"
#include <QString>
#include <QJsonObject>
#include <QJsonParseError>
#include <QString>
namespace LtsWebSocket
{
class LTSWEBSOCKETCOMMON_EXPORT ReplyMessage
{
public:
public:
virtual ~ReplyMessage() = default;
virtual ~ReplyMessage() = default;
virtual QString toJsonString() const;
virtual QString toJsonString() const;
QJsonObject json() const { return m_jsonRepresentation; }
protected:
ReplyMessage() = default;
ReplyMessage(const QString &type, const int typeId, const QString &uuid);
protected:
QJsonObject m_jsonRepresentation;
};
QJsonObject json() const
{
return m_jsonRepresentation;
}
protected:
ReplyMessage() = default;
ReplyMessage(const QString& type, const int typeId, const QString& uuid);
protected:
QJsonObject m_jsonRepresentation;
};
class LTSWEBSOCKETCOMMON_EXPORT ReplyHandler
{
public:
virtual ~ReplyHandler() = default;
public:
virtual ~ReplyHandler() = default;
virtual void addReply(ReplyMessage *message) = 0;
};
virtual void addReply(ReplyMessage* message) = 0;
};
class LTSWEBSOCKETCOMMON_EXPORT ErrorMessage final
: public ReplyMessage
class LTSWEBSOCKETCOMMON_EXPORT ErrorMessage final : public ReplyMessage
{
public:
public:
struct ErrorData
{
int errorClass = 0;
QString uuid;
QString errorMessage;
};
struct ErrorData
{
int errorClass = 0;
QString uuid;
QString errorMessage;
};
explicit ErrorMessage(const ErrorData& data);
};
explicit ErrorMessage(const ErrorData &data);
};
}
} // namespace LtsWebSocket