added change remote operation

Author: Skycoder42

doc/accountmanager.dox

@@ -379,7 +379,22 @@ ids.
 If `keepData` is false, all local data is deleted. This is basically a full reset. If it is true
 (the default) then all data is kept.
 
-@sa AccountManager::importAccount, AccountManager::importAccountTrusted
+@sa AccountManager::importAccount, AccountManager::importAccountTrusted,
+AccountManager::changeRemote
+*/
+
+/*!
+@fn QtDataSync::AccountManager::changeRemote
+
+@param config The remote config to be used to connect to the new remote
+@param keepData Specify whether the stored data should be preserved
+
+Disconnects you from the current remote, and then tries to connect to the new remote defined by
+the new config. This operation implicitly performs an account reset. See resetAccount() for
+more details.
+
+@sa AccountManager::importAccount, AccountManager::importAccountTrusted,
+AccountManager::resetAccount
 */
 
 /*!

src/datasync/accountmanager.cpp

@@ -123,7 +123,12 @@ bool AccountManager::isTrustedImport(const QByteArray &importData)
 
 void AccountManager::resetAccount(bool keepData)
 {
-	return d->replica->resetAccount(keepData);
+	d->replica->resetAccount(keepData);
+}
+
+void AccountManager::changeRemote(const RemoteConfig &config, bool keepData)
+{
+	d->replica->changeRemote(config, keepData);
 }
 
 void AccountManager::exportAccount(bool includeServer, const function<void(QJsonObject)> &completedFn, const function<void(QString)> &errorFn)

src/datasync/accountmanager.h

@@ -11,7 +11,8 @@
 #include <QtCore/qsharedpointer.h>
 #include <QtCore/qjsonobject.h>
 
-#include "qtdatasync_global.h"
+#include "QtDataSync/qtdatasync_global.h"
+#include "QtDataSync/remoteconfig.h"
 
 class QRemoteObjectNode;
 class QRemoteObjectReplica;
@@ -160,6 +161,8 @@ public Q_SLOTS:
 	}
 	//! Removes this device from the current account and then creates a new one
 	void resetAccount(bool keepData = true);
+	//! Resets the account and connects to the new remote to create a new one
+	void changeRemote(const RemoteConfig &config, bool keepData = true);
 
 	//! Generate a new secret exchange key used to encrypt data
 	void updateExchangeKey();

src/datasync/accountmanager_p.cpp

@@ -72,6 +72,12 @@ void AccountManagerPrivate::resetAccount(bool keepData)
 	_engine->resetAccount(keepData);
 }
 
+void AccountManagerPrivate::changeRemote(const RemoteConfig &config, bool keepData)
+{
+	_engine->remoteConnector()->changeRemote(config);
+	_engine->resetAccount(keepData, false);
+}
+
 void AccountManagerPrivate::exportAccount(const QUuid &id, bool includeServer)
 {
 	try {

src/datasync/accountmanager_p.h

@@ -28,6 +28,7 @@ public Q_SLOTS:
 	void removeDevice(const QUuid &deviceId) override;
 	void updateExchangeKey() override;
 	void resetAccount(bool keepData) override;
+	void changeRemote(const RemoteConfig &config, bool keepData) override;
 	void exportAccount(const QUuid &id, bool includeServer) override;
 	void exportAccountTrusted(const QUuid &id, bool includeServer, const QString &password) override;
 	void importAccount(const JsonObject &importData, bool keepData) override;

src/datasync/accountmanager_p.rep

@@ -10,6 +10,7 @@ class AccountManagerPrivate {
 	SLOT(void removeDevice(const QUuid &deviceId));
 	SLOT(void updateExchangeKey());
 	SLOT(void resetAccount(bool keepData));
+	SLOT(void changeRemote(const QtDataSync::RemoteConfig &config, bool keepData));
 	SLOT(void exportAccount(const QUuid &id, bool includeServer));
 	SLOT(void exportAccountTrusted(const QUuid &id, bool includeServer, const QString &password));
 	SLOT(void importAccount(const QtDataSync::JsonObject &importData, bool keepData));

src/datasync/datasync.pro

@@ -39,7 +39,9 @@ HEADERS += \
 	changeemitter_p.h \
 	signal_private_connect_p.h \
     migrationhelper.h \
-    migrationhelper_p.h
+    migrationhelper_p.h \
+    remoteconfig.h \
+    remoteconfig_p.h
 
 SOURCES += \
 	localstore.cpp \
@@ -68,7 +70,8 @@ SOURCES += \
 	userexchangemanager.cpp \
 	emitteradapter.cpp \
 	changeemitter.cpp \
-    migrationhelper.cpp
+    migrationhelper.cpp \
+    remoteconfig.cpp
 
 STATECHARTS += \
 	connectorstatemachine.scxml

src/datasync/localstore.cpp

@@ -718,7 +718,7 @@ void LocalStore::beginWriteTransaction(const ObjectKey &key, bool exclusive)
 
 void LocalStore::exec(QSqlQuery &query, const ObjectKey &key) const
 {
-	if(!query.exec()) { //TODO do same for prepare
+	if(!query.exec()) {
 			throw LocalStoreException(_defaults,
 									  key,
 									  query.executedQuery().simplified(),

src/datasync/remoteconfig.cpp

@@ -0,0 +1,100 @@
+#include "remoteconfig.h"
+#include "remoteconfig_p.h"
+#include "message_p.h"
+using namespace QtDataSync;
+
+RemoteConfig::RemoteConfig(const QUrl &url, const QString &accessKey, const HeaderHash &headers, int keepaliveTimeout) :
+	d(new RemoteConfigPrivate(url, accessKey, headers, keepaliveTimeout))
+{}
+
+RemoteConfig::RemoteConfig(const RemoteConfig &other) :
+	d(other.d)
+{}
+
+RemoteConfig::~RemoteConfig() {}
+
+RemoteConfig &RemoteConfig::operator=(const RemoteConfig &other)
+{
+	d = other.d;
+	return (*this);
+}
+
+QUrl RemoteConfig::url() const
+{
+	return d->url;
+}
+
+QString RemoteConfig::accessKey() const
+{
+	return d->accessKey;
+}
+
+RemoteConfig::HeaderHash RemoteConfig::headers() const
+{
+	return d->headers;
+}
+
+int RemoteConfig::keepaliveTimeout() const
+{
+	return d->keepaliveTimeout;
+}
+
+void RemoteConfig::setUrl(QUrl url)
+{
+	d->url = url;
+}
+
+void RemoteConfig::setAccessKey(QString accessKey)
+{
+	d->accessKey = accessKey;
+}
+
+void RemoteConfig::setHeaders(RemoteConfig::HeaderHash headers)
+{
+	d->headers = headers;
+}
+
+void RemoteConfig::setKeepaliveTimeout(int keepaliveTimeout)
+{
+	d->keepaliveTimeout = keepaliveTimeout;
+}
+
+
+
+QDataStream &QtDataSync::operator<<(QDataStream &stream, const RemoteConfig &deviceInfo)
+{
+	stream << deviceInfo.d->url
+		   << static_cast<Utf8String>(deviceInfo.d->accessKey)
+		   << deviceInfo.d->headers
+		   << deviceInfo.d->keepaliveTimeout;
+	return stream;
+}
+
+QDataStream &QtDataSync::operator>>(QDataStream &stream, RemoteConfig &deviceInfo)
+{
+	Utf8String accessKey;
+	stream >> deviceInfo.d->url
+		   >> accessKey
+		   >> deviceInfo.d->headers
+		   >> deviceInfo.d->keepaliveTimeout;
+	deviceInfo.d->accessKey = accessKey;
+	return stream;
+}
+
+
+
+RemoteConfigPrivate::RemoteConfigPrivate(const QUrl &url, const QString &accessKey, const RemoteConfig::HeaderHash &headers, int keepaliveTimeout) :
+	QSharedData(),
+	url(url),
+	accessKey(accessKey),
+	headers(headers),
+	keepaliveTimeout(keepaliveTimeout)
+{}
+
+RemoteConfigPrivate::RemoteConfigPrivate(const RemoteConfigPrivate &other) :
+	QSharedData(other),
+	url(other.url),
+	accessKey(other.accessKey),
+	headers(other.headers),
+	keepaliveTimeout(other.keepaliveTimeout)
+{}

src/datasync/remoteconfig.h

@@ -0,0 +1,80 @@
+#ifndef QTDATASYNC_REMOTECONFIG_H
+#define QTDATASYNC_REMOTECONFIG_H
+
+#include <QtCore/qobject.h>
+#include <QtCore/qurl.h>
+#include <QtCore/qhash.h>
+#include <QtCore/qshareddata.h>
+
+#include "QtDataSync/qtdatasync_global.h"
+
+namespace QtDataSync {
+
+class RemoteConfigPrivate;
+//! A configuration on how to connect to a remote server
+class Q_DATASYNC_EXPORT RemoteConfig
+{
+	Q_GADGET
+
+	//! The websocket url of the server to connect to
+	Q_PROPERTY(QUrl url READ url WRITE setUrl)
+	//! A access secret needed in order to connect to the server
+	Q_PROPERTY(QString accessKey READ accessKey WRITE setAccessKey)
+	//! A collection of additional HTTP headers to be sent with the request
+	Q_PROPERTY(HeaderHash headers READ headers WRITE setHeaders)
+	//! The keep alive timeout to be used to send pings to the server
+	Q_PROPERTY(int keepaliveTimeout READ keepaliveTimeout WRITE setKeepaliveTimeout)
+
+public:
+	//! Typedef for a hash of additional HTTP headers
+	typedef QHash<QByteArray, QByteArray> HeaderHash;
+
+	//! Default constructor, with optional parameters
+	RemoteConfig(const QUrl &url = {},
+				 const QString &accessKey = {},
+				 const HeaderHash &headers = {},
+				 int keepaliveTimeout = 1); //1 minute between ping messages (nginx timeout is 75 seconds be default)
+	//! Copy constructor
+	RemoteConfig(const RemoteConfig &other);
+	~RemoteConfig();
+
+	//! Assignment operator
+	RemoteConfig &operator=(const RemoteConfig &other);
+
+	//! @readAcFn{RemoteConfig::url}
+	QUrl url() const;
+	//! @readAcFn{RemoteConfig::accessKey}
+	QString accessKey() const;
+	//! @readAcFn{RemoteConfig::headers}
+	HeaderHash headers() const;
+	//! @readAcFn{RemoteConfig::keepaliveTimeout}
+	int keepaliveTimeout() const;
+
+	//! @writeAcFn{RemoteConfig::url}
+	void setUrl(QUrl url);
+	//! @writeAcFn{RemoteConfig::accessKey}
+	void setAccessKey(QString accessKey);
+	//! @writeAcFn{RemoteConfig::headers}
+	void setHeaders(HeaderHash headers);
+	//! @writeAcFn{RemoteConfig::keepaliveTimeout}
+	void setKeepaliveTimeout(int keepaliveTimeout);
+
+private:
+	QSharedDataPointer<RemoteConfigPrivate> d;
+
+	friend Q_DATASYNC_EXPORT QDataStream &operator<<(QDataStream &stream, const RemoteConfig &deviceInfo);
+	friend Q_DATASYNC_EXPORT QDataStream &operator>>(QDataStream &stream, RemoteConfig &deviceInfo);
+};
+
+//! Stream operator to stream into a QDataStream
+Q_DATASYNC_EXPORT QDataStream &operator<<(QDataStream &stream, const RemoteConfig &deviceInfo);
+//! Stream operator to stream out of a QDataStream
+Q_DATASYNC_EXPORT QDataStream &operator>>(QDataStream &stream, RemoteConfig &deviceInfo);
+
+}
+
+Q_DECLARE_METATYPE(QtDataSync::RemoteConfig)
+Q_DECLARE_TYPEINFO(QtDataSync::RemoteConfig, Q_MOVABLE_TYPE);
+
+
+#endif // QTDATASYNC_REMOTECONFIG_H

src/datasync/remoteconfig_p.h

@@ -0,0 +1,27 @@
+#ifndef QTDATASYNC_REMOTECONFIG_P_H
+#define QTDATASYNC_REMOTECONFIG_P_H
+
+#include "qtdatasync_global.h"
+#include "remoteconfig.h"
+
+namespace QtDataSync {
+
+//no export needed
+class RemoteConfigPrivate : public QSharedData
+{
+public:
+	RemoteConfigPrivate(const QUrl &url,
+						const QString &accessKey,
+						const RemoteConfig::HeaderHash &headers,
+						int keepaliveTimeout);
+	RemoteConfigPrivate(const RemoteConfigPrivate &other);
+
+	QUrl url;
+	QString accessKey;
+	RemoteConfig::HeaderHash headers;
+	int keepaliveTimeout;
+};
+
+}
+
+#endif // QTDATASYNC_REMOTECONFIG_P_H

src/datasync/remoteconnector.cpp

@@ -250,6 +250,13 @@ void RemoteConnector::resetAccount(bool clearConfig)
 	}
 }
 
+void RemoteConnector::changeRemote(const RemoteConfig &config)
+{
+	storeConfig(config);
+	//after storing, continue with "normal" reset. This MUST be done by the engine, thus not in this function
+	logDebug() << "Prepared new remote configuration for next reconnect";
+}
+
 void RemoteConnector::prepareImport(const ExportData &data, const CryptoPP::SecByteBlock &key)
 {
 	//assume data was already "validated"
@@ -827,6 +834,8 @@ RemoteConfig RemoteConnector::loadConfig() const
 
 void RemoteConnector::storeConfig(const RemoteConfig &config)
 {
+	//clean the old config
+	settings()->remove(keyRemoteConfig);
 	//store remote config as well -> via current values, taken from defaults
 	settings()->setValue(keyRemoteUrl, config.url());
 	settings()->setValue(keyRemoteAccessKey, config.accessKey());

src/datasync/remoteconnector_p.h

@@ -103,6 +103,7 @@ public Q_SLOTS:
 	void listDevices();
 	void removeDevice(const QUuid &deviceId);
 	void resetAccount(bool removeConfig);
+	void changeRemote(const RemoteConfig &config);
 	void prepareImport(const ExportData &data, const CryptoPP::SecByteBlock &key);
 	void loginReply(const QUuid &deviceId, bool accept);