ETM-Schurig
/
nymea-remoteproxy
mirror of https://github.com/nymea/nymea-remoteproxy
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Start implementing client library tunnel classes

remoteproxy-v2
Simon Stürz 2021-07-30 18:35:54 +02:00
parent f0cdb2706b
commit 8f9bdcce13
15 changed files with 447 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libnymea-remoteproxyclient/libnymea-remoteproxyclient.pri
View File

@ -1,24 +1,24 @@
INCLUDEPATH += $$PWD
HEADERS += \
$$PWD/tunnelproxy/tunnelproxyjsonrpcclient.h \
$$PWD/tunnelproxy/tunnelproxyremoteconnection.h \
$$PWD/tunnelproxy/tunnelproxysocket.h \
$$PWD/tunnelproxy/tunnelproxyserver.h \
$$PWD/tcpsocketconnection.h \
$$PWD/proxyjsonrpcclient.h \
$$PWD/jsonreply.h \
$$PWD/remoteproxyconnection.h \
$$PWD/proxyconnection.h \
$$PWD/tunnelproxy/tunnelproxysocketserver.h \
$$PWD/websocketconnection.h
SOURCES += \
$$PWD/tunnelproxy/tunnelproxyjsonrpcclient.cpp \
$$PWD/tunnelproxy/tunnelproxyremoteconnection.cpp \
$$PWD/tunnelproxy/tunnelproxysocket.cpp \
$$PWD/tunnelproxy/tunnelproxyserver.cpp \
$$PWD/tcpsocketconnection.cpp \
$$PWD/proxyjsonrpcclient.cpp \
$$PWD/jsonreply.cpp \
$$PWD/remoteproxyconnection.cpp \
$$PWD/proxyconnection.cpp \
$$PWD/tunnelproxy/tunnelproxysocketserver.cpp \
$$PWD/websocketconnection.cpp

13
libnymea-remoteproxyclient/proxyjsonrpcclient.cpp
View File

@ -66,6 +66,19 @@ JsonReply *JsonRpcClient::callAuthenticate(const QUuid &clientUuid, const QStrin
return reply;
}
JsonReply *JsonRpcClient::callRegisterServer(const QUuid &serverUuid, const QString &serverName)
{
QVariantMap params;
params.insert("serverName", serverName);
params.insert("serverUuid", serverUuid.toString());
JsonReply *reply = new JsonReply(m_commandId, "TunnelProxy", "RegisterServer", params, this);
qCDebug(dcRemoteProxyClientJsonRpc()) << "Calling" << QString("%1.%2").arg(reply->nameSpace()).arg(reply->method());
sendRequest(reply->requestMap());
m_replies.insert(m_commandId, reply);
return reply;
}
void JsonRpcClient::sendRequest(const QVariantMap &request)
{
QByteArray data = QJsonDocument::fromVariant(request).toJson(QJsonDocument::Compact);

6
libnymea-remoteproxyclient/proxyjsonrpcclient.h
View File

@ -47,9 +47,15 @@ class JsonRpcClient : public QObject
public:
explicit JsonRpcClient(ProxyConnection *connection, QObject *parent = nullptr);
// General
JsonReply *callHello();
// Proxy
JsonReply *callAuthenticate(const QUuid &clientUuid, const QString &clientName, const QString &token, const QString &nonce);
// Tunnel proxy
JsonReply *callRegisterServer(const QUuid &serverUuid, const QString &serverName);
private:
ProxyConnection *m_connection = nullptr;

37
libnymea-remoteproxyclient/tunnelproxy/tunnelproxyjsonrpcclient.cpp
View File

@ -1,37 +0,0 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Copyright 2013 - 2021, nymea GmbH
* Contact: contact@nymea.io
*
* This file is part of nymea.
* This project including source code and documentation is protected by copyright law, and
* remains the property of nymea GmbH. All rights, including reproduction, publication,
* editing and translation, are reserved. The use of this project is subject to the terms of a
* license agreement to be concluded with nymea GmbH in accordance with the terms
* of use of nymea GmbH, available under https://nymea.io/license
*
* GNU Lesser General Public License Usage
* Alternatively, this project may be redistributed and/or modified under the terms of the GNU
* Lesser General Public License as published by the Free Software Foundation; version 3.
* this project is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with this project.
* If not, see <https://www.gnu.org/licenses/>.
*
* For any further details and any questions please contact us under contact@nymea.io
* or see our FAQ/Licensing Information on https://nymea.io/license/faq
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "tunnelproxyjsonrpcclient.h"
namespace remoteproxyclient {
TunnelProxyJsonRpcClient::TunnelProxyJsonRpcClient(QObject *parent) : QObject(parent)
{
}
}

48
libnymea-remoteproxyclient/tunnelproxy/tunnelproxyjsonrpcclient.h
View File

@ -1,48 +0,0 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Copyright 2013 - 2021, nymea GmbH
* Contact: contact@nymea.io
*
* This file is part of nymea.
* This project including source code and documentation is protected by copyright law, and
* remains the property of nymea GmbH. All rights, including reproduction, publication,
* editing and translation, are reserved. The use of this project is subject to the terms of a
* license agreement to be concluded with nymea GmbH in accordance with the terms
* of use of nymea GmbH, available under https://nymea.io/license
*
* GNU Lesser General Public License Usage
* Alternatively, this project may be redistributed and/or modified under the terms of the GNU
* Lesser General Public License as published by the Free Software Foundation; version 3.
* this project is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with this project.
* If not, see <https://www.gnu.org/licenses/>.
*
* For any further details and any questions please contact us under contact@nymea.io
* or see our FAQ/Licensing Information on https://nymea.io/license/faq
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef TUNNELPROXYJSONRPCCLIENT_H
#define TUNNELPROXYJSONRPCCLIENT_H
#include <QObject>
namespace remoteproxyclient {
class TunnelProxyJsonRpcClient : public QObject
{
Q_OBJECT
public:
explicit TunnelProxyJsonRpcClient(QObject *parent = nullptr);
signals:
};
}
#endif // TUNNELPROXYJSONRPCCLIENT_H

6
libnymea-remoteproxyclient/tunnelproxy/tunnelproxyremoteconnection.cpp Normal file
View File

@ -0,0 +1,6 @@
#include "tunnelproxyremoteconnection.h"
TunnelProxyRemoteConnection::TunnelProxyRemoteConnection(QObject *parent) : QObject(parent)
{
}

16
libnymea-remoteproxyclient/tunnelproxy/tunnelproxyremoteconnection.h Normal file
View File

@ -0,0 +1,16 @@
#ifndef TUNNELPROXYREMOTECONNECTION_H
#define TUNNELPROXYREMOTECONNECTION_H
#include <QObject>
class TunnelProxyRemoteConnection : public QObject
{
Q_OBJECT
public:
explicit TunnelProxyRemoteConnection(QObject *parent = nullptr);
signals:
};
#endif // TUNNELPROXYREMOTECONNECTION_H

84
libnymea-remoteproxyclient/tunnelproxy/tunnelproxyserver.cpp
View File

@ -1,84 +0,0 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Copyright 2013 - 2021, nymea GmbH
* Contact: contact@nymea.io
*
* This file is part of nymea.
* This project including source code and documentation is protected by copyright law, and
* remains the property of nymea GmbH. All rights, including reproduction, publication,
* editing and translation, are reserved. The use of this project is subject to the terms of a
* license agreement to be concluded with nymea GmbH in accordance with the terms
* of use of nymea GmbH, available under https://nymea.io/license
*
* GNU Lesser General Public License Usage
* Alternatively, this project may be redistributed and/or modified under the terms of the GNU
* Lesser General Public License as published by the Free Software Foundation; version 3.
* this project is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with this project.
* If not, see <https://www.gnu.org/licenses/>.
*
* For any further details and any questions please contact us under contact@nymea.io
* or see our FAQ/Licensing Information on https://nymea.io/license/faq
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "tunnelproxyserver.h"
#include "proxyconnection.h"
#include "tcpsocketconnection.h"
#include "websocketconnection.h"
namespace remoteproxyclient {
TunnelProxyServer::TunnelProxyServer(const QUuid &serverUuid, const QString &serverName, QObject *parent) :
QObject(parent),
m_serverUuid(serverUuid),
m_serverName(serverName)
{
}
TunnelProxyServer::TunnelProxyServer(const QUuid &serverUuid, const QString &serverName, ConnectionType connectionType, QObject *parent) :
QObject(parent),
m_serverUuid(serverUuid),
m_serverName(serverName),
m_connectionType(connectionType)
{
}
TunnelProxyServer::~TunnelProxyServer()
{
}
bool TunnelProxyServer::running() const
{
return m_running;
}
void TunnelProxyServer::ignoreSslErrors()
{
m_connection->ignoreSslErrors();
}
void TunnelProxyServer::ignoreSslErrors(const QList<QSslError> &errors)
{
m_connection->ignoreSslErrors(errors);
}
void remoteproxyclient::TunnelProxyServer::startServer(const QUrl &serverUrl)
{
// Register as server to the remote proxy
m_serverUrl = serverUrl;
}
void remoteproxyclient::TunnelProxyServer::stopServer()
{
// Close the server connection and all related sockets
}
}

277
libnymea-remoteproxyclient/tunnelproxy/tunnelproxysocketserver.cpp Normal file
View File

@ -0,0 +1,277 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Copyright 2013 - 2021, nymea GmbH
* Contact: contact@nymea.io
*
* This file is part of nymea.
* This project including source code and documentation is protected by copyright law, and
* remains the property of nymea GmbH. All rights, including reproduction, publication,
* editing and translation, are reserved. The use of this project is subject to the terms of a
* license agreement to be concluded with nymea GmbH in accordance with the terms
* of use of nymea GmbH, available under https://nymea.io/license
*
* GNU Lesser General Public License Usage
* Alternatively, this project may be redistributed and/or modified under the terms of the GNU
* Lesser General Public License as published by the Free Software Foundation; version 3.
* this project is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with this project.
* If not, see <https://www.gnu.org/licenses/>.
*
* For any further details and any questions please contact us under contact@nymea.io
* or see our FAQ/Licensing Information on https://nymea.io/license/faq
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "tunnelproxysocketserver.h"
#include "proxyconnection.h"
#include "tcpsocketconnection.h"
#include "websocketconnection.h"
#include "proxyjsonrpcclient.h"
Q_LOGGING_CATEGORY(dcTunnelProxySocketServer, "dcTunnelProxySocketServer")
namespace remoteproxyclient {
TunnelProxySocketServer::TunnelProxySocketServer(const QUuid &serverUuid, const QString &serverName, QObject *parent) :
QObject(parent),
m_serverUuid(serverUuid),
m_serverName(serverName)
{
}
TunnelProxySocketServer::TunnelProxySocketServer(const QUuid &serverUuid, const QString &serverName, ConnectionType connectionType, QObject *parent) :
QObject(parent),
m_serverUuid(serverUuid),
m_serverName(serverName),
m_connectionType(connectionType)
{
}
TunnelProxySocketServer::~TunnelProxySocketServer()
{
}
bool TunnelProxySocketServer::running() const
{
return m_running;
}
QAbstractSocket::SocketError TunnelProxySocketServer::error() const
{
return m_error;
}
void TunnelProxySocketServer::ignoreSslErrors()
{
m_connection->ignoreSslErrors();
}
void TunnelProxySocketServer::ignoreSslErrors(const QList<QSslError> &errors)
{
m_connection->ignoreSslErrors(errors);
}
void TunnelProxySocketServer::startServer(const QUrl &serverUrl)
{
m_serverUrl = serverUrl;
m_error = QAbstractSocket::UnknownSocketError;
cleanUp();
switch (m_connectionType) {
case ConnectionTypeWebSocket:
qCDebug(dcTunnelProxySocketServer()) << "Creating a web socket connection to" << m_serverUrl.toString();
m_connection = qobject_cast<ProxyConnection *>(new WebSocketConnection(this));
break;
case ConnectionTypeTcpSocket:
qCDebug(dcTunnelProxySocketServer()) << "Creating a TCP socket connection to" << m_serverUrl.toString();
m_connection = qobject_cast<ProxyConnection *>(new TcpSocketConnection(this));
break;
}
connect(m_connection, &ProxyConnection::connectedChanged, this, &TunnelProxySocketServer::onConnectionChanged);
connect(m_connection, &ProxyConnection::dataReceived, this, &TunnelProxySocketServer::onConnectionDataAvailable);
connect(m_connection, &ProxyConnection::errorOccured, this, &TunnelProxySocketServer::onConnectionSocketError);
connect(m_connection, &ProxyConnection::stateChanged, this, &TunnelProxySocketServer::onConnectionStateChanged);
connect(m_connection, &ProxyConnection::sslErrors, this, &TunnelProxySocketServer::sslErrors);
m_jsonClient = new JsonRpcClient(m_connection, this);
// connect(m_jsonClient, &JsonRpcClient::tunnelEstablished, this, &RemoteProxyConnection::onTunnelEstablished);
qCDebug(dcTunnelProxySocketServer()) << "Connecting to" << m_serverUrl.toString();
m_connection->connectServer(m_serverUrl);
}
void TunnelProxySocketServer::stopServer()
{
// Close the server connection and all related sockets
}
void TunnelProxySocketServer::onConnectionChanged(bool connected)
{
if (connected) {
qCDebug(dcTunnelProxySocketServer()) << "Connected to remote proxy server.";
setState(StateConnected);
setState(StateInitializing);
JsonReply *reply = m_jsonClient->callHello();
connect(reply, &JsonReply::finished, this, &TunnelProxySocketServer::onHelloFinished);
} else {
qCDebug(dcTunnelProxySocketServer()) << "Disconnected from remote proxy server.";
setState(StateDisconnected);
cleanUp();
}
}
void TunnelProxySocketServer::onConnectionDataAvailable(const QByteArray &data)
{
if (m_state != StateRunning) {
m_jsonClient->processData(data);
return;
}
// Parse SLIP
}
void TunnelProxySocketServer::onConnectionSocketError(QAbstractSocket::SocketError error)
{
setError(error);
}
void TunnelProxySocketServer::onConnectionStateChanged(QAbstractSocket::SocketState state)
{
// Process the actuall socket state
switch (state) {
case QAbstractSocket::UnconnectedState:
setState(StateDisconnected);
break;
case QAbstractSocket::HostLookupState:
setState(StateHostLookup);
break;
case QAbstractSocket::ConnectingState:
setState(StateConnecting);
break;
case QAbstractSocket::ConnectedState:
setState(StateConnected);
break;
case QAbstractSocket::ClosingState:
setState(StateDiconnecting);
break;
case QAbstractSocket::BoundState:
case QAbstractSocket::ListeningState:
break;
}
}
void TunnelProxySocketServer::onHelloFinished()
{
JsonReply *reply = static_cast<JsonReply *>(sender());
reply->deleteLater();
QVariantMap response = reply->response();
qCDebug(dcTunnelProxySocketServer()) << "Hello response ready" << reply->commandId() << response;
if (response.value("status").toString() != "success") {
qCWarning(dcTunnelProxySocketServer()) << "Could not get initial information from proxy server.";
m_connection->disconnectServer();
return;
}
QVariantMap responseParams = response.value("params").toMap();
m_remoteProxyServer = responseParams.value("server").toString();
m_remoteProxyServerName = responseParams.value("name").toString();
m_remoteProxyServerVersion = responseParams.value("version").toString();
m_remoteProxyApiVersion = responseParams.value("apiVersion").toString();
setState(StateRegister);
JsonReply *registerReply = m_jsonClient->callRegisterServer(m_serverUuid, m_serverName);
connect(registerReply, &JsonReply::finished, this, &TunnelProxySocketServer::onServerRegistrationFinished);
}
void TunnelProxySocketServer::onServerRegistrationFinished()
{
JsonReply *reply = static_cast<JsonReply *>(sender());
reply->deleteLater();
QVariantMap response = reply->response();
qCDebug(dcTunnelProxySocketServer()) << "RegisterServer response ready" << reply->commandId() << response;
if (response.value("status").toString() != "success") {
qCWarning(dcTunnelProxySocketServer()) << "JSON RPC error. Failed to register as tunnel server on the remote proxy server.";
m_connection->disconnectServer();
return;
}
QVariantMap responseParams = response.value("params").toMap();
if (responseParams.value("tunnelProxyError").toString() != "TunnelProxyErrorNoError") {
qCWarning(dcTunnelProxySocketServer()) << "Failed to register as tunnel server on the remote proxy server:" << responseParams.value("tunnelProxyError").toString();
m_connection->disconnectServer();
return;
}
qCDebug(dcTunnelProxySocketServer()) << "Registered successfully as tunnel server on the remote proxy server.";
setState(StateRunning);
}
void TunnelProxySocketServer::setState(State state)
{
if (m_state == state)
return;
m_state = state;
qCDebug(dcTunnelProxySocketServer()) << "State changed" << m_state;
emit stateChanged(m_state);
setRunning(m_state == StateRunning);
}
void TunnelProxySocketServer::setRunning(bool running)
{
if (m_running == running)
return;
qCDebug(dcTunnelProxySocketServer()) << "The TunnelProxy server" << (running ? "is now up and running. Listening for remote clients" : "not running any more.");
m_running = running;
emit runningChanged(m_running);
}
void TunnelProxySocketServer::setError(QAbstractSocket::SocketError error)
{
if (m_error == error)
return;
m_error = error;
qCDebug(dcTunnelProxySocketServer()) << "Error occured" << m_error;
emit errorOccured(m_error);
}
void TunnelProxySocketServer::cleanUp()
{
// TODO: cleanup client connections
if (m_jsonClient) {
m_jsonClient->deleteLater();
m_jsonClient = nullptr;
}
if (m_connection) {
m_connection->deleteLater();
m_connection = nullptr;
}
// m_serverName = QString();
// m_serverUuid = QUuid();
setState(StateDisconnected);
}
}

60
libnymea-remoteproxyclient/tunnelproxy/tunnelproxyserver.h → libnymea-remoteproxyclient/tunnelproxy/tunnelproxysocketserver.h
View File

@ -25,14 +25,14 @@
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef TUNNELPROXYSERVER_H
#define TUNNELPROXYSERVER_H
#ifndef TUNNELPROXYSOCKETSERVER_H
#define TUNNELPROXYSOCKETSERVER_H
#include <QUuid>
#include <QObject>
#include <QLoggingCategory>
Q_DECLARE_LOGGING_CATEGORY(dcRemoteProxyTunnelProxyServer)
Q_DECLARE_LOGGING_CATEGORY(dcTunnelProxySocketServer)
#include "proxyconnection.h"
#include "tunnelproxysocket.h"
@ -40,21 +40,33 @@ Q_DECLARE_LOGGING_CATEGORY(dcRemoteProxyTunnelProxyServer)
namespace remoteproxyclient {
class ProxyConnection;
class TunnelProxyJsonRpcClient;
class JsonRpcClient;
class TunnelProxyServer : public QObject
class TunnelProxySocketServer : public QObject
{
Q_OBJECT
public:
enum State {
StateConnecting,
StateHostLookup,
StateConnected,
StateInitializing,
StateRegister,
StateRunning,
StateDiconnecting,
StateDisconnected,
};
Q_ENUM(State)
enum ConnectionType {
ConnectionTypeWebSocket,
ConnectionTypeTcpSocket
};
Q_ENUM(ConnectionType)
explicit TunnelProxyServer(const QUuid &serverUuid, const QString &serverName, QObject *parent = nullptr);
explicit TunnelProxyServer(const QUuid &serverUuid, const QString &serverName, ConnectionType connectionType, QObject *parent = nullptr);
~TunnelProxyServer();
explicit TunnelProxySocketServer(const QUuid &serverUuid, const QString &serverName, QObject *parent = nullptr);
explicit TunnelProxySocketServer(const QUuid &serverUuid, const QString &serverName, ConnectionType connectionType, QObject *parent = nullptr);
~TunnelProxySocketServer();
bool running() const;
@ -69,22 +81,50 @@ public slots:
signals:
void runningChanged(bool running);
void stateChanged(TunnelProxySocketServer::State state);
void errorOccured(QAbstractSocket::SocketError error);
void sslErrors(const QList<QSslError> &errors);
private slots:
void onConnectionChanged(bool connected);
void onConnectionDataAvailable(const QByteArray &data);
void onConnectionSocketError(QAbstractSocket::SocketError error);
void onConnectionStateChanged(QAbstractSocket::SocketState state);
// Initialization calls
void onHelloFinished();
void onServerRegistrationFinished();
private:
// This server information
QUuid m_serverUuid;
QString m_serverName;
ConnectionType m_connectionType = ConnectionTypeTcpSocket;
// Remote proxy server information
QString m_remoteProxyServer;
QString m_remoteProxyServerName;
QString m_remoteProxyServerVersion;
QString m_remoteProxyApiVersion;
bool m_running = false;
QUrl m_serverUrl;
QAbstractSocket::SocketError m_error = QAbstractSocket::UnknownSocketError;
State m_state = StateDisconnected;
ProxyConnection *m_connection = nullptr;
TunnelProxyJsonRpcClient *m_jsonClient = nullptr;
JsonRpcClient *m_jsonClient = nullptr;
void setState(State state);
void setRunning(bool running);
void setError(QAbstractSocket::SocketError error);
void cleanUp();
};
}
#endif // TUNNELPROXYSERVER_H
#endif // TUNNELPROXYSOCKETSERVER_H

46
tests/test-proxy/remoteproxytestsproxy.cpp
View File

@ -128,14 +128,14 @@ void RemoteProxyTestsProxy::monitorServer()
// Connect one
QSignalSpy connectionOneReadySpy(connectionOne, &RemoteProxyConnection::ready);
QVERIFY(connectionOne->connectServer(m_serverUrl));
QVERIFY(connectionOne->connectServer(m_serverUrlProxyWebSocket));
connectionOneReadySpy.wait();
QVERIFY(connectionOneReadySpy.count() == 1);
QVERIFY(connectionOne->isConnected());
// Connect two
QSignalSpy connectionTwoReadySpy(connectionTwo, &RemoteProxyConnection::ready);
QVERIFY(connectionTwo->connectServer(m_serverUrl));
QVERIFY(connectionTwo->connectServer(m_serverUrlProxyWebSocket));
connectionTwoReadySpy.wait();
QVERIFY(connectionTwoReadySpy.count() == 1);
QVERIFY(connectionTwo->isConnected());
@ -597,14 +597,14 @@ void RemoteProxyTestsProxy::authenticateNonce()
// Connect one
QSignalSpy connectionOneReadySpy(connectionOne, &RemoteProxyConnection::ready);
QVERIFY(connectionOne->connectServer(m_serverUrl));
QVERIFY(connectionOne->connectServer(m_serverUrlProxyWebSocket));
connectionOneReadySpy.wait();
QVERIFY(connectionOneReadySpy.count() == 1);
QVERIFY(connectionOne->isConnected());
// Connect two
QSignalSpy connectionTwoReadySpy(connectionTwo, &RemoteProxyConnection::ready);
QVERIFY(connectionTwo->connectServer(m_serverUrl));
QVERIFY(connectionTwo->connectServer(m_serverUrlProxyWebSocket));
connectionTwoReadySpy.wait();
QVERIFY(connectionTwoReadySpy.count() == 1);
QVERIFY(connectionTwo->isConnected());
@ -724,14 +724,14 @@ void RemoteProxyTestsProxy::clientConnectionWebSocket()
// Connect to server (insecue enabled for testing)
QSignalSpy readySpy(connection, &RemoteProxyConnection::ready);
QVERIFY(connection->connectServer(m_serverUrl));
QVERIFY(connection->connectServer(m_serverUrlProxyWebSocket));
readySpy.wait();
QVERIFY(readySpy.count() == 1);
QVERIFY(connection->isConnected());
QVERIFY(!connection->isRemoteConnected());
QVERIFY(connection->state() == RemoteProxyConnection::StateReady);
QVERIFY(connection->error() == QAbstractSocket::UnknownSocketError);
QVERIFY(connection->serverUrl() == m_serverUrl);
QVERIFY(connection->serverUrl() == m_serverUrlProxyWebSocket);
QVERIFY(connection->connectionType() == RemoteProxyConnection::ConnectionTypeWebSocket);
QVERIFY(connection->serverName() == SERVER_NAME_STRING);
QVERIFY(connection->proxyServerName() == Engine::instance()->serverName());
@ -774,14 +774,14 @@ void RemoteProxyTestsProxy::clientConnectionTcpSocket()
// Connect to server (insecue enabled for testing)
QSignalSpy readySpy(connection, &RemoteProxyConnection::ready);
QVERIFY(connection->connectServer(m_serverUrlTcp));
QVERIFY(connection->connectServer(m_serverUrlProxyTcp));
readySpy.wait();
QVERIFY(readySpy.count() == 1);
QVERIFY(connection->isConnected());
QVERIFY(!connection->isRemoteConnected());
QVERIFY(connection->state() == RemoteProxyConnection::StateReady);
QVERIFY(connection->error() == QAbstractSocket::UnknownSocketError);
QVERIFY(connection->serverUrl() == m_serverUrlTcp);
QVERIFY(connection->serverUrl() == m_serverUrlProxyTcp);
QVERIFY(connection->connectionType() == RemoteProxyConnection::ConnectionTypeTcpSocket);
QVERIFY(connection->serverName() == SERVER_NAME_STRING);
QVERIFY(connection->proxyServerName() == Engine::instance()->serverName());
@ -836,14 +836,14 @@ void RemoteProxyTestsProxy::remoteConnection()
// Connect one
QSignalSpy connectionOneReadySpy(connectionOne, &RemoteProxyConnection::ready);
QVERIFY(connectionOne->connectServer(m_serverUrl));
QVERIFY(connectionOne->connectServer(m_serverUrlProxyWebSocket));
connectionOneReadySpy.wait();
QVERIFY(connectionOneReadySpy.count() == 1);
QVERIFY(connectionOne->isConnected());
// Connect two
QSignalSpy connectionTwoReadySpy(connectionTwo, &RemoteProxyConnection::ready);
QVERIFY(connectionTwo->connectServer(m_serverUrl));
QVERIFY(connectionTwo->connectServer(m_serverUrlProxyWebSocket));
connectionTwoReadySpy.wait();
QVERIFY(connectionTwoReadySpy.count() == 1);
QVERIFY(connectionTwo->isConnected());
@ -955,14 +955,14 @@ void RemoteProxyTestsProxy::trippleConnection()
// Connect one
QSignalSpy connectionOneReadySpy(connectionOne, &RemoteProxyConnection::ready);
QVERIFY(connectionOne->connectServer(m_serverUrl));
QVERIFY(connectionOne->connectServer(m_serverUrlProxyWebSocket));
connectionOneReadySpy.wait();
QVERIFY(connectionOneReadySpy.count() == 1);
QVERIFY(connectionOne->isConnected());
// Connect two
QSignalSpy connectionTwoReadySpy(connectionTwo, &RemoteProxyConnection::ready);
QVERIFY(connectionTwo->connectServer(m_serverUrl));
QVERIFY(connectionTwo->connectServer(m_serverUrlProxyWebSocket));
connectionTwoReadySpy.wait();
QVERIFY(connectionTwoReadySpy.count() == 1);
QVERIFY(connectionTwo->isConnected());
@ -995,7 +995,7 @@ void RemoteProxyTestsProxy::trippleConnection()
// Connect three
QSignalSpy connectionThreeReadySpy(connectionThree, &RemoteProxyConnection::ready);
QSignalSpy connectionThreeDisconnectedSpy(connectionThree, &RemoteProxyConnection::disconnected);
QVERIFY(connectionThree->connectServer(m_serverUrl));
QVERIFY(connectionThree->connectServer(m_serverUrlProxyWebSocket));
connectionThreeReadySpy.wait();
QVERIFY(connectionThreeReadySpy.count() == 1);
QVERIFY(connectionThree->isConnected());
@ -1040,14 +1040,14 @@ void RemoteProxyTestsProxy::duplicateUuid()
// Connect one
QSignalSpy connectionOneReadySpy(connectionOne, &RemoteProxyConnection::ready);
QVERIFY(connectionOne->connectServer(m_serverUrl));
QVERIFY(connectionOne->connectServer(m_serverUrlProxyWebSocket));
connectionOneReadySpy.wait();
QVERIFY(connectionOneReadySpy.count() == 1);
QVERIFY(connectionOne->isConnected());
// Connect two
QSignalSpy connectionTwoReadySpy(connectionTwo, &RemoteProxyConnection::ready);
QVERIFY(connectionTwo->connectServer(m_serverUrl));
QVERIFY(connectionTwo->connectServer(m_serverUrlProxyWebSocket));
connectionTwoReadySpy.wait();
QVERIFY(connectionTwoReadySpy.count() == 1);
QVERIFY(connectionTwo->isConnected());
@ -1087,7 +1087,7 @@ void RemoteProxyTestsProxy::sslConfigurations()
// Connect to the server (insecure disabled)
RemoteProxyConnection *connector = new RemoteProxyConnection(QUuid::createUuid(), "Test client one", this);
QSignalSpy spyError(connector, &RemoteProxyConnection::errorOccured);
QVERIFY(connector->connectServer(m_serverUrl));
QVERIFY(connector->connectServer(m_serverUrlProxyWebSocket));
spyError.wait();
QVERIFY(spyError.count() == 1);
qDebug() << connector->error();
@ -1097,7 +1097,7 @@ void RemoteProxyTestsProxy::sslConfigurations()
// Connect to server (insecue enabled)
QSignalSpy spyConnected(connector, &RemoteProxyConnection::connected);
connect(connector, &RemoteProxyConnection::sslErrors, this, &BaseTest::ignoreConnectionSslError);
connector->connectServer(m_serverUrl);
connector->connectServer(m_serverUrlProxyWebSocket);
spyConnected.wait();
QVERIFY(connector->isConnected());
@ -1152,7 +1152,7 @@ void RemoteProxyTestsProxy::inactiveTimeout()
// Connect one
QSignalSpy connectionReadySpy(connection, &RemoteProxyConnection::ready);
QSignalSpy connectionDisconnectedSpy(connection, &RemoteProxyConnection::disconnected);
QVERIFY(connection->connectServer(m_serverUrl));
QVERIFY(connection->connectServer(m_serverUrlProxyWebSocket));
connectionReadySpy.wait();
QVERIFY(connectionReadySpy.count() == 1);
@ -1209,7 +1209,7 @@ void RemoteProxyTestsProxy::authenticationReplyConnection()
// Connect one
QSignalSpy connectionReadySpy(connection, &RemoteProxyConnection::ready);
QVERIFY(connection->connectServer(m_serverUrl));
QVERIFY(connection->connectServer(m_serverUrlProxyWebSocket));
connectionReadySpy.wait();
QVERIFY(connectionReadySpy.count() == 1);
@ -1251,14 +1251,14 @@ void RemoteProxyTestsProxy::tcpRemoteConnection()
// Connect one
QSignalSpy connectionOneReadySpy(connectionOne, &RemoteProxyConnection::ready);
QVERIFY(connectionOne->connectServer(m_serverUrlTcp));
QVERIFY(connectionOne->connectServer(m_serverUrlProxyTcp));
connectionOneReadySpy.wait();
QVERIFY(connectionOneReadySpy.count() == 1);
QVERIFY(connectionOne->isConnected());
// Connect two
QSignalSpy connectionTwoReadySpy(connectionTwo, &RemoteProxyConnection::ready);
QVERIFY(connectionTwo->connectServer(m_serverUrlTcp));
QVERIFY(connectionTwo->connectServer(m_serverUrlProxyTcp));
connectionTwoReadySpy.wait();
QVERIFY(connectionTwoReadySpy.count() == 1);
QVERIFY(connectionTwo->isConnected());
@ -1345,14 +1345,14 @@ void RemoteProxyTestsProxy::tcpWebsocketRemoteConnection()
// Connect one
QSignalSpy connectionOneReadySpy(connectionOne, &RemoteProxyConnection::ready);
QVERIFY(connectionOne->connectServer(m_serverUrl));
QVERIFY(connectionOne->connectServer(m_serverUrlProxyWebSocket));
connectionOneReadySpy.wait();
QVERIFY(connectionOneReadySpy.count() == 1);
QVERIFY(connectionOne->isConnected());
// Connect two
QSignalSpy connectionTwoReadySpy(connectionTwo, &RemoteProxyConnection::ready);
QVERIFY(connectionTwo->connectServer(m_serverUrlTcp));
QVERIFY(connectionTwo->connectServer(m_serverUrlProxyTcp));
connectionTwoReadySpy.wait();
QVERIFY(connectionTwoReadySpy.count() == 1);
QVERIFY(connectionTwo->isConnected());

42
tests/test-tunnelproxy/remoteproxyteststunnelproxy.cpp
View File

@ -31,6 +31,9 @@
#include "loggingcategories.h"
#include "remoteproxyconnection.h"
// Client
#include "tunnelproxy/tunnelproxysocketserver.h"
#include <QMetaType>
#include <QSignalSpy>
#include <QWebSocket>
@ -541,5 +544,44 @@ void RemoteProxyTestsTunnelProxy::crossRegisterServerClient()
stopServer();
}
void RemoteProxyTestsTunnelProxy::testTunnelProxyServer()
{
// Start the server
startServer();
resetDebugCategories();
addDebugCategory("TunnelProxyServer.debug=true");
addDebugCategory("JsonRpcTraffic.debug=true");
addDebugCategory("TunnelProxySocketServer.debug=true");
// Tunnel proxy socket server
QString serverName = "SuperDuper server name";
QUuid serverUuid = QUuid::createUuid();
TunnelProxySocketServer *tunnelProxyServer = new TunnelProxySocketServer(serverUuid, serverName, this);
connect(tunnelProxyServer, &TunnelProxySocketServer::sslErrors, this, [=](const QList<QSslError> &errors){
tunnelProxyServer->ignoreSslErrors(errors);
});
tunnelProxyServer->startServer(m_serverUrlTunnelProxyTcp);
QSignalSpy serverRunningSpy(tunnelProxyServer, &TunnelProxySocketServer::runningChanged);
serverRunningSpy.wait();
QVERIFY(serverRunningSpy.count() == 1);
QList<QVariant> arguments = serverRunningSpy.takeFirst();
QVERIFY(arguments.at(0).toBool() == true);
QVERIFY(tunnelProxyServer->running());
// Tunnel proxy client connection
resetDebugCategories();
// Clean up
stopServer();
}
QTEST_MAIN(RemoteProxyTestsTunnelProxy)

6
tests/test-tunnelproxy/remoteproxyteststunnelproxy.h
View File

@ -44,7 +44,7 @@ private slots:
// Basic stuff
void startStopServer();
// WebSocket connection API
// Raw api calls
void getIntrospect();
void getHello();
@ -60,11 +60,13 @@ private slots:
void registerClient_data();
void registerClient();
void registerServerDuplicated();
void registerClientDuplicated();
void crossRegisterServerClient();
// Client classes
void testTunnelProxyServer();
};
#endif // REMOTEPROXYTESTSTUNNELPROXY_H

4
tests/testbase/basetest.cpp
View File

@ -322,7 +322,7 @@ bool BaseTest::createRemoteConnection(const QString &token, const QString &nonce
// Connect one
QSignalSpy connectionOneReadySpy(connectionOne, &RemoteProxyConnection::ready);
if (!connectionOne->connectServer(m_serverUrl)) {
if (!connectionOne->connectServer(m_serverUrlProxyWebSocket)) {
qWarning() << "Could not connect client one";
return false;
}
@ -340,7 +340,7 @@ bool BaseTest::createRemoteConnection(const QString &token, const QString &nonce
// Connect two
QSignalSpy connectionTwoReadySpy(connectionTwo, &RemoteProxyConnection::ready);
if (!connectionTwo->connectServer(m_serverUrl)) {
if (!connectionTwo->connectServer(m_serverUrlProxyWebSocket)) {
qWarning() << "Could not connect client two";
return false;
}

8
tests/testbase/basetest.h
View File

@ -56,11 +56,11 @@ public:
protected:
ProxyConfiguration *m_configuration = nullptr;
QUrl m_serverUrl = QUrl("wss://127.0.0.1:1212");
QUrl m_serverUrlTcp = QUrl("ssl://127.0.0.1:1213");
QUrl m_serverUrlProxyWebSocket = QUrl("wss://127.0.0.1:1212");
QUrl m_serverUrlProxyTcp = QUrl("ssl://127.0.0.1:1213");
QUrl m_serverUrlTunnel = QUrl("wss://127.0.0.1:2212");
QUrl m_serverUrlTunnelTcp = QUrl("ssl://127.0.0.1:2213");
QUrl m_serverUrlTunnelProxyWebSocket = QUrl("wss://127.0.0.1:2212");
QUrl m_serverUrlTunnelProxyTcp = QUrl("ssl://127.0.0.1:2213");
QSslConfiguration m_sslConfiguration;