Hive.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "protodefinitions/Hermes.pb.h"
 
#include <functional>
#include <memory>
#include <chrono>
#include <vector>
#include <mutex>
 
namespace HermesSDK
{
    // Set up a Doxygen group.
    typedef std::function<void(Hermes::Protocol::HiveNode _node)> hiveNodeCallback;
 
    class Hive
    {
 
    private:
        //Limit according to https://docs.microsoft.com/en-us/windows/win32/api/processenv/nf-processenv-getenvironmentvariablew
        static const unsigned long s_BufferSize = 65535;
 
    public:
        Hive(hiveNodeCallback& _onNodeFound, hiveNodeCallback& _onLocalNodeFound, hiveNodeCallback& _onNodeRemoved);
        ~Hive();
 
        // delete the copy constructor and assignment operator to prevent this class from accidentally being copied
        Hive(const Hive&) = delete;
        Hive& operator=(const Hive&) = delete;
 
        void Configure(std::string _name, bool _useLoopback = true, int _beaconPort = (int)Hermes::Protocol::DefaultPorts::HivePort, int _broadcastIntervalInSeconds = 1, int _deadNodeTimeoutInSeconds = 10);
        void Join();
        void Stop();
        static void CleanEnvironmentVariables();
        static void CleanEnvironmentVariable(std::wstring p_EnvironmentVariable);
        static bool DoesEnvironmentVariableExist(std::wstring p_EnvironmentVariable);
        static std::unique_ptr<Hive> FindCoordinator(std::string _name, int _beaconPort, hiveNodeCallback& _onNodeFound, hiveNodeCallback& _onLocalNodeFound, hiveNodeCallback& _onNodeRemoved, bool _useLoopback);
        static std::unique_ptr<Hive> FindLocalCoordinator(std::string _name, int _beaconPort, hiveNodeCallback& _onNodeFound, hiveNodeCallback& _onLocalNodeFound, hiveNodeCallback& _onNodeRemoved);
        static std::unique_ptr<Hive> FindNetworkCoordinator(std::string _name, int _beaconPort, hiveNodeCallback& _onNodeFound, hiveNodeCallback& _onLocalNodeFound, hiveNodeCallback& _onNodeRemoved);
        
    private:
        static std::unique_ptr<Hermes::Protocol::HiveNode> tryParseHiveNodeFromBytes(unsigned char*_data, int _size);
        void InternalStart();
        void NodeDiscovered(Hermes::Protocol::HiveNode _node);
 
        struct HiveNodeTimeStamped {
            Hermes::Protocol::HiveNode node;
            std::chrono::system_clock::time_point lastseen;
        };
        std::vector<HiveNodeTimeStamped> m_nodes; // for a map, you need to implement your own comparator or hash function, gave a lot of trouble
        std::mutex m_nodes_mutex;
 
        //Threads
        void subscriberThreadFunction();
        void nodeCleanupThreadFunction();
        std::unique_ptr<std::thread>    m_subscriberThread;
        std::unique_ptr<std::thread>    m_nodeCleanupThread;
 
        //Callbacks
        hiveNodeCallback& m_anyNodeFoundCallback;
        hiveNodeCallback& m_localNodeFoundCallback;
        hiveNodeCallback& m_nodeRemovedCallback;
 
        bool                    m_running = false;
 
        bool m_isConfigured = false;
        std::string m_name = "N/A";
        int m_beaconPort = 0;
        std::chrono::seconds m_deadNodeTimeout = std::chrono::seconds(2);
        int m_broadcastIntervalInSeconds = 1;
 
        std::vector<std::string> m_localIpAddresses;
    };
 
    // Close the Doxygen group.
}