Initial commit

Lts/Common/LtsWebSocket/lts_web_socket_client.cpp

@@ -0,0 +1,208 @@
+/**
+  * @RDE_HEADER@
+  * The LtsWebSocketClient handles a websocket connection to a server
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Philipp Dassow, NLST, 2018-03-19
+  */
+#include "lts_web_socket_client.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();
+
+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;
+  NGL::INGLLogger &m_logger;
+};
+
+WebSocketHelper::WebSocketHelper(AbstractClientMessageFactory *messageFactory,
+                                 LtsWebSocketClient *webSocketClient,
+                                 NGL::INGLLogger &logger)
+  : QObject() // no parent, is moved to another thread
+  , 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);
+}
+
+WebSocketHelper::~WebSocketHelper()
+{
+  m_socket->close();
+  delete m_socket;
+}
+
+void WebSocketHelper::doOpen(const QString &hostname, const unsigned short 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
+    {
+      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);
+}
+
+void WebSocketHelper::doClose()
+{
+  INFO_LOG(m_logger) << "Closing web socket to url:" << m_socket->requestUrl().toDisplayString();
+  m_socket->close();
+}
+
+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);
+}
+
+void WebSocketHelper::onConnected()
+{
+  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();
+}
+
+void WebSocketHelper::onError(QAbstractSocket::SocketError error)
+{
+  ERROR_LOG(m_logger) << "Error occured: " << error << " closing socket.";
+  m_socket->close();
+}
+
+void WebSocketHelper::parseMessage(const QString &message)
+{
+  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);
+}
+
+//
+// LtsWebSocketClient
+//
+LtsWebSocketClient::LtsWebSocketClient(AbstractClientMessageFactory *messageFactory, QObject *parent)
+  : QObject(parent)
+  , m_messageFactory(messageFactory)
+  , m_webSocketHelperThread(new QThread(this))
+  , m_logger(getLogger("LtsWebSocketClient"))
+{
+  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(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;
+}
+
+void LtsWebSocketClient::open(const QString &hostname, const unsigned short port)
+{
+  emit onOpen(hostname, port);
+}
+
+void LtsWebSocketClient::close()
+{
+  emit onClose();
+}
+
+void LtsWebSocketClient::addReply(ReplyMessage *message)
+{
+  const QString msg(message->toJsonString());
+  emit onSendTextMessage(msg);
+  delete message;
+}
+
+void LtsWebSocketClient::onNewClientMessage(AbstractClientMessage *clientMessage)
+{
+  if (!clientMessage)
+    return;
+  clientMessage->process();
+  delete clientMessage;
+}
+
+}
+
+#include "lts_web_socket_client.moc"