volume_detector.hpp

Go to the documentation of this file.

#pragma once
 
// MountedVolumeListChangeDetector — monitors filesystem for volume mount/unmount.
// ScopedLowPowerModeDisabler is in coalesced_updater.hpp.
// LockingCoalescedUpdater is in coalesced_updater.hpp.
// NetworkServiceDiscovery — mDNS-based service discovery.
 
#include <string>
#include <string_view>
#include <vector>
#include <functional>
#include <atomic>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <unordered_map>
 
namespace pulp::events {

class MountedVolumeListChangeDetector {
public:
    MountedVolumeListChangeDetector() = default;
    ~MountedVolumeListChangeDetector();

    void start(std::chrono::milliseconds interval = std::chrono::seconds(2));

    void stop();

    bool is_running() const { return running_.load(); }

    static std::vector<std::string> get_mounted_volumes();

    std::function<void(const std::vector<std::string>& volumes)> on_change;
 
private:
    std::atomic<bool> running_{false};
    std::thread thread_;
    std::mutex mutex_;
    std::condition_variable cv_;
    std::vector<std::string> last_volumes_;
};

class NetworkServiceDiscovery {
public:
    using TxtRecords = std::unordered_map<std::string, std::string>;
 
    struct Service {
        std::string name;
        std::string type;      // e.g., "_http._tcp"
        std::string hostname;
        std::string address;
        uint16_t port = 0;
        TxtRecords txt_records;
    };

    class Backend {
    public:
        virtual ~Backend() = default;
        virtual void browse(std::string_view service_type,
                            NetworkServiceDiscovery& owner) = 0;
        virtual void stop() = 0;
        virtual bool register_service(std::string_view name,
                                      std::string_view type,
                                      uint16_t port) = 0;
        virtual bool register_service(std::string_view name,
                                      std::string_view type,
                                      uint16_t port,
                                      const TxtRecords& /*txt_records*/) {
            return register_service(name, type, port);
        }
        virtual void unregister_service() = 0;
    };
 
    NetworkServiceDiscovery() = default;
    ~NetworkServiceDiscovery();

    void install_backend(std::unique_ptr<Backend> backend);

    bool has_backend() const noexcept { return backend_ != nullptr; }

    void browse(std::string_view service_type);

    void stop();

    bool register_service(std::string_view name, std::string_view type, uint16_t port);

    bool register_service(std::string_view name,
                          std::string_view type,
                          uint16_t port,
                          const TxtRecords& txt_records);

    void unregister_service();

    void notify_service_found(const Service& svc);

    void notify_service_lost(const Service& svc);

    std::function<void(const Service&)> on_service_found;

    std::function<void(const Service&)> on_service_lost;

    const std::vector<Service>& discovered() const { return services_; }
 
private:
    std::vector<Service> services_;
    std::atomic<bool> running_{false};
    std::thread browse_thread_;
    std::unique_ptr<Backend> backend_;
};

class LockingCoalescedUpdater {
public:
    virtual ~LockingCoalescedUpdater() = default;

    void trigger_and_wait();

    virtual void on_update() = 0;
 
private:
    std::atomic<bool> pending_{false};
    std::mutex mutex_;
    std::condition_variable cv_;
};
 
}  // namespace pulp::events