abstractnode.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018-2025 QuasarApp.
 * Distributed under the lgplv3 software license, see the accompanying
 * Everyone is permitted to copy and distribute verbatim copies
 * of this license document, but changing it is not allowed.
*/
 
 
#ifndef ABSTRACTNODE_H
#define ABSTRACTNODE_H
 
#include "abstractnodeinfo.h"
#include "ping.h"
 
#ifdef USE_HEART_SSL
#include <QSslConfiguration>
#include <easyssl/icertificate.h>
#endif
 
#include <QAbstractSocket>
#include <QFutureWatcher>
#include <QMutex>
#include <QSharedPointer>
#include <QTcpServer>
#include <QThreadPool>
#include <QTimer>
#include <softdelete.h>
#include "abstractdata.h"
#include "workstate.h"
#include "package.h"
#include "heart_global.h"
#include <iparser.h>
 
namespace QH {
 
class DataSender;
class ReceiveData;
class SocketFactory;
class AsyncLauncher;
class TaskScheduler;
class AbstractTask;
class SslSocket;
class APIVersionParser;
 
namespace PKG {
class ErrorData;
}

enum class SslMode {
    NoSSL,
#ifdef USE_HEART_SSL

    InitFromSystem,
    InitSelfSigned
#endif
};

enum class AddNodeError {
    UnknownError,
    HostNotFound,
    RegisterSocketFailed
};
 
#define CRITICAL_ERROOR  -50
#define LOGICK_ERROOR    -20
#define REQUEST_ERROR    -5
#define NOTSUPPORT_ERROR -1
 
#define BIG_DATA_HASH_ID 0xFFFF
 
class Abstract;

class HEARTSHARED_EXPORT AbstractNode : public QTcpServer, public SoftDelete
{
    Q_OBJECT
 
public:

    enum NodeType: int {
        Client = 0,

        Node = 1,

        Server = 2
    };

    AbstractNode(QObject * ptr = nullptr);
    ~AbstractNode() override;

    virtual NodeType nodeType() const = 0;

    virtual bool run(const QString& addres, unsigned short port);

    QSharedPointer<QH::iParser> selectParser(unsigned short cmd,
                                             AbstractNodeInfo *sender) const;

    QSharedPointer<QH::iParser> selectParser(const QString& type,
                                             int version) const;

    QSharedPointer<QH::iParser> selectParser(const QString& type,
                                             AbstractNodeInfo *sender) const;

    virtual void stop();

    virtual AbstractNodeInfo* getInfoPtr(const HostAddress &id);

    virtual const AbstractNodeInfo* getInfoPtr(const HostAddress &id) const;

    virtual void ban(const HostAddress& target);

    virtual void unBan(const HostAddress& target);

    virtual unsigned int sendData(const PKG::AbstractData *resp,  const HostAddress& address,
                                  const Header *req = nullptr);

    virtual unsigned int sendData(const PKG::AbstractData *resp, const AbstractNodeInfo *node,
                                  const Header *req = nullptr);

    bool addNode(const HostAddress &address);

    bool addNode(const HostAddress &address,
                 const std::function<void(QH::AbstractNodeInfo *)>& action,
                 NodeCoonectionStatus status = NodeCoonectionStatus::Connected);

    bool addNode(const QString &domain, unsigned short port,
                 const std::function<void(QH::AbstractNodeInfo *)>& action = nullptr,
                 NodeCoonectionStatus status = NodeCoonectionStatus::Connected);

    bool removeNode(const HostAddress& nodeAdderess);

    bool removeNode(AbstractNodeInfo* node);

    HostAddress address() const;
 
#ifdef USE_HEART_SSL

    QSslConfiguration getSslConfig() const;
#endif
    SslMode getMode() const;

    virtual WorkState getWorkState() const;

    int connectionsCount() const;

    int confirmendCount() const;

    bool ping( const HostAddress& address);

    static QThread *mainThreadID();

    bool sheduleTask(const QSharedPointer<AbstractTask>& task);

    void removeTask(int taskId);

    int sheduledTaskCount() const;

    virtual void badRequest(const HostAddress &address, const Header &req,
                            const PKG::ErrorData& err, qint8 diff = REQUEST_ERROR);
 
#ifdef USE_HEART_SSL

    const QList<QSslError> &ignoreSslErrors() const;
#endif

    bool addApiParser(const QSharedPointer<iParser>& parser);

    bool fSendBadRequestErrors() const;

    void setSendBadRequestErrors(bool value);

    bool fCloseConnectionAfterBadRequest() const;

    void setCloseConnectionAfterBadRequest(bool value);
 
signals:
    void requestError(unsigned char code, QString msg);

    void sigNoLongerSupport(const QString& ApiKey, unsigned short version);
 
 
protected:
 
#ifdef USE_HEART_SSL

    void setIgnoreSslErrors(const QList<QSslError> &newIgnoreSslErrors);

    virtual QSslConfiguration selfSignedSslConfiguration( const EasySSL::SslSrtData& data = {});
#endif

    virtual AbstractNodeInfo* createNodeInfo(QAbstractSocket *socket,
                                             const HostAddress *clientAddress = nullptr) const;

    virtual bool registerSocket(QAbstractSocket *socket, const HostAddress* address = nullptr);

    virtual bool sendPackage(const Package &pkg, QAbstractSocket *target) const;

    virtual QString getWorkStateString() const;

    virtual QString connectionState() const;

    QList<HostAddress> banedList() const;
 
    // TO-DO Need to add new method fo collect banned addresses for exmaple use the mask.
    // See Task https://github.com/QuasarApp/Heart/issues/13
    virtual bool isBanned(const AbstractNodeInfo *socket) const;

    void incomingConnection(qintptr handle) override final;

    virtual bool changeTrust(const HostAddress& id, int diff);
 
 
#ifdef USE_HEART_SSL

    bool useSelfSignedSslConfiguration(const EasySSL::SslSrtData& crtData);

    bool useSystemSslConfiguration(QSslConfiguration config = QSslConfiguration::defaultConfiguration());

    bool disableSSL();
#endif

    QHash<HostAddress, AbstractNodeInfo *> connections() const;

    virtual void nodeConfirmend(AbstractNodeInfo *node);

    virtual void nodeConnected(AbstractNodeInfo *node);

    virtual void nodeDisconnected(AbstractNodeInfo *node);
 
    void prepareForDelete() override;

    QSharedPointer<PKG::AbstractData> prepareData(const Package& pkg, AbstractNodeInfo *sender) const;

    QList<HostAddress> connectionsList() const;

    QList<HostAddress> activeConnectionsList() const;

    virtual void addNodeFailed(AddNodeError error);

    virtual void nodeAddedSucessful(AbstractNodeInfo* node);

    template<class ApiType, class ... Args >
    QSharedPointer<ApiType> addApiParserNative(Args&&... arg) {
        return addApiParserImpl(QSharedPointer<ApiType>::create(this, std::forward<Args>(arg)...)).template staticCast<ApiType>();
    }

    template<class ApiType, class ... Args >
    const QSharedPointer<iParser> & addApiParser(Args&&... arg) {
        return addApiParserImpl(QSharedPointer<ApiType>::create(this, std::forward<Args>(arg)...));
    }
 
protected slots:
    virtual void receivePing(const QSharedPointer<QH::PKG::Ping>& ping);;

    virtual void nodeErrorOccured(QH::AbstractNodeInfo *nodeInfo,
                                  QAbstractSocket::SocketError errorCode,
                                  QString errorString);
 
#ifdef USE_HEART_SSL

    virtual void handleSslErrorOcurred(QH::SslSocket *scket, const QSslError& error);
#endif
 
private slots:
 
    void avelableBytes(QH::AbstractNodeInfo* sender);

    void handleNodeStatusChanged(QH::AbstractNodeInfo* node, QH::NodeCoonectionStatus status);

    void handleWorkerStoped();

    void handleForceRemoveNode(QH::HostAddress node);

    void handleBeginWork(QSharedPointer<QH::AbstractTask> work);
 
#ifdef USE_HEART_SSL

    void handleSslErrorOcurredPrivate(QH::SslSocket *sender, const QList<QSslError> & errors);

    void handleEncrypted(QH::AbstractNodeInfo *node);
 
#endif
 
private:

    const QSharedPointer<iParser> & addApiParserImpl(const QSharedPointer<QH::iParser>& parserObject);
 
    // iParser interface
    ParserResult parsePackage(const QSharedPointer<PKG::AbstractData> &pkg,
                              const Header &pkgHeader,
                              AbstractNodeInfo *sender);

    QSharedPointer<PKG::AbstractData>
    genPackage(unsigned short cmd,
               AbstractNodeInfo *sender) const;

    bool listen(const HostAddress& address = HostAddress::Any);

    void newWork(const Package &pkg, AbstractNodeInfo *sender, const HostAddress &id);

    void checkConfirmendOfNode(AbstractNodeInfo *node);

    void initThreadId() const;

    void initThreadPool();

    void deinitThreadPool();
 
 
    SslMode _mode = SslMode::NoSSL;
#ifdef USE_HEART_SSL
    bool configureSslSocket(AbstractNodeInfo *node, bool fServer);
    QSslConfiguration _ssl;
    QList<QSslError> _ignoreSslErrors;
#endif
    QHash<HostAddress, AbstractNodeInfo*> _connections;
    QHash<HostAddress, ReceiveData*> _receiveData;
 
    DataSender * _dataSender = nullptr;
    AsyncLauncher * _socketWorker = nullptr;
    TaskScheduler *_tasksheduller = nullptr;
    APIVersionParser *_apiVersionParser = nullptr;
 
    QHash<NodeCoonectionStatus,
          QHash<HostAddress,
                std::function<void (QH::AbstractNodeInfo *)>>> _connectActions;
 
    QSet<QFutureWatcher <bool>*> _workers;
    bool _sendBadRequestErrors = true;
    bool _closeConnectionAfterBadRequest = false;
 
    mutable QMutex _connectionsMutex;
    mutable QMutex _confirmNodeMutex;
    mutable QMutex _threadPoolMutex;
    mutable QMutex _workersMutex;
 
    QThreadPool *_threadPool = nullptr;
 
    friend class WebSocketController;
    friend class SocketFactory;
    friend class BigDataParser;
    friend class BigDataParserOld;
    friend class AbstractNodeParser;
    friend class AbstractNodeParserOld;
 
 
};
 
}
#endif // ABSTRACTNODE_H