discovery/Service.h

Go to the documentation of this file.

#pragma once

#include <swarmio/Mailbox.h>
#include <swarmio/services/discovery/Observer.h>
#include <swarmio/services/discovery/Discoverable.h>
#include <swarmio/services/discovery/DiscoveryAwaiter.h>
#include <set>
#include <map>
#include <mutex>

namespace swarmio::services::discovery 
{
    class SWARMIO_API Service final : public Mailbox  
    {
        private:

            bool _performActiveDiscovery;

            std::map<const Node*, data::discovery::Response> _remotes;

            std::mutex _remotesMutex;

            std::set<Observer*> _observers;

            std::mutex _observersMutex;

            std::set<Discoverable*> _discoverables;

            std::mutex _discoverablesMutex;

            bool _cacheValid = true;

            data::discovery::Response _cachedResponse;

            void HandleDiscoveryRequest(const Node* node, const data::Message* message);

            void CacheDiscoveryResponse(const Node* node, const data::Message* message);

            void HandleInvalidationRequest(const Node* node, const data::Message* message);

        public:

            Service(Endpoint* endpoint, bool performActiveDiscovery)
                : Mailbox(endpoint), _performActiveDiscovery(performActiveDiscovery)
            { 
                FinishConstruction();
            }

            static DiscoveryAwaiter Query(Endpoint* endpoint, const Node* node);

            DiscoveryAwaiter CachedQuery(const Node* node);

            void GlobalQuery();

            std::map<const Node*, data::discovery::Response> GetCachedNodeInformation();

            void RegisterObserver(Observer* observer)
            {
                std::unique_lock<std::mutex> guard(_observersMutex);
                _observers.insert(observer);
            }
            void UnregisterObserver(Observer* observer)
            {
                std::unique_lock<std::mutex> guard(_observersMutex);
                _observers.erase(observer);
            }

            void Invalidate();

            void RegisterDiscoverable(Discoverable* discoverable);

            void UnregisterDiscoverable(Discoverable* discoverable);

            virtual bool ReceiveMessage(const Node* sender, const data::Message* message) override;

            virtual void NodeDidJoin(const Node* node) noexcept override;

            virtual void NodeWillLeave(const Node* node) noexcept override;
    };
}