DiarkisP2PBase.h

[詳解]

// © 2019-2024 Diarkis Inc. All rights reserved.
 
#pragma once
 
#include <functional>
#include "diarkis/common.h"
#include "diarkis/modules/p2p.h"
#include "logging/LoggerFactory.h"
#include "protocol.h"
 
using namespace Diarkis::Modules;
 
class Peer
{
   public:
    Peer(std::shared_ptr<IDiarkisP2P> p2p);
    ~Peer();
    void RegisterReadyEvent(std::function<void(void*, const DiarkisReadyEventArgs&)> lambda);
    void RegisterFailEvent(std::function<void(void*, const DiarkisFailEventArgs&)> lambda);
    void RegisterDisconnectEvent(std::function<void(void*, const DiarkisP2PDisconnectEventArgs&)> lambda);
    void RegisterMessageEvent(std::function<void(void*, const DiarkisMessageEventArgs&)> lambda);
    void RegisterExceptionEvent(std::function<void(void*, const DiarkisExceptionEventArgs&)> lambda);
    void RegisterSchedulerAddNotifyEvent(std::function<void(void*, void*)> lambda);
    std::shared_ptr<IDiarkisP2P> GetDiarkisP2P() const { return diarkisP2P_; }
 
   private:
    std::shared_ptr<IDiarkisP2P> diarkisP2P_;
    Diarkis::StdVector<std::function<void()>> eventUnsubscriptions_;
    std::mutex eventMutex_;
};
 
class DIARKIS_API DiarkisP2PBase
{
   public:
    DiarkisP2PBase();
 
    virtual ~DiarkisP2PBase();
 
    virtual void SetupP2P(const std::shared_ptr<IDiarkisUdp>& udp, const std::shared_ptr<LoggerFactory>& loggerFactory, const char* uid);
 
    virtual void ConnectClient(const char* uid, const char** address, size_t addressCount, size_t timeoutInMilliseconds = 5000, bool bBuffering = true);
 
    virtual void ConnectClient(const std::string& uid, const std::vector<std::string>& address, size_t timeoutInMilliseconds = 5000, bool bBuffering = true);
 
    virtual void
    SetEncryptionKeys(bool bEncryption, const uint8_t* key, size_t keySize, const uint8_t* iv, size_t ivSize, const uint8_t* mkey, size_t mkeySize);
 
    virtual void SetEncryptionKeys(bool bEncryption, const std::vector<uint8_t>& key, const std::vector<uint8_t>& iv, const std::vector<uint8_t>& mkey);
 
    virtual uint16_t SendUnicast(const uint8_t* payload, size_t payloadSize, RudpType type, const char* uid);
 
    virtual uint16_t SendUnicast(const uint8_t* payload, size_t payloadSize, RudpType type, const std::string& uid);
 
    virtual uint16_t SendUnicast(const std::vector<uint8_t>& payload, RudpType type, const std::string& uid);
 
    virtual uint16_t SendMulticast(const uint8_t* payload, size_t payloadSize, RudpType type, const char** uids, size_t uidsLen);
 
    virtual uint16_t SendMulticast(const uint8_t* payload, size_t payloadSize, RudpType type, const std::vector<std::string>& uid);
 
    virtual uint16_t SendMulticast(const std::vector<uint8_t>& payload, RudpType type, const std::vector<std::string>& uid);
 
    virtual uint16_t SendBroadcast(const uint8_t* payload, size_t payloadSize, RudpType type);
 
    virtual uint16_t SendBroadcast(const std::vector<uint8_t>& payload, RudpType type);
 
    void Disconnect();
 
    bool Disconnect(const char* uid);
 
    void Update();
 
    void SetSchedulerAddNotifyEvent(std::function<void()> notifyEventFunc);
 
    uint16_t GetConnectedNum();
 
    void GetPeerUids(Diarkis::StdVector<Diarkis::StdString>& output);
 
#if defined(DIARKIS_DEBUG_FEATURES)
 
    void SetDebugP2PFailMode(bool enable);
 
    void SetDebugP2PFailUIDs(const char** UIDList, size_t UIDListSize);
 
    void SetDebugP2PFailUIDs(const std::vector<std::string>& UIDList);
 
    void ClearDebugP2PFailUIDs();
#endif
 
   protected:
    virtual void OnP2PReady(const DiarkisReadyEventArgs& args);
 
    virtual void OnP2PFail(const DiarkisFailEventArgs& args);
 
    virtual void OnP2PDisconnect(const DiarkisP2PDisconnectEventArgs& args);
 
    virtual void OnP2PMessage(const DiarkisMessageEventArgs& args);
 
    virtual void OnP2PException(const DiarkisExceptionEventArgs& args);
 
    void RegisterPeer(const Diarkis::StdString& uid, const std::shared_ptr<Peer>& p2p);
 
    uint64_t UnregisterPeer(const Diarkis::StdString& uid);
 
    Diarkis::StdUnorderedMap<Diarkis::StdString, std::shared_ptr<Peer>> p2pList_;
 
    std::recursive_mutex p2pListMutex_;
 
    std::shared_ptr<IDiarkisUdp> udp_;
 
    std::shared_ptr<LoggerFactory> loggerFactory_;
    
    std::shared_ptr<IDiarkisLogger> logger_;
 
    std::function<void()> schedulerAddNotifyEventFunc_;
 
    Diarkis::StdString ownGlobalAddress_;
 
    Diarkis::StdString myUid_;
 
#if defined(DIARKIS_DEBUG_FEATURES)
 
    std::atomic<bool> debugP2PFailMode_;
 
    Diarkis::StdVector<Diarkis::StdString> debugP2PFailUIDs_;
    std::mutex debugP2PFailUIDsMutex_;
#endif
};