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;
    QThread *_senderThread = 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