setup.h

#ifndef QTDATASYNC_SETUP_H
#define QTDATASYNC_SETUP_H

#include <functional>
#include <ratio>

#include <QtCore/qobject.h>
#include <QtCore/qlogging.h>
#include <QtCore/qurl.h>
class QLockFile;

#include <QtNetwork/qsslconfiguration.h>

#include "QtDataSync/qtdatasync_global.h"
#include "QtDataSync/exception.h"
#include "QtDataSync/remoteconfig.h"

class QJsonSerializer;

namespace QtDataSync {

template<typename TRatio>
Q_DECL_CONSTEXPR inline int ratioBytes(intmax_t value);
Q_DECL_CONSTEXPR inline int KB(intmax_t value);
Q_DECL_CONSTEXPR inline int MB(intmax_t value);
Q_DECL_CONSTEXPR inline int GB(intmax_t value);

#if __cplusplus >= 201402L
namespace literals {

Q_DECL_CONSTEXPR inline int operator "" _kb(unsigned long long x) {
    return KB(static_cast<intmax_t>(x));
}

Q_DECL_CONSTEXPR inline int operator "" _mb(unsigned long long x) {
    return MB(static_cast<intmax_t>(x));
}

Q_DECL_CONSTEXPR inline int operator "" _gb(unsigned long long x) {
    return GB(static_cast<intmax_t>(x));
}

}
#endif

class ConflictResolver;
class KeyStore;

class SetupPrivate;
class Q_DATASYNC_EXPORT Setup
{
    Q_GADGET
    Q_DISABLE_COPY(Setup)

    
    Q_PROPERTY(QString localDir READ localDir WRITE setLocalDir RESET resetLocalDir)
    Q_PROPERTY(QUrl remoteObjectHost READ remoteObjectHost WRITE setRemoteObjectHost RESET resetRemoteObjectHost)
    Q_PROPERTY(QJsonSerializer* serializer READ serializer WRITE setSerializer RESET resetSerializer)
    Q_PROPERTY(QtDataSync::ConflictResolver* conflictResolver READ conflictResolver WRITE setConflictResolver RESET resetConflictResolver)
    Q_PROPERTY(FatalErrorHandler fatalErrorHandler READ fatalErrorHandler WRITE setFatalErrorHandler RESET resetFatalErrorHandler)
    Q_PROPERTY(int cacheSize READ cacheSize WRITE setCacheSize RESET resetCacheSize)
    Q_PROPERTY(bool persistDeletedVersion READ persistDeletedVersion WRITE setPersistDeletedVersion RESET resetPersistDeletedVersion)
    Q_PROPERTY(SyncPolicy syncPolicy READ syncPolicy WRITE setSyncPolicy RESET resetSyncPolicy)
    Q_PROPERTY(QSslConfiguration sslConfiguration READ sslConfiguration WRITE setSslConfiguration RESET resetSslConfiguration)
    Q_PROPERTY(QtDataSync::RemoteConfig remoteConfiguration READ remoteConfiguration WRITE setRemoteConfiguration RESET resetRemoteConfiguration)
    Q_PROPERTY(QString keyStoreProvider READ keyStoreProvider WRITE setKeyStoreProvider RESET resetKeyStoreProvider)
    Q_PROPERTY(SignatureScheme signatureScheme READ signatureScheme WRITE setSignatureScheme RESET resetSignatureScheme)
    Q_PROPERTY(QVariant signatureKeyParam READ signatureKeyParam WRITE setSignatureKeyParam RESET resetSignatureKeyParam)
    Q_PROPERTY(EncryptionScheme encryptionScheme READ encryptionScheme WRITE setEncryptionScheme RESET resetEncryptionScheme)
    Q_PROPERTY(QVariant encryptionKeyParam READ encryptionKeyParam WRITE setEncryptionKeyParam RESET resetEncryptionKeyParam)
    Q_PROPERTY(CipherScheme cipherScheme READ cipherScheme WRITE setCipherScheme RESET resetCipherScheme)
    Q_PROPERTY(qint32 cipherKeySize READ cipherKeySize WRITE setCipherKeySize RESET resetCipherKeySize) //MAJOR make uint
    Q_PROPERTY(EventMode eventLoggingMode READ eventLoggingMode WRITE setEventLoggingMode RESET resetEventLoggingMode REVISION 2)

public:
    using FatalErrorHandler = std::function<void (QString, QString, const QMessageLogContext &)>;

    enum SyncPolicy {
        PreferChanged, 
        PreferDeleted 
    };
    Q_ENUM(SyncPolicy)

    
    enum SignatureScheme {
        RSA_PSS_SHA3_512, 
        ECDSA_ECP_SHA3_512, 
        ECNR_ECP_SHA3_512 
    };
    Q_ENUM(SignatureScheme)

    
    enum EncryptionScheme {
        RSA_OAEP_SHA3_512, 
        ECIES_ECP_SHA3_512 
    };
    Q_ENUM(EncryptionScheme)

    
    enum CipherScheme {
        AES_EAX, 
        AES_GCM, 
        TWOFISH_EAX, 
        TWOFISH_GCM, 
        SERPENT_EAX, 
        SERPENT_GCM, 
        IDEA_EAX, 
    };
    Q_ENUM(CipherScheme)

    
    enum EllipticCurve {
        secp112r1,
        secp128r1,
        secp160r1,
        secp192r1,
        secp224r1,
        secp256r1,
        secp384r1,
        secp521r1,

        brainpoolP160r1,
        brainpoolP192r1,
        brainpoolP224r1,
        brainpoolP256r1,
        brainpoolP320r1,
        brainpoolP384r1,
        brainpoolP512r1,

        secp112r2,
        secp128r2,
        secp160r2,

        secp160k1,
        secp192k1,
        secp224k1,
        secp256k1
    };
    Q_ENUM(EllipticCurve)

    
    enum class EventMode {
        Unchanged, 
        Enabled, 
        Disabled 
    };
    Q_ENUM(EventMode)

    
    static bool exists(const QString &name = DefaultSetup);
    static void setCleanupTimeout(unsigned long timeout);
    static void removeSetup(const QString &name, bool waitForFinished = false);

    static QStringList keystoreProviders();
    static QStringList availableKeystores();
    static bool keystoreAvailable(const QString &provider);
    static QString defaultKeystoreProvider();
    static KeyStore *loadKeystore(QObject *parent = nullptr, const QString &setupName = DefaultSetup);
    static KeyStore *loadKeystore(const QString &provider, QObject *parent = nullptr, const QString &setupName = DefaultSetup);

    Setup();
    Setup(Setup &&other) noexcept;
    Setup &operator=(Setup &&other) noexcept;
    ~Setup();

    QString localDir() const;
    QUrl remoteObjectHost() const;
    QJsonSerializer *serializer() const;
    ConflictResolver* conflictResolver() const;
    FatalErrorHandler fatalErrorHandler() const;
    int cacheSize() const;
    bool persistDeletedVersion() const;
    SyncPolicy syncPolicy() const;
    QSslConfiguration sslConfiguration() const;
    RemoteConfig remoteConfiguration() const;
    QString keyStoreProvider() const;
    SignatureScheme signatureScheme() const;
    QVariant signatureKeyParam() const;
    EncryptionScheme encryptionScheme() const;
    QVariant encryptionKeyParam() const;
    CipherScheme cipherScheme() const;
    qint32 cipherKeySize() const;
    EventMode eventLoggingMode() const;

    Setup &setLocalDir(QString localDir);
    Setup &setRemoteObjectHost(QUrl remoteObjectHost);
    Setup &setSerializer(QJsonSerializer *serializer);
    Setup &setConflictResolver(ConflictResolver* conflictResolver);
    Setup &setFatalErrorHandler(const FatalErrorHandler &fatalErrorHandler);
    Setup &setCacheSize(int cacheSize);
    Setup &setPersistDeletedVersion(bool persistDeletedVersion);
    Setup &setSyncPolicy(SyncPolicy syncPolicy);
    Setup &setSslConfiguration(QSslConfiguration sslConfiguration);
    Setup &setRemoteConfiguration(RemoteConfig remoteConfiguration);
    Setup &setKeyStoreProvider(QString keyStoreProvider);
    Setup &setSignatureScheme(SignatureScheme signatureScheme);
    Setup &setSignatureKeyParam(QVariant signatureKeyParam);
    Setup &setEncryptionScheme(EncryptionScheme encryptionScheme);
    Setup &setEncryptionKeyParam(QVariant encryptionKeyParam);
    Setup &setCipherScheme(CipherScheme cipherScheme);
    Setup &setCipherKeySize(qint32 cipherKeySize);
    Setup &setEventLoggingMode(EventMode eventLoggingMode);

    Setup &resetLocalDir();
    Setup &resetRemoteObjectHost();
    Setup &resetSerializer();
    Setup &resetConflictResolver();
    Setup &resetFatalErrorHandler();
    Setup &resetCacheSize();
    Setup &resetPersistDeletedVersion();
    Setup &resetSyncPolicy();
    Setup &resetSslConfiguration();
    Setup &resetRemoteConfiguration();
    Setup &resetKeyStoreProvider();
    Setup &resetSignatureScheme();
    Setup &resetSignatureKeyParam();
    Setup &resetEncryptionScheme();
    Setup &resetEncryptionKeyParam();
    Setup &resetCipherScheme();
    Setup &resetCipherKeySize();
    Setup &resetEventLoggingMode();

    Setup &setAccount(const QJsonObject &importData, bool keepData = false, bool allowFailure = false);
    Setup &setAccount(const QByteArray &importData, bool keepData = false, bool allowFailure = false);
    Setup &setAccountTrusted(const QJsonObject &importData, const QString &password, bool keepData = false, bool allowFailure = false);
    Setup &setAccountTrusted(const QByteArray &importData, const QString &password, bool keepData = false, bool allowFailure = false);

    void create(const QString &name = DefaultSetup);
    bool createPassive(const QString &name = DefaultSetup, int timeout = 30000);

private:
    QScopedPointer<SetupPrivate> d;
};

class Q_DATASYNC_EXPORT SetupException : public Exception
{
protected:
    SetupException(const QString &setupName, const QString &message);
    SetupException(const SetupException * const other);
};

class Q_DATASYNC_EXPORT SetupExistsException : public SetupException
{
public:
    SetupExistsException(const QString &setupName);

    QByteArray className() const noexcept override;
    void raise() const final;
    QException *clone() const final;

protected:
    SetupExistsException(const SetupExistsException * const other);
};

class Q_DATASYNC_EXPORT SetupLockedException : public SetupException
{
public:
    SetupLockedException(QLockFile *lockfile, const QString &setupName);

    qint64 pid() const;
    QString hostname() const;
    QString appname() const;

    QByteArray className() const noexcept override;
    QString qWhat() const override;
    void raise() const final;
    QException *clone() const final;

protected:
    SetupLockedException(const SetupLockedException *cloneFrom);

    qint64 _pid = -1;
    QString _hostname;
    QString _appname;
};

// ------------- Generic Implementation -------------

template<typename TRatio>
Q_DECL_CONSTEXPR inline int ratioBytes(intmax_t value)
{
    return static_cast<int>(qMin(TRatio().num * value, static_cast<intmax_t>(INT_MAX)));
}

Q_DECL_CONSTEXPR inline int KB(intmax_t value)
{
    return ratioBytes<std::kilo>(value);
}

Q_DECL_CONSTEXPR inline int MB(intmax_t value)
{
    return ratioBytes<std::mega>(value);
}

Q_DECL_CONSTEXPR inline int GB(intmax_t value)
{
    return ratioBytes<std::giga>(value);
}

}

#endif // QTDATASYNC_SETUP_H