App refactoring finished

client/amnezia_application.cpp

@@ -7,12 +7,11 @@
 
 #include "QZXing.h"
 
+#include "core/servercontroller.h"
 #include "debug.h"
 #include "defines.h"
 
-
 #include "platforms/ios/QRCodeReaderBase.h"
-//#include "platforms/ios/MobileUtils.h"
 
 #include "ui/pages.h"
 
@@ -49,14 +48,8 @@ AmneziaApplication::AmneziaApplication(int &argc, char *argv[], bool allowSecond
 {
     setQuitOnLastWindowClosed(false);
     m_settings = std::shared_ptr<Settings>(new Settings);
-
+    m_serverController = std::shared_ptr<ServerController>(new ServerController(m_settings, this));
-//    QObject::connect(&app, &QCoreApplication::aboutToQuit, uiLogic, [&engine, uiLogic](){
+    m_configurator = std::shared_ptr<VpnConfigurator>(new VpnConfigurator(m_settings, m_serverController, this));
-//        QObject::disconnect(engine, 0,0,0);
-//        delete engine;
-
-//        QObject::disconnect(uiLogic, 0,0,0);
-//        delete uiLogic;
-    //    });
 }
 
 AmneziaApplication::~AmneziaApplication()
@@ -71,7 +64,7 @@ AmneziaApplication::~AmneziaApplication()
 void AmneziaApplication::init()
 {
     m_engine = new QQmlApplicationEngine;
-    m_uiLogic = new UiLogic(m_settings);
+    m_uiLogic = new UiLogic(m_settings, m_configurator, m_serverController);
 
     const QUrl url(QStringLiteral("qrc:/ui/qml/main.qml"));
     QObject::connect(m_engine, &QQmlApplicationEngine::objectCreated,

client/amnezia_application.h

@@ -11,6 +11,7 @@
 #include "settings.h"
 
 #include "ui/uilogic.h"
+#include "configurators/vpn_configurator.h"
 
 #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
   #define AMNEZIA_BASE_CLASS SingleApplication
@@ -43,6 +44,8 @@ private:
     QQmlApplicationEngine *m_engine;
     UiLogic *m_uiLogic;
     std::shared_ptr<Settings> m_settings;
+    std::shared_ptr<VpnConfigurator> m_configurator;
+    std::shared_ptr<ServerController> m_serverController;
 
     QTranslator* m_translator;
     QCommandLineParser m_parser;

client/client.pro

@@ -26,6 +26,7 @@ HEADERS  += \
     ../ipc/ipc.h \
     amnezia_application.h \
     configurators/cloak_configurator.h \
+    configurators/configurator_base.h \
     configurators/ikev2_configurator.h \
     configurators/shadowsocks_configurator.h \
     configurators/ssh_configurator.h \
@@ -87,6 +88,7 @@ HEADERS  += \
 SOURCES  += \
     amnezia_application.cpp \
     configurators/cloak_configurator.cpp \
+    configurators/configurator_base.cpp \
     configurators/ikev2_configurator.cpp \
     configurators/shadowsocks_configurator.cpp \
     configurators/ssh_configurator.cpp \

client/configurators/cloak_configurator.cpp

@@ -4,18 +4,25 @@
 #include <QJsonObject>
 #include <QJsonDocument>
 
+#include "core/servercontroller.h"
 #include "containers/containers_defs.h"
 
+CloakConfigurator::CloakConfigurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
+    ConfiguratorBase(settings, serverController, parent)
+{
+
+}
+
 QString CloakConfigurator::genCloakConfig(const ServerCredentials &credentials,
     DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
 {
     ErrorCode e = ErrorCode::NoError;
 
-    QString cloakPublicKey = ServerController::getTextFileFromContainer(container, credentials,
+    QString cloakPublicKey = m_serverController->getTextFileFromContainer(container, credentials,
         amnezia::protocols::cloak::ckPublicKeyPath, &e);
     cloakPublicKey.replace("\n", "");
 
-    QString cloakBypassUid = ServerController::getTextFileFromContainer(container, credentials,
+    QString cloakBypassUid = m_serverController->getTextFileFromContainer(container, credentials,
         amnezia::protocols::cloak::ckBypassUidKeyPath, &e);
     cloakBypassUid.replace("\n", "");
 
@@ -40,8 +47,8 @@ QString CloakConfigurator::genCloakConfig(const ServerCredentials &credentials,
     config.insert(config_key::remote, credentials.hostName);
     config.insert(config_key::port, "$CLOAK_SERVER_PORT");
 
-    QString textCfg = ServerController::replaceVars(QJsonDocument(config).toJson(),
+    QString textCfg = m_serverController->replaceVars(QJsonDocument(config).toJson(),
-        ServerController::genVarsForScript(credentials, container, containerConfig));
+        m_serverController->genVarsForScript(credentials, container, containerConfig));
 
     // qDebug().noquote() << textCfg;
     return textCfg;

client/configurators/cloak_configurator.h

@@ -3,15 +3,18 @@
 
 #include <QObject>
 
-#include "core/defs.h"
+#include "configurator_base.h"
-#include "settings.h"
-#include "core/servercontroller.h"
 
-class CloakConfigurator
+using namespace amnezia;
+
+class CloakConfigurator : ConfiguratorBase
 {
+    Q_OBJECT
 public:
+    CloakConfigurator(std::shared_ptr<Settings> settings,
+        std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
 
-    static QString genCloakConfig(const ServerCredentials &credentials, DockerContainer container,
+    QString genCloakConfig(const ServerCredentials &credentials, DockerContainer container,
         const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
 };
 

client/configurators/configurator_base.cpp

@@ -0,0 +1,10 @@
+#include "configurator_base.h"
+
+ConfiguratorBase::ConfiguratorBase(std::shared_ptr<Settings> settings,
+    std::shared_ptr<ServerController> serverController, QObject *parent)
+    : QObject{parent},
+      m_settings(settings),
+      m_serverController(serverController)
+{
+
+}

client/configurators/configurator_base.h

@@ -0,0 +1,25 @@
+#ifndef CONFIGURATORBASE_H
+#define CONFIGURATORBASE_H
+
+#include <QObject>
+
+class Settings;
+class ServerController;
+
+#include "containers/containers_defs.h"
+#include "core/defs.h"
+
+class ConfiguratorBase : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ConfiguratorBase(std::shared_ptr<Settings> settings,
+        std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
+
+protected:
+    std::shared_ptr<Settings> m_settings;
+    std::shared_ptr<ServerController> m_serverController;
+
+};
+
+#endif // CONFIGURATORBASE_H

client/configurators/ikev2_configurator.cpp

@@ -8,13 +8,18 @@
 #include <QJsonDocument>
 #include <QUuid>
 
-#include "sftpdefs.h"
-
-#include "core/server_defs.h"
 #include "containers/containers_defs.h"
+#include "core/server_defs.h"
 #include "core/scripts_registry.h"
+#include "core/servercontroller.h"
 #include "utils.h"
 
+Ikev2Configurator::Ikev2Configurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
+    ConfiguratorBase(settings, serverController, parent)
+{
+
+}
+
 Ikev2Configurator::ConnectionData Ikev2Configurator::prepareIkev2Config(const ServerCredentials &credentials,
     DockerContainer container, ErrorCode *errorCode)
 {
@@ -35,16 +40,16 @@ Ikev2Configurator::ConnectionData Ikev2Configurator::prepareIkev2Config(const Se
                              "--extKeyUsage serverAuth,clientAuth -8 \"%1\"")
             .arg(connData.clientId);
 
-    ErrorCode e = ServerController::runContainerScript(credentials, container, scriptCreateCert);
+    ErrorCode e = m_serverController->runContainerScript(credentials, container, scriptCreateCert);
 
     QString scriptExportCert = QString("pk12util -W \"%1\" -d sql:/etc/ipsec.d -n \"%2\" -o \"%3\"")
             .arg(connData.password)
             .arg(connData.clientId)
             .arg(certFileName);
-    e = ServerController::runContainerScript(credentials, container, scriptExportCert);
+    e = m_serverController->runContainerScript(credentials, container, scriptExportCert);
 
-    connData.clientCert = ServerController::getTextFileFromContainer(container, credentials, certFileName, &e);
+    connData.clientCert = m_serverController->getTextFileFromContainer(container, credentials, certFileName, &e);
-    connData.caCert = ServerController::getTextFileFromContainer(container, credentials, "/etc/ipsec.d/ca_cert_base64.p12", &e);
+    connData.caCert = m_serverController->getTextFileFromContainer(container, credentials, "/etc/ipsec.d/ca_cert_base64.p12", &e);
 
     qDebug() << "Ikev2Configurator::ConnectionData client cert size:" << connData.clientCert.size();
     qDebug() << "Ikev2Configurator::ConnectionData ca cert size:" << connData.caCert.size();

client/configurators/ikev2_configurator.h

@@ -4,12 +4,15 @@
 #include <QObject>
 #include <QProcessEnvironment>
 
+#include "configurator_base.h"
 #include "core/defs.h"
-#include "core/servercontroller.h"
 
-class Ikev2Configurator
+class Ikev2Configurator : ConfiguratorBase
 {
+    Q_OBJECT
 public:
+    Ikev2Configurator(std::shared_ptr<Settings> settings,
+        std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
 
     struct ConnectionData {
         QByteArray clientCert; // p12 client cert
@@ -19,14 +22,14 @@ public:
         QString host; // host ip
     };
 
-    static QString genIkev2Config(const ServerCredentials &credentials, DockerContainer container,
+    QString genIkev2Config(const ServerCredentials &credentials, DockerContainer container,
         const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
 
-    static QString genIkev2Config(const ConnectionData &connData);
+    QString genIkev2Config(const ConnectionData &connData);
-    static QString genMobileConfig(const ConnectionData &connData);
+    QString genMobileConfig(const ConnectionData &connData);
-    static QString genStrongSwanConfig(const ConnectionData &connData);
+    QString genStrongSwanConfig(const ConnectionData &connData);
 
-    static ConnectionData prepareIkev2Config(const ServerCredentials &credentials,
+    ConnectionData prepareIkev2Config(const ServerCredentials &credentials,
         DockerContainer container, ErrorCode *errorCode = nullptr);
 };
 

client/configurators/openvpn_configurator.cpp

@@ -6,16 +6,25 @@
 #include <QDebug>
 #include <QTemporaryFile>
 #include <QJsonObject>
+#include <QJsonDocument>
 
-#include "core/server_defs.h"
 #include "containers/containers_defs.h"
+#include "core/server_defs.h"
+#include "core/servercontroller.h"
 #include "core/scripts_registry.h"
+#include "settings.h"
 #include "utils.h"
 
 #include <openssl/rsa.h>
 #include <openssl/x509.h>
 #include <openssl/pem.h>
 
+OpenVpnConfigurator::OpenVpnConfigurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
+    ConfiguratorBase(settings, serverController, parent)
+{
+
+}
+
 OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(const ServerCredentials &credentials,
     DockerContainer container, ErrorCode *errorCode)
 {
@@ -31,7 +40,7 @@ OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(co
             arg(amnezia::protocols::openvpn::clientsDirPath).
             arg(connData.clientId);
 
-    ErrorCode e = ServerController::uploadTextFileToContainer(container, credentials, connData.request, reqFileName);
+    ErrorCode e = m_serverController->uploadTextFileToContainer(container, credentials, connData.request, reqFileName);
     if (e) {
         if (errorCode) *errorCode = e;
         return connData;
@@ -43,8 +52,8 @@ OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(co
         return connData;
     }
 
-    connData.caCert = ServerController::getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::caCertPath, &e);
+    connData.caCert = m_serverController->getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::caCertPath, &e);
-    connData.clientCert = ServerController::getTextFileFromContainer(container, credentials,
+    connData.clientCert = m_serverController->getTextFileFromContainer(container, credentials,
         QString("%1/%2.crt").arg(amnezia::protocols::openvpn::clientCertPath).arg(connData.clientId), &e);
 
     if (e) {
@@ -52,7 +61,7 @@ OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(co
         return connData;
     }
 
-    connData.taKey = ServerController::getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::taKeyPath, &e);
+    connData.taKey = m_serverController->getTextFileFromContainer(container, credentials, amnezia::protocols::openvpn::taKeyPath, &e);
 
     if (connData.caCert.isEmpty() || connData.clientCert.isEmpty() || connData.taKey.isEmpty()) {
         if (errorCode) *errorCode = ErrorCode::RemoteProcessCrashError;
@@ -61,17 +70,11 @@ OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::prepareOpenVpnConfig(co
     return connData;
 }
 
-Settings &OpenVpnConfigurator::m_settings()
-{
-    static Settings s;
-    return s;
-}
-
 QString OpenVpnConfigurator::genOpenVpnConfig(const ServerCredentials &credentials,
     DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
 {
-    QString config = ServerController::replaceVars(amnezia::scriptData(ProtocolScriptType::openvpn_template, container),
+    QString config = m_serverController->replaceVars(amnezia::scriptData(ProtocolScriptType::openvpn_template, container),
-            ServerController::genVarsForScript(credentials, container, containerConfig));
+            m_serverController->genVarsForScript(credentials, container, containerConfig));
 
     ConnectionData connData = prepareOpenVpnConfig(credentials, container, errorCode);
     if (errorCode && *errorCode) {
@@ -105,7 +108,7 @@ QString OpenVpnConfigurator::processConfigWithLocalSettings(QString jsonConfig)
     QJsonObject json = QJsonDocument::fromJson(jsonConfig.toUtf8()).object();
     QString config = json[config_key::config].toString();
 
-    if (m_settings().routeMode() != Settings::VpnAllSites) {
+    if (m_settings->routeMode() != Settings::VpnAllSites) {
         config.replace("redirect-gateway def1 bypass-dhcp", "");
     }
     else {
@@ -161,9 +164,9 @@ ErrorCode OpenVpnConfigurator::signCert(DockerContainer container,
             .arg(clientId);
 
     QStringList scriptList {script_import, script_sign};
-    QString script = ServerController::replaceVars(scriptList.join("\n"), ServerController::genVarsForScript(credentials, container));
+    QString script = m_serverController->replaceVars(scriptList.join("\n"), m_serverController->genVarsForScript(credentials, container));
 
-    return ServerController::runScript(credentials, script);
+    return m_serverController->runScript(credentials, script);
 }
 
 OpenVpnConfigurator::ConnectionData OpenVpnConfigurator::createCertRequest()

client/configurators/openvpn_configurator.h

@@ -4,13 +4,15 @@
 #include <QObject>
 #include <QProcessEnvironment>
 
+#include "configurator_base.h"
 #include "core/defs.h"
-#include "settings.h"
-#include "core/servercontroller.h"
 
-class OpenVpnConfigurator
+class OpenVpnConfigurator : ConfiguratorBase
 {
+    Q_OBJECT
 public:
+    OpenVpnConfigurator(std::shared_ptr<Settings> settings,
+        std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
 
     struct ConnectionData {
         QString clientId;
@@ -22,22 +24,21 @@ public:
         QString host; // host ip
     };
 
-    static QString genOpenVpnConfig(const ServerCredentials &credentials, DockerContainer container,
+    QString genOpenVpnConfig(const ServerCredentials &credentials, DockerContainer container,
         const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
 
-    static QString processConfigWithLocalSettings(QString jsonConfig);
+    QString processConfigWithLocalSettings(QString jsonConfig);
-    static QString processConfigWithExportSettings(QString jsonConfig);
+    QString processConfigWithExportSettings(QString jsonConfig);
 
-    static ErrorCode signCert(DockerContainer container,
+    ErrorCode signCert(DockerContainer container,
         const ServerCredentials &credentials, QString clientId);
 
 private:
-    static ConnectionData createCertRequest();
+    ConnectionData createCertRequest();
 
-    static ConnectionData prepareOpenVpnConfig(const ServerCredentials &credentials,
+    ConnectionData prepareOpenVpnConfig(const ServerCredentials &credentials,
         DockerContainer container, ErrorCode *errorCode = nullptr);
 
-    static Settings &m_settings();
 };
 
 #endif // OPENVPN_CONFIGURATOR_H

client/configurators/shadowsocks_configurator.cpp

@@ -5,13 +5,20 @@
 #include <QJsonDocument>
 
 #include "containers/containers_defs.h"
+#include "core/servercontroller.h"
+
+ShadowSocksConfigurator::ShadowSocksConfigurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
+    ConfiguratorBase(settings, serverController, parent)
+{
+
+}
 
 QString ShadowSocksConfigurator::genShadowSocksConfig(const ServerCredentials &credentials,
     DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
 {
     ErrorCode e = ErrorCode::NoError;
 
-    QString ssKey = ServerController::getTextFileFromContainer(container, credentials,
+    QString ssKey = m_serverController->getTextFileFromContainer(container, credentials,
         amnezia::protocols::shadowsocks::ssKeyPath, &e);
     ssKey.replace("\n", "");
 
@@ -29,8 +36,8 @@ QString ShadowSocksConfigurator::genShadowSocksConfig(const ServerCredentials &c
     config.insert("method", "$SHADOWSOCKS_CIPHER");
 
 
-    QString textCfg = ServerController::replaceVars(QJsonDocument(config).toJson(),
+    QString textCfg = m_serverController->replaceVars(QJsonDocument(config).toJson(),
-        ServerController::genVarsForScript(credentials, container, containerConfig));
+        m_serverController->genVarsForScript(credentials, container, containerConfig));
 
     //qDebug().noquote() << textCfg;
     return textCfg;

client/configurators/shadowsocks_configurator.h

@@ -3,15 +3,17 @@
 
 #include <QObject>
 
+#include "configurator_base.h"
 #include "core/defs.h"
-#include "settings.h"
-#include "core/servercontroller.h"
 
-class ShadowSocksConfigurator
+class ShadowSocksConfigurator : ConfiguratorBase
 {
+    Q_OBJECT
 public:
+    ShadowSocksConfigurator(std::shared_ptr<Settings> settings,
+        std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
 
-    static QString genShadowSocksConfig(const ServerCredentials &credentials, DockerContainer container,
+    QString genShadowSocksConfig(const ServerCredentials &credentials, DockerContainer container,
         const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
 };
 

client/configurators/ssh_configurator.cpp

@@ -14,8 +14,15 @@
 #include "core/server_defs.h"
 #include "utils.h"
 
+#include "sftpdefs.h"
+
 using namespace QSsh;
 
+SshConfigurator::SshConfigurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
+    ConfiguratorBase(settings, serverController, parent)
+{
+
+}
 
 QString SshConfigurator::convertOpenSShKey(const QString &key)
 {

client/configurators/ssh_configurator.h

@@ -4,16 +4,19 @@
 #include <QObject>
 #include <QProcessEnvironment>
 
+#include "configurator_base.h"
 #include "core/defs.h"
-#include "settings.h"
-#include "core/servercontroller.h"
 
-class SshConfigurator
+class SshConfigurator : ConfiguratorBase
 {
+    Q_OBJECT
 public:
-    static QProcessEnvironment prepareEnv();
+    SshConfigurator(std::shared_ptr<Settings> settings,
-    static QString convertOpenSShKey(const QString &key);
+        std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
-    static void openSshTerminal(const ServerCredentials &credentials);
+
+    QProcessEnvironment prepareEnv();
+    QString convertOpenSShKey(const QString &key);
+    void openSshTerminal(const ServerCredentials &credentials);
 
 };
 

client/configurators/vpn_configurator.cpp

@@ -4,18 +4,26 @@
 #include "shadowsocks_configurator.h"
 #include "wireguard_configurator.h"
 #include "ikev2_configurator.h"
+#include "ssh_configurator.h"
 
 #include <QFile>
 #include <QJsonObject>
 #include <QJsonDocument>
 
 #include "containers/containers_defs.h"
+#include "settings.h"
 #include "utils.h"
 
-Settings &VpnConfigurator::m_settings()
+VpnConfigurator::VpnConfigurator(std::shared_ptr<Settings> settings,
+    std::shared_ptr<ServerController> serverController, QObject *parent):
+    ConfiguratorBase(settings, serverController, parent)
 {
-    static Settings s;
+    openVpnConfigurator = std::shared_ptr<OpenVpnConfigurator>(new OpenVpnConfigurator(settings, serverController, this));
-    return s;
+    shadowSocksConfigurator = std::shared_ptr<ShadowSocksConfigurator>(new ShadowSocksConfigurator(settings, serverController, this));
+    cloakConfigurator = std::shared_ptr<CloakConfigurator>(new CloakConfigurator(settings, serverController, this));
+    wireguardConfigurator = std::shared_ptr<WireguardConfigurator>(new WireguardConfigurator(settings, serverController, this));
+    ikev2Configurator = std::shared_ptr<Ikev2Configurator>(new Ikev2Configurator(settings, serverController, this));
+    sshConfigurator = std::shared_ptr<SshConfigurator>(new SshConfigurator(settings, serverController, this));
 }
 
 QString VpnConfigurator::genVpnProtocolConfig(const ServerCredentials &credentials,
@@ -23,19 +31,19 @@ QString VpnConfigurator::genVpnProtocolConfig(const ServerCredentials &credentia
 {
     switch (proto) {
     case Proto::OpenVpn:
-        return OpenVpnConfigurator::genOpenVpnConfig(credentials, container, containerConfig, errorCode);
+        return openVpnConfigurator->genOpenVpnConfig(credentials, container, containerConfig, errorCode);
 
     case Proto::ShadowSocks:
-        return ShadowSocksConfigurator::genShadowSocksConfig(credentials, container, containerConfig, errorCode);
+        return shadowSocksConfigurator->genShadowSocksConfig(credentials, container, containerConfig, errorCode);
 
     case Proto::Cloak:
-        return CloakConfigurator::genCloakConfig(credentials, container, containerConfig, errorCode);
+        return cloakConfigurator->genCloakConfig(credentials, container, containerConfig, errorCode);
 
     case Proto::WireGuard:
-        return WireguardConfigurator::genWireguardConfig(credentials, container, containerConfig, errorCode);
+        return wireguardConfigurator->genWireguardConfig(credentials, container, containerConfig, errorCode);
 
     case Proto::Ikev2:
-        return Ikev2Configurator::genIkev2Config(credentials, container, containerConfig, errorCode);
+        return ikev2Configurator->genIkev2Config(credentials, container, containerConfig, errorCode);
 
     default:
         return "";
@@ -46,20 +54,20 @@ QPair<QString, QString> VpnConfigurator::getDnsForConfig(int serverIndex)
 {
     QPair<QString, QString> dns;
 
-    bool useAmneziaDns = m_settings().useAmneziaDns();
+    bool useAmneziaDns = m_settings->useAmneziaDns();
-    const QJsonObject &server = m_settings().server(serverIndex);
+    const QJsonObject &server = m_settings->server(serverIndex);
 
     dns.first = server.value(config_key::dns1).toString();
     dns.second = server.value(config_key::dns2).toString();
 
     if (dns.first.isEmpty() || !Utils::checkIPv4Format(dns.first)) {
-        if (useAmneziaDns && m_settings().containers(serverIndex).contains(DockerContainer::Dns)) {
+        if (useAmneziaDns && m_settings->containers(serverIndex).contains(DockerContainer::Dns)) {
             dns.first = protocols::dns::amneziaDnsIp;
         }
-        else dns.first = m_settings().primaryDns();
+        else dns.first = m_settings->primaryDns();
     }
     if (dns.second.isEmpty() || !Utils::checkIPv4Format(dns.second)) {
-        dns.second = m_settings().secondaryDns();
+        dns.second = m_settings->secondaryDns();
     }
 
     qDebug() << "VpnConfigurator::getDnsForConfig" << dns.first << dns.second;
@@ -83,7 +91,7 @@ QString &VpnConfigurator::processConfigWithLocalSettings(int serverIndex, Docker
     processConfigWithDnsSettings(serverIndex, container, proto, config);
 
     if (proto == Proto::OpenVpn) {
-        config = OpenVpnConfigurator::processConfigWithLocalSettings(config);
+        config = openVpnConfigurator->processConfigWithLocalSettings(config);
     }
     return config;
 }
@@ -94,7 +102,7 @@ QString &VpnConfigurator::processConfigWithExportSettings(int serverIndex, Docke
     processConfigWithDnsSettings(serverIndex, container, proto, config);
 
     if (proto == Proto::OpenVpn) {
-        config = OpenVpnConfigurator::processConfigWithExportSettings(config);
+        config = openVpnConfigurator->processConfigWithExportSettings(config);
     }
     return config;
 }

client/configurators/vpn_configurator.h

@@ -3,29 +3,46 @@
 
 #include <QObject>
 
+#include "configurator_base.h"
 #include "core/defs.h"
-#include "settings.h"
+
-#include "core/servercontroller.h"
+
+class OpenVpnConfigurator;
+class ShadowSocksConfigurator;
+class CloakConfigurator;
+class WireguardConfigurator;
+class Ikev2Configurator;
+class SshConfigurator;
 
 // Retrieve connection settings from server
-class VpnConfigurator
+class VpnConfigurator : ConfiguratorBase
 {
+    Q_OBJECT
 public:
+    VpnConfigurator(std::shared_ptr<Settings> settings,
+        std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
 
-    static QString genVpnProtocolConfig(const ServerCredentials &credentials, DockerContainer container,
+    QString genVpnProtocolConfig(const ServerCredentials &credentials, DockerContainer container,
         const QJsonObject &containerConfig, Proto proto, ErrorCode *errorCode = nullptr);
 
-    static QPair<QString, QString> getDnsForConfig(int serverIndex);
+    QPair<QString, QString> getDnsForConfig(int serverIndex);
-    static QString &processConfigWithDnsSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
+    QString &processConfigWithDnsSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
 
-    static QString &processConfigWithLocalSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
+    QString &processConfigWithLocalSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
-    static QString &processConfigWithExportSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
+    QString &processConfigWithExportSettings(int serverIndex, DockerContainer container, Proto proto, QString &config);
 
     // workaround for containers which is not support normal configaration
-    static void updateContainerConfigAfterInstallation(DockerContainer container,
+    void updateContainerConfigAfterInstallation(DockerContainer container,
         QJsonObject &containerConfig, const QString &stdOut);
 
-    static Settings &m_settings();
+    std::shared_ptr<ServerController> m_serverController;
+
+    std::shared_ptr<OpenVpnConfigurator> openVpnConfigurator;
+    std::shared_ptr<ShadowSocksConfigurator> shadowSocksConfigurator;
+    std::shared_ptr<CloakConfigurator> cloakConfigurator;
+    std::shared_ptr<WireguardConfigurator> wireguardConfigurator;
+    std::shared_ptr<Ikev2Configurator> ikev2Configurator;
+    std::shared_ptr<SshConfigurator> sshConfigurator;
 };
 
 #endif // VPN_CONFIGURATOR_H

client/configurators/wireguard_configurator.cpp

@@ -5,19 +5,28 @@
 #include <QTemporaryDir>
 #include <QDebug>
 #include <QTemporaryFile>
+#include <QJsonDocument>
+
 
 #include <openssl/rand.h>
 #include <openssl/rsa.h>
 #include <openssl/x509.h>
 #include <openssl/pem.h>
 
-#include "sftpdefs.h"
 
-#include "core/server_defs.h"
 #include "containers/containers_defs.h"
+#include "core/server_defs.h"
 #include "core/scripts_registry.h"
+#include "core/servercontroller.h"
+#include "settings.h"
 #include "utils.h"
 
+WireguardConfigurator::WireguardConfigurator(std::shared_ptr<Settings> settings, std::shared_ptr<ServerController> serverController, QObject *parent):
+    ConfiguratorBase(settings, serverController, parent)
+{
+
+}
+
 WireguardConfigurator::ConnectionData WireguardConfigurator::genClientKeys()
 {
     // TODO review
@@ -71,7 +80,7 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
             stdOut += data + "\n";
         };
 
-        ServerController::runContainerScript(credentials, container, script, cbReadStdOut);
+        m_serverController->runContainerScript(credentials, container, script, cbReadStdOut);
         stdOut.replace("AllowedIPs = ", "");
         stdOut.replace("/32", "");
         QStringList ips = stdOut.split("\n", Qt::SkipEmptyParts);
@@ -104,14 +113,14 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
     }
 
     // Get keys
-    connData.serverPubKey = ServerController::getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPublicKeyPath, &e);
+    connData.serverPubKey = m_serverController->getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPublicKeyPath, &e);
     connData.serverPubKey.replace("\n", "");
     if (e) {
         if (errorCode) *errorCode = e;
         return connData;
     }
 
-    connData.pskKey = ServerController::getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPskKeyPath, &e);
+    connData.pskKey = m_serverController->getTextFileFromContainer(container, credentials, amnezia::protocols::wireguard::serverPskKeyPath, &e);
     connData.pskKey.replace("\n", "");
 
     if (e) {
@@ -129,7 +138,7 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
             arg(connData.pskKey).
             arg(connData.clientIP);
 
-    e = ServerController::uploadTextFileToContainer(container, credentials, configPart,
+    e = m_serverController->uploadTextFileToContainer(container, credentials, configPart,
         protocols::wireguard::serverConfigPath, QSsh::SftpOverwriteMode::SftpAppendToExisting);
 
     if (e) {
@@ -137,24 +146,18 @@ WireguardConfigurator::ConnectionData WireguardConfigurator::prepareWireguardCon
         return connData;
     }
 
-    e = ServerController::runScript(credentials,
+    e = m_serverController->runScript(credentials,
-        ServerController::replaceVars("sudo docker exec -i $CONTAINER_NAME bash -c 'wg syncconf wg0 <(wg-quick strip /opt/amnezia/wireguard/wg0.conf)'",
+        m_serverController->replaceVars("sudo docker exec -i $CONTAINER_NAME bash -c 'wg syncconf wg0 <(wg-quick strip /opt/amnezia/wireguard/wg0.conf)'",
-            ServerController::genVarsForScript(credentials, container)));
+            m_serverController->genVarsForScript(credentials, container)));
 
     return connData;
 }
 
-Settings &WireguardConfigurator::m_settings()
-{
-    static Settings s;
-    return s;
-}
-
 QString WireguardConfigurator::genWireguardConfig(const ServerCredentials &credentials,
     DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode)
 {
-    QString config = ServerController::replaceVars(amnezia::scriptData(ProtocolScriptType::wireguard_template, container),
+    QString config = m_serverController->replaceVars(amnezia::scriptData(ProtocolScriptType::wireguard_template, container),
-            ServerController::genVarsForScript(credentials, container, containerConfig));
+            m_serverController->genVarsForScript(credentials, container, containerConfig));
 
     ConnectionData connData = prepareWireguardConfig(credentials, container, containerConfig, errorCode);
     if (errorCode && *errorCode) {
@@ -182,8 +185,8 @@ QString WireguardConfigurator::genWireguardConfig(const ServerCredentials &crede
 QString WireguardConfigurator::processConfigWithLocalSettings(QString config)
 {
     // TODO replace DNS if it already set
-    config.replace("$PRIMARY_DNS", m_settings().primaryDns());
+    config.replace("$PRIMARY_DNS", m_settings->primaryDns());
-    config.replace("$SECONDARY_DNS", m_settings().secondaryDns());
+    config.replace("$SECONDARY_DNS", m_settings->secondaryDns());
 
     QJsonObject jConfig;
     jConfig[config_key::config] = config;
@@ -193,8 +196,8 @@ QString WireguardConfigurator::processConfigWithLocalSettings(QString config)
 
 QString WireguardConfigurator::processConfigWithExportSettings(QString config)
 {
-    config.replace("$PRIMARY_DNS", m_settings().primaryDns());
+    config.replace("$PRIMARY_DNS", m_settings->primaryDns());
-    config.replace("$SECONDARY_DNS", m_settings().secondaryDns());
+    config.replace("$SECONDARY_DNS", m_settings->secondaryDns());
 
     return config;
 }

client/configurators/wireguard_configurator.h

@@ -4,13 +4,15 @@
 #include <QObject>
 #include <QProcessEnvironment>
 
+#include "configurator_base.h"
 #include "core/defs.h"
-#include "settings.h"
-#include "core/servercontroller.h"
 
-class WireguardConfigurator
+class WireguardConfigurator : ConfiguratorBase
 {
+    Q_OBJECT
 public:
+    WireguardConfigurator(std::shared_ptr<Settings> settings,
+        std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
 
     struct ConnectionData {
         QString clientPrivKey; // client private key
@@ -21,20 +23,18 @@ public:
         QString host; // host ip
     };
 
-    static QString genWireguardConfig(const ServerCredentials &credentials, DockerContainer container,
+    QString genWireguardConfig(const ServerCredentials &credentials, DockerContainer container,
         const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
 
-    static QString processConfigWithLocalSettings(QString config);
+    QString processConfigWithLocalSettings(QString config);
-    static QString processConfigWithExportSettings(QString config);
+    QString processConfigWithExportSettings(QString config);
 
 
 private:
-    static ConnectionData prepareWireguardConfig(const ServerCredentials &credentials,
+    ConnectionData prepareWireguardConfig(const ServerCredentials &credentials,
         DockerContainer container, const QJsonObject &containerConfig, ErrorCode *errorCode = nullptr);
 
-    static ConnectionData genClientKeys();
+    ConnectionData genClientKeys();
-
-    static Settings &m_settings();
 };
 
 #endif // WIREGUARD_CONFIGURATOR_H

client/core/servercontroller.cpp

@@ -18,18 +18,18 @@
 
 #include "containers/containers_defs.h"
 #include "server_defs.h"
+#include "settings.h"
 #include "scripts_registry.h"
 #include "utils.h"
 
 #include <configurators/vpn_configurator.h>
 
-
 using namespace QSsh;
 
-Settings &ServerController::m_settings()
+ServerController::ServerController(std::shared_ptr<Settings> settings, QObject *parent) :
+    m_settings(settings)
 {
-    static Settings s;
+
-    return s;
 }
 
 ErrorCode ServerController::runScript(const ServerCredentials &credentials, QString script,
@@ -605,7 +605,7 @@ ErrorCode ServerController::configureContainerWorker(const ServerCredentials &cr
                 cbReadStdOut, cbReadStdErr);
 
 
-    VpnConfigurator::updateContainerConfigAfterInstallation(container, config, stdOut);
+    m_configurator->updateContainerConfigAfterInstallation(container, config, stdOut);
 
     return e;
 }
@@ -698,8 +698,8 @@ ServerController::Vars ServerController::genVarsForScript(const ServerCredential
 
     vars.append({{"$IPSEC_VPN_C2C_TRAFFIC", "no"}});
 
-    vars.append({{"$PRIMARY_SERVER_DNS", m_settings().primaryDns()}});
+    vars.append({{"$PRIMARY_SERVER_DNS", m_settings->primaryDns()}});
-    vars.append({{"$SECONDARY_SERVER_DNS", m_settings().secondaryDns()}});
+    vars.append({{"$SECONDARY_SERVER_DNS", m_settings->secondaryDns()}});
 
 
     // Sftp vars

client/core/servercontroller.h

@@ -7,78 +7,83 @@
 #include "sshremoteprocess.h"
 #include "debug.h"
 #include "defs.h"
-#include "settings.h"
 
 #include "containers/containers_defs.h"
 
 #include "sftpdefs.h"
 
+class Settings;
+class VpnConfigurator;
+
 using namespace amnezia;
 
 class ServerController : public QObject
 {
     Q_OBJECT
 public:
+    ServerController(std::shared_ptr<Settings> settings, QObject *parent = nullptr);
+
     typedef QList<QPair<QString, QString>> Vars;
 
-    static ErrorCode fromSshConnectionErrorCode(QSsh::SshError error);
+    ErrorCode fromSshConnectionErrorCode(QSsh::SshError error);
 
     // QSsh exitCode and exitStatus are different things
-    static ErrorCode fromSshProcessExitStatus(int exitStatus);
+    ErrorCode fromSshProcessExitStatus(int exitStatus);
 
-    static QSsh::SshConnectionParameters sshParams(const ServerCredentials &credentials);
+    QSsh::SshConnectionParameters sshParams(const ServerCredentials &credentials);
-    static void disconnectFromHost(const ServerCredentials &credentials);
+    void disconnectFromHost(const ServerCredentials &credentials);
 
-    static ErrorCode removeAllContainers(const ServerCredentials &credentials);
+    ErrorCode removeAllContainers(const ServerCredentials &credentials);
-    static ErrorCode removeContainer(const ServerCredentials &credentials, DockerContainer container);
+    ErrorCode removeContainer(const ServerCredentials &credentials, DockerContainer container);
-    static ErrorCode setupContainer(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
+    ErrorCode setupContainer(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
-    static ErrorCode updateContainer(const ServerCredentials &credentials, DockerContainer container,
+    ErrorCode updateContainer(const ServerCredentials &credentials, DockerContainer container,
         const QJsonObject &oldConfig, QJsonObject &newConfig);
 
     // create initial config - generate passwords, etc
-    static QJsonObject createContainerInitialConfig(DockerContainer container, int port, TransportProto tp);
+    QJsonObject createContainerInitialConfig(DockerContainer container, int port, TransportProto tp);
 
-    static bool isReinstallContainerRequred(DockerContainer container, const QJsonObject &oldConfig, const QJsonObject &newConfig);
+    bool isReinstallContainerRequred(DockerContainer container, const QJsonObject &oldConfig, const QJsonObject &newConfig);
 
-    static ErrorCode checkOpenVpnServer(DockerContainer container, const ServerCredentials &credentials);
+    ErrorCode checkOpenVpnServer(DockerContainer container, const ServerCredentials &credentials);
 
-    static ErrorCode uploadFileToHost(const ServerCredentials &credentials, const QByteArray &data,
+    ErrorCode uploadFileToHost(const ServerCredentials &credentials, const QByteArray &data,
         const QString &remotePath, QSsh::SftpOverwriteMode overwriteMode = QSsh::SftpOverwriteMode::SftpOverwriteExisting);
 
-    static ErrorCode uploadTextFileToContainer(DockerContainer container,
+    ErrorCode uploadTextFileToContainer(DockerContainer container,
         const ServerCredentials &credentials, const QString &file, const QString &path,
         QSsh::SftpOverwriteMode overwriteMode = QSsh::SftpOverwriteMode::SftpOverwriteExisting);
 
-    static QByteArray getTextFileFromContainer(DockerContainer container,
+    QByteArray getTextFileFromContainer(DockerContainer container,
         const ServerCredentials &credentials, const QString &path, ErrorCode *errorCode = nullptr);
 
-    static ErrorCode setupServerFirewall(const ServerCredentials &credentials);
+    ErrorCode setupServerFirewall(const ServerCredentials &credentials);
 
-    static QString replaceVars(const QString &script, const Vars &vars);
+    QString replaceVars(const QString &script, const Vars &vars);
 
-    static ErrorCode runScript(const ServerCredentials &credentials, QString script,
+    ErrorCode runScript(const ServerCredentials &credentials, QString script,
         const std::function<void(const QString &, QSharedPointer<QSsh::SshRemoteProcess>)> &cbReadStdOut = nullptr,
         const std::function<void(const QString &, QSharedPointer<QSsh::SshRemoteProcess>)> &cbReadStdErr = nullptr);
 
-    static ErrorCode runContainerScript(const ServerCredentials &credentials, DockerContainer container, QString script,
+    ErrorCode runContainerScript(const ServerCredentials &credentials, DockerContainer container, QString script,
         const std::function<void(const QString &, QSharedPointer<QSsh::SshRemoteProcess>)> &cbReadStdOut = nullptr,
         const std::function<void(const QString &, QSharedPointer<QSsh::SshRemoteProcess>)> &cbReadStdErr = nullptr);
 
-    static Vars genVarsForScript(const ServerCredentials &credentials, DockerContainer container = DockerContainer::None, const QJsonObject &config = QJsonObject());
+    Vars genVarsForScript(const ServerCredentials &credentials, DockerContainer container = DockerContainer::None, const QJsonObject &config = QJsonObject());
 
-    static QString checkSshConnection(const ServerCredentials &credentials, ErrorCode *errorCode = nullptr);
+    QString checkSshConnection(const ServerCredentials &credentials, ErrorCode *errorCode = nullptr);
-    static QSsh::SshConnection *connectToHost(const QSsh::SshConnectionParameters &sshParams);
+    QSsh::SshConnection *connectToHost(const QSsh::SshConnectionParameters &sshParams);
 
 private:
 
-    static ErrorCode installDockerWorker(const ServerCredentials &credentials, DockerContainer container);
+    ErrorCode installDockerWorker(const ServerCredentials &credentials, DockerContainer container);
-    static ErrorCode prepareHostWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
+    ErrorCode prepareHostWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
-    static ErrorCode buildContainerWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
+    ErrorCode buildContainerWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
-    static ErrorCode runContainerWorker(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
+    ErrorCode runContainerWorker(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
-    static ErrorCode configureContainerWorker(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
+    ErrorCode configureContainerWorker(const ServerCredentials &credentials, DockerContainer container, QJsonObject &config);
-    static ErrorCode startupContainerWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
+    ErrorCode startupContainerWorker(const ServerCredentials &credentials, DockerContainer container, const QJsonObject &config = QJsonObject());
 
-    static Settings &m_settings();
+    std::shared_ptr<Settings> m_settings;
+    std::shared_ptr<VpnConfigurator> m_configurator;
 };
 
 #endif // SERVERCONTROLLER_H

client/protocols/openvpnovercloakprotocol.cpp

@@ -1,5 +1,4 @@
 #include "openvpnovercloakprotocol.h"
-#include "core/servercontroller.h"
 
 #include "utils.h"
 #include "containers/containers_defs.h"

client/protocols/shadowsocksvpnprotocol.cpp

@@ -1,5 +1,4 @@
 #include "shadowsocksvpnprotocol.h"
-#include "core/servercontroller.h"
 
 #include "debug.h"
 #include "utils.h"

client/ui/pages_logic/NetworkSettingsLogic.cpp

@@ -1,6 +1,7 @@
 #include "NetworkSettingsLogic.h"
 
 #include "defines.h"
+#include "settings.h"
 #include "utils.h"
 
 NetworkSettingsLogic::NetworkSettingsLogic(UiLogic *logic, QObject *parent):

client/ui/pages_logic/NewServerProtocolsLogic.h

@@ -2,6 +2,7 @@
 #define NEW_SERVER_PROTOCOLS_LOGIC_H
 
 #include "PageLogicBase.h"
+#include "containers/containers_defs.h"
 
 class UiLogic;
 

client/ui/pages_logic/PageLogicBase.cpp

@@ -1,6 +1,8 @@
 #include "PageLogicBase.h"
-#include "ui/uilogic.h"
 
+#include "ui/uilogic.h"
+#include "settings.h"
+#include "configurators/vpn_configurator.h"
 
 PageLogicBase::PageLogicBase(UiLogic *logic, QObject *parent):
     QObject(parent),
@@ -8,6 +10,8 @@ PageLogicBase::PageLogicBase(UiLogic *logic, QObject *parent):
     m_uiLogic(logic)
 {
     m_settings = logic->m_settings;
+    m_configurator = logic->m_configurator;
+    m_serverController = logic->m_serverController;
 }
 
 

client/ui/pages_logic/PageLogicBase.h

@@ -1,14 +1,15 @@
 #ifndef PAGE_LOGIC_BASE_H
 #define PAGE_LOGIC_BASE_H
 
-#include "settings.h"
 #include "../pages.h"
 #include "../property_helper.h"
 
-using namespace amnezia;
 using namespace PageEnumNS;
 
 class UiLogic;
+class Settings;
+class VpnConfigurator;
+class ServerController;
 
 class PageLogicBase : public QObject
 {
@@ -22,10 +23,12 @@ public:
     Q_INVOKABLE virtual void onUpdatePage() {}
 
 protected:
-    UiLogic *uiLogic() const { return m_uiLogic; }
-    std::shared_ptr<Settings> m_settings;
-
     UiLogic *m_uiLogic;
+    UiLogic *uiLogic() const { return m_uiLogic; }
+
+    std::shared_ptr<Settings> m_settings;
+    std::shared_ptr<VpnConfigurator> m_configurator;
+    std::shared_ptr<ServerController> m_serverController;
 
 signals:
     void updatePage();

client/ui/pages_logic/ServerConfiguringProgressLogic.h

@@ -3,6 +3,9 @@
 
 #include <functional>
 #include "PageLogicBase.h"
+#include "core/defs.h"
+
+using namespace amnezia;
 
 class UiLogic;
 

client/ui/pages_logic/ServerContainersLogic.cpp

@@ -67,7 +67,7 @@ void ServerContainersLogic::onPushButtonShareClicked(DockerContainer c)
 void ServerContainersLogic::onPushButtonRemoveClicked(DockerContainer container)
 {
     //buttonSetEnabledFunc(false);
-    ErrorCode e = ServerController::removeContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), container);
+    ErrorCode e = m_serverController->removeContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), container);
     m_settings->removeContainerConfig(uiLogic()->selectedServerIndex, container);
     //buttonSetEnabledFunc(true);
 
@@ -81,13 +81,13 @@ void ServerContainersLogic::onPushButtonRemoveClicked(DockerContainer container)
 
 void ServerContainersLogic::onPushButtonContinueClicked(DockerContainer c, int port, TransportProto tp)
 {
-    QJsonObject config = ServerController::createContainerInitialConfig(c, port, tp);
+    QJsonObject config = m_serverController->createContainerInitialConfig(c, port, tp);
 
     emit uiLogic()->goToPage(Page::ServerConfiguringProgress);
     qApp->processEvents();
 
     ErrorCode e = uiLogic()->serverConfiguringProgressLogic()->doInstallAction([this, c, &config](){
-        return ServerController::setupContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), c, config);
+        return m_serverController->setupContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), c, config);
     });
 
     if (!e) {

client/ui/pages_logic/ServerContainersLogic.h

@@ -2,6 +2,7 @@
 #define SERVER_CONTAINERS_LOGIC_H
 
 #include "PageLogicBase.h"
+#include "containers/containers_defs.h"
 
 class UiLogic;
 

client/ui/pages_logic/ServerSettingsLogic.cpp

@@ -52,10 +52,10 @@ void ServerSettingsLogic::onPushButtonClearServer()
         uiLogic()->vpnLogic()->onDisconnect();
     }
 
-    ErrorCode e = ServerController::removeAllContainers(m_settings->serverCredentials(uiLogic()->selectedServerIndex));
+    ErrorCode e = m_serverController->removeAllContainers(m_settings->serverCredentials(uiLogic()->selectedServerIndex));
-    ServerController::disconnectFromHost(m_settings->serverCredentials(uiLogic()->selectedServerIndex));
+    m_serverController->disconnectFromHost(m_settings->serverCredentials(uiLogic()->selectedServerIndex));
     if (e) {
-        uiLogic()->setDialogConnectErrorText(
+        uiLogic()->set_dialogConnectErrorText(
                     tr("Error occurred while configuring server.") + "\n" +
                     errorString(e) + "\n" +
                     tr("See logs for details."));

client/ui/pages_logic/ShareConnectionLogic.cpp

@@ -21,6 +21,7 @@
 #include "defines.h"
 #include "core/defs.h"
 #include "core/errorstrings.h"
+#include "core/servercontroller.h"
 #include <functional>
 
 #include "../uilogic.h"
@@ -85,7 +86,7 @@ void ShareConnectionLogic::onPushButtonShareAmneziaGenerateClicked()
         for (Proto p: ContainerProps::protocolsForContainer(container)) {
             QJsonObject protoConfig = m_settings->protocolConfig(serverIndex, container, p);
 
-            QString cfg = VpnConfigurator::genVpnProtocolConfig(credentials, container, containerConfig, p, &e);
+            QString cfg = m_configurator->genVpnProtocolConfig(credentials, container, containerConfig, p, &e);
             if (e) {
                 cfg = "Error generating config";
                 break;
@@ -103,7 +104,7 @@ void ShareConnectionLogic::onPushButtonShareAmneziaGenerateClicked()
             serverConfig.insert(config_key::containers, QJsonArray {containerConfig});
             serverConfig.insert(config_key::defaultContainer, ContainerProps::containerToString(container));
 
-            auto dns = VpnConfigurator::getDnsForConfig(serverIndex);
+            auto dns = m_configurator->getDnsForConfig(serverIndex);
             serverConfig.insert(config_key::dns1, dns.first);
             serverConfig.insert(config_key::dns2, dns.second);
 
@@ -134,8 +135,8 @@ void ShareConnectionLogic::onPushButtonShareOpenVpnGenerateClicked()
     const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
 
     ErrorCode e = ErrorCode::NoError;
-    QString cfg = OpenVpnConfigurator::genOpenVpnConfig(credentials, container, containerConfig, &e);
+    QString cfg = m_configurator->openVpnConfigurator->genOpenVpnConfig(credentials, container, containerConfig, &e);
-    cfg = VpnConfigurator::processConfigWithExportSettings(serverIndex, container, Proto::OpenVpn, cfg);
+    cfg = m_configurator->processConfigWithExportSettings(serverIndex, container, Proto::OpenVpn, cfg);
 
     set_textEditShareOpenVpnCodeText(QJsonDocument::fromJson(cfg.toUtf8()).object()[config_key::config].toString());
 }
@@ -153,7 +154,7 @@ void ShareConnectionLogic::onPushButtonShareShadowSocksGenerateClicked()
         const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
 
         ErrorCode e = ErrorCode::NoError;
-        cfg = ShadowSocksConfigurator::genShadowSocksConfig(credentials, container, containerConfig, &e);
+        cfg = m_configurator->shadowSocksConfigurator->genShadowSocksConfig(credentials, container, containerConfig, &e);
     }
 
     QJsonObject ssConfig = QJsonDocument::fromJson(cfg.toUtf8()).object();
@@ -195,7 +196,7 @@ void ShareConnectionLogic::onPushButtonShareCloakGenerateClicked()
         const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
 
         ErrorCode e = ErrorCode::NoError;
-        cfg = CloakConfigurator::genCloakConfig(credentials, container, containerConfig, &e);
+        cfg = m_configurator->cloakConfigurator->genCloakConfig(credentials, container, containerConfig, &e);
     }
 
     QJsonObject cloakConfig = QJsonDocument::fromJson(cfg.toUtf8()).object();
@@ -214,14 +215,14 @@ void ShareConnectionLogic::onPushButtonShareWireGuardGenerateClicked()
     const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
 
     ErrorCode e = ErrorCode::NoError;
-    QString cfg = WireguardConfigurator::genWireguardConfig(credentials, container, containerConfig, &e);
+    QString cfg = m_configurator->wireguardConfigurator->genWireguardConfig(credentials, container, containerConfig, &e);
     if (e) {
         QMessageBox::warning(nullptr, APPLICATION_NAME,
                              tr("Error occurred while configuring server.") + "\n" +
                              errorString(e));
         return;
     }
-    cfg = VpnConfigurator::processConfigWithExportSettings(serverIndex, container, Proto::WireGuard, cfg);
+    cfg = m_configurator->processConfigWithExportSettings(serverIndex, container, Proto::WireGuard, cfg);
     cfg = QJsonDocument::fromJson(cfg.toUtf8()).object()[config_key::config].toString();
 
     set_textEditShareWireGuardCodeText(cfg);
@@ -239,18 +240,18 @@ void ShareConnectionLogic::onPushButtonShareIkev2GenerateClicked()
 
     //const QJsonObject &containerConfig = m_settings->containerConfig(serverIndex, container);
 
-    Ikev2Configurator::ConnectionData connData = Ikev2Configurator::prepareIkev2Config(credentials, container);
+    Ikev2Configurator::ConnectionData connData = m_configurator->ikev2Configurator->prepareIkev2Config(credentials, container);
 
-    QString cfg = Ikev2Configurator::genIkev2Config(connData);
+    QString cfg = m_configurator->ikev2Configurator->genIkev2Config(connData);
-    cfg = VpnConfigurator::processConfigWithExportSettings(serverIndex, container, Proto::Ikev2, cfg);
+    cfg = m_configurator->processConfigWithExportSettings(serverIndex, container, Proto::Ikev2, cfg);
     cfg = QJsonDocument::fromJson(cfg.toUtf8()).object()[config_key::cert].toString();
 
     set_textEditShareIkev2CertText(cfg);
 
-    QString mobileCfg = Ikev2Configurator::genMobileConfig(connData);
+    QString mobileCfg = m_configurator->ikev2Configurator->genMobileConfig(connData);
     set_textEditShareIkev2MobileConfigText(mobileCfg);
 
-    QString strongSwanCfg = Ikev2Configurator::genStrongSwanConfig(connData);
+    QString strongSwanCfg = m_configurator->ikev2Configurator->genStrongSwanConfig(connData);
     set_textEditShareIkev2StrongSwanConfigText(strongSwanCfg);
 
 }

client/ui/pages_logic/ShareConnectionLogic.h

@@ -2,6 +2,7 @@
 #define SHARE_CONNECTION_LOGIC_H
 
 #include "PageLogicBase.h"
+#include "containers/containers_defs.h"
 
 class UiLogic;
 

client/ui/pages_logic/SitesLogic.h

@@ -2,6 +2,7 @@
 #define SITES_LOGIC_H
 
 #include "PageLogicBase.h"
+#include "settings.h"
 
 class UiLogic;
 class SitesModel;

client/ui/pages_logic/StartPageLogic.cpp

@@ -1,6 +1,7 @@
 #include "StartPageLogic.h"
 #include "core/errorstrings.h"
 #include "configurators/ssh_configurator.h"
+#include "configurators/vpn_configurator.h"
 #include "../uilogic.h"
 #include "utils.h"
 
@@ -83,7 +84,7 @@ void StartPageLogic::onPushButtonConnect()
         }
 
         if (key.contains("OPENSSH") && key.contains("BEGIN") && key.contains("PRIVATE KEY")) {
-            key = SshConfigurator::convertOpenSShKey(key);
+            key = m_configurator->sshConfigurator->convertOpenSShKey(key);
         }
 
         serverCredentials.password = key;
@@ -97,7 +98,7 @@ void StartPageLogic::onPushButtonConnect()
 
     ErrorCode e = ErrorCode::NoError;
 #ifdef Q_DEBUG
-    //QString output = ServerController::checkSshConnection(serverCredentials, &e);
+    //QString output = m_serverController->checkSshConnection(serverCredentials, &e);
 #else
     QString output;
 #endif

client/ui/pages_logic/VpnLogic.cpp

@@ -69,7 +69,7 @@ void VpnLogic::onUpdatePage()
     QString selectedContainerName = ContainerProps::containerHumanNames().value(selectedContainer);
     set_labelCurrentService(selectedContainerName);
 
-    auto dns = VpnConfigurator::getDnsForConfig(m_settings->defaultServerIndex());
+    auto dns = m_configurator->getDnsForConfig(m_settings->defaultServerIndex());
     set_amneziaDnsEnabled(dns.first == protocols::dns::amneziaDnsIp);
     if (dns.first == protocols::dns::amneziaDnsIp) {
         set_labelCurrentDns("On your server");
@@ -233,14 +233,6 @@ void VpnLogic::onConnectWorker(int serverIndex, const ServerCredentials &credent
     qApp->processEvents();
 
     emit connectToVpn(serverIndex, credentials, container, containerConfig);
-
-//    if (errorCode) {
-//        //ui->pushButton_connect->setChecked(false);
-//        uiLogic()->setDialogConnectErrorText(errorString(errorCode));
-//        emit uiLogic()->showConnectErrorDialog();
-//        return;
-//    }
-
 }
 
 void VpnLogic::onDisconnect()

client/ui/pages_logic/WizardLogic.h

@@ -2,6 +2,7 @@
 #define WIZARD_LOGIC_H
 
 #include "PageLogicBase.h"
+#include "containers/containers_defs.h"
 
 class UiLogic;
 

client/ui/pages_logic/protocols/CloakLogic.cpp

@@ -89,7 +89,7 @@ void CloakLogic::onPushButtonSaveClicked()
     };
 
     ErrorCode e = uiLogic()->doInstallAction([this, containerConfig, &newContainerConfig](){
-        return ServerController::updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
+        return m_serverController->updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
     },
     page_func, progressBar_reset,
     pushButton_save_func, label_info_func);

client/ui/pages_logic/protocols/OpenVpnLogic.cpp

@@ -118,7 +118,7 @@ void OpenVpnLogic::onPushButtonProtoOpenVpnSaveClicked()
     };
 
     ErrorCode e = uiLogic()->doInstallAction([this, containerConfig, &newContainerConfig](){
-        return ServerController::updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
+        return m_serverController->updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
     },
     page_proto_openvpn, progressBar_proto_openvpn_reset,
     pushButton_proto_openvpn_save, label_proto_openvpn_info);

client/ui/pages_logic/protocols/OtherProtocolsLogic.cpp

@@ -5,7 +5,6 @@
 #include <QStandardPaths>
 
 #include "OtherProtocolsLogic.h"
-#include "core/servercontroller.h"
 #include <functional>
 #include "../../uilogic.h"
 #include "utils.h"

client/ui/pages_logic/protocols/ShadowSocksLogic.cpp

@@ -82,7 +82,7 @@ void ShadowSocksLogic::onPushButtonSaveClicked()
     };
 
     ErrorCode e = uiLogic()->doInstallAction([this, containerConfig, &newContainerConfig](){
-        return ServerController::updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
+        return m_serverController->updateContainer(m_settings->serverCredentials(uiLogic()->selectedServerIndex), uiLogic()->selectedDockerContainer, containerConfig, newContainerConfig);
     },
     page_proto_shadowsocks, progressBar_reset,
     pushButton_proto_shadowsocks_save, label_proto_shadowsocks_info);

client/ui/property_helper.h

@@ -14,7 +14,7 @@
         } \
        Q_SIGNAL void NAME ## Changed(TYPE value);\
     private: \
-       TYPE m_ ## NAME;
+       TYPE m_ ## NAME{};
 
 #define READONLY_PROPERTY(TYPE, NAME) \
     Q_PROPERTY(TYPE NAME READ NAME CONSTANT ) \
@@ -22,6 +22,6 @@
        TYPE NAME() const { return m_ ## NAME ; } \
     private: \
        void NAME(TYPE value) {m_ ## NAME = value; } \
-       TYPE m_ ## NAME;
+       TYPE m_ ## NAME{};
 
 #endif // PROPERTY_HELPER_H

client/ui/uilogic.cpp

@@ -74,14 +74,17 @@
 using namespace amnezia;
 using namespace PageEnumNS;
 
-UiLogic::UiLogic(std::shared_ptr<Settings> settings, QObject *parent) :
+UiLogic::UiLogic(std::shared_ptr<Settings> settings, std::shared_ptr<VpnConfigurator> configurator,
+    std::shared_ptr<ServerController> serverController,
+    QObject *parent) :
     QObject(parent),
     m_settings(settings),
-    m_dialogConnectErrorText{}
+    m_configurator(configurator),
+    m_serverController(serverController)
 {
     m_containersModel = new ContainersModel(settings, this);
     m_protocolsModel = new ProtocolsModel(settings, this);
-    m_vpnConnection = new VpnConnection(settings);
+    m_vpnConnection = new VpnConnection(settings, configurator, serverController);
     m_vpnConnection->moveToThread(&m_vpnConnectionThread);
     m_vpnConnectionThread.start();
 
@@ -173,19 +176,6 @@ void UiLogic::initalizeUiLogic()
     qInfo().noquote() << QString("%1 (%2)").arg(QSysInfo::prettyProductName()).arg(QSysInfo::currentCpuArchitecture());
 }
 
-QString UiLogic::getDialogConnectErrorText() const
-{
-    return m_dialogConnectErrorText;
-}
-
-void UiLogic::setDialogConnectErrorText(const QString &dialogConnectErrorText)
-{
-    if (m_dialogConnectErrorText != dialogConnectErrorText) {
-        m_dialogConnectErrorText = dialogConnectErrorText;
-        emit dialogConnectErrorTextChanged();
-    }
-}
-
 void UiLogic::showOnStartup()
 {
     if (! m_settings->isStartMinimized()) {
@@ -259,7 +249,7 @@ void UiLogic::keyPressEvent(Qt::Key key)
         onGotoCurrentProtocolsPage();
         break;
     case Qt::Key_T:
-        SshConfigurator::openSshTerminal(m_settings->serverCredentials(m_settings->defaultServerIndex()));
+        m_configurator->sshConfigurator->openSshTerminal(m_settings->serverCredentials(m_settings->defaultServerIndex()));
         break;
     case Qt::Key_Escape:
     case Qt::Key_Back:
@@ -443,9 +433,9 @@ bool UiLogic::installContainers(ServerCredentials credentials,
         progress.setTextVisibleFunc(true);
         progress.setTextFunc(QString("Installing %1 %2 %3").arg(cnt+1).arg(tr("of")).arg(containers.size()));
 
-        ErrorCode e = ServerController::setupContainer(credentials, i.key(), i.value());
+        ErrorCode e = m_serverController->setupContainer(credentials, i.key(), i.value());
         qDebug() << "Setup server finished with code" << e;
-        ServerController::disconnectFromHost(credentials);
+        m_serverController->disconnectFromHost(credentials);
 
         if (e) {
             if (page.setEnabledFunc) {

client/ui/uilogic.h

@@ -16,7 +16,10 @@
 #include "models/protocols_model.h"
 
 #include "notificationhandler.h"
-#include "settings.h"
+
+class Settings;
+class VpnConfigurator;
+class ServerController;
 
 class AppSettingsLogic;
 class GeneralSettingsLogic;
@@ -50,15 +53,14 @@ class UiLogic : public QObject
     AUTO_PROPERTY(bool, pageEnabled)
     AUTO_PROPERTY(int, pagesStackDepth)
     AUTO_PROPERTY(int, currentPageValue)
+    AUTO_PROPERTY(QString, dialogConnectErrorText)
 
     READONLY_PROPERTY(QObject *, containersModel)
     READONLY_PROPERTY(QObject *, protocolsModel)
 
-    // TODO: review
-    Q_PROPERTY(QString dialogConnectErrorText READ getDialogConnectErrorText WRITE setDialogConnectErrorText NOTIFY dialogConnectErrorTextChanged)
-
 public:
-    explicit UiLogic(std::shared_ptr<Settings> settings, QObject *parent = nullptr);
+    explicit UiLogic(std::shared_ptr<Settings> settings, std::shared_ptr<VpnConfigurator> configurator,
+        std::shared_ptr<ServerController> serverController, QObject *parent = nullptr);
     ~UiLogic();
     void showOnStartup();
 
@@ -108,9 +110,6 @@ public:
 
     void shareTempFile(const QString &suggestedName, QString ext, const QString& data);
 
-    QString getDialogConnectErrorText() const;
-    void setDialogConnectErrorText(const QString &dialogConnectErrorText);
-
 signals:
     void dialogConnectErrorTextChanged();
 
@@ -127,9 +126,6 @@ signals:
     void raise();
     void toggleLogPanel();
 
-private:
-    QString m_dialogConnectErrorText;
-
 private slots:
     // containers - INOUT arg
     void installServer(QMap<DockerContainer, QJsonObject> &containers);
@@ -214,7 +210,10 @@ private:
 
     VpnConnection* m_vpnConnection;
     QThread m_vpnConnectionThread;
+
     std::shared_ptr<Settings> m_settings;
+    std::shared_ptr<VpnConfigurator> m_configurator;
+    std::shared_ptr<ServerController> m_serverController;
 
     NotificationHandler* m_notificationHandler;
 

client/vpnconnection.cpp

@@ -29,8 +29,12 @@
 #include "utils.h"
 #include "vpnconnection.h"
 
-VpnConnection::VpnConnection(std::shared_ptr<Settings> settings, QObject* parent) : QObject(parent),
+VpnConnection::VpnConnection(std::shared_ptr<Settings> settings,
-    m_settings(settings)
+    std::shared_ptr<VpnConfigurator> configurator,
+    std::shared_ptr<ServerController> serverController, QObject* parent) : QObject(parent),
+    m_settings(settings),
+    m_configurator(configurator),
+    m_serverController(serverController)
 {
 }
 
@@ -214,18 +218,18 @@ QString VpnConnection::createVpnConfigurationForProto(int serverIndex,
     QString configData;
     if (lastVpnConfig.contains(proto)) {
         configData = lastVpnConfig.value(proto);
-        configData = VpnConfigurator::processConfigWithLocalSettings(serverIndex, container, proto, configData);
+        configData = m_configurator->processConfigWithLocalSettings(serverIndex, container, proto, configData);
 
         qDebug() << "VpnConnection::createVpnConfiguration: using saved config for" << ProtocolProps::protoToString(proto);
     }
     else {
         qDebug() << "VpnConnection::createVpnConfiguration: gen new config for" << ProtocolProps::protoToString(proto);
-        configData = VpnConfigurator::genVpnProtocolConfig(credentials,
+        configData = m_configurator->genVpnProtocolConfig(credentials,
             container, containerConfig, proto, &e);
 
         QString configDataBeforeLocalProcessing = configData;
 
-        configData = VpnConfigurator::processConfigWithLocalSettings(serverIndex, container, proto, configData);
+        configData = m_configurator->processConfigWithLocalSettings(serverIndex, container, proto, configData);
 
 
         if (errorCode && e) {
@@ -271,7 +275,7 @@ QJsonObject VpnConnection::createVpnConfiguration(int serverIndex,
     Proto proto = ContainerProps::defaultProtocol(container);
     vpnConfiguration[config_key::vpnproto] = ProtocolProps::protoToString(proto);
 
-    auto dns = VpnConfigurator::getDnsForConfig(serverIndex);
+    auto dns = m_configurator->getDnsForConfig(serverIndex);
 
     vpnConfiguration[config_key::dns1] = dns.first;
     vpnConfiguration[config_key::dns2] = dns.second;
@@ -345,7 +349,7 @@ void VpnConnection::connectToVpn(int serverIndex,
     connect(m_vpnProtocol.data(), SIGNAL(connectionStateChanged(VpnProtocol::VpnConnectionState)), this, SLOT(onConnectionStateChanged(VpnProtocol::VpnConnectionState)));
     connect(m_vpnProtocol.data(), SIGNAL(bytesChanged(quint64, quint64)), this, SLOT(onBytesChanged(quint64, quint64)));
 
-    ServerController::disconnectFromHost(credentials);
+    m_serverController->disconnectFromHost(credentials);
 
     e = m_vpnProtocol.data()->start();
     if (e) emit VpnProtocol::Error;

client/vpnconnection.h

@@ -14,6 +14,9 @@
 #include "core/ipcclient.h"
 #endif
 
+class VpnConfigurator;
+class ServerController;
+
 using namespace amnezia;
 
 class VpnConnection : public QObject
@@ -21,7 +24,9 @@ class VpnConnection : public QObject
     Q_OBJECT
 
 public:
-    explicit VpnConnection(std::shared_ptr<Settings> settings, QObject* parent = nullptr);
+    explicit VpnConnection(std::shared_ptr<Settings> settings,
+        std::shared_ptr<VpnConfigurator> configurator,
+        std::shared_ptr<ServerController> serverController, QObject* parent = nullptr);
     ~VpnConnection() override;
 
     static QString bytesPerSecToText(quint64 bytes);
@@ -74,6 +79,9 @@ protected:
 
 private:
     std::shared_ptr<Settings> m_settings;
+    std::shared_ptr<VpnConfigurator> m_configurator;
+    std::shared_ptr<ServerController> m_serverController;
+
     QJsonObject m_vpnConfiguration;
     QJsonObject m_routeMode;
     QString m_remoteAddress;