service.hpp

Go to the documentation of this file.

#ifndef CORAL_NET_SERVICE_HPP
#define CORAL_NET_SERVICE_HPP

#include <chrono>
#include <cstdint>
#include <functional>
#include <string>
#include <thread>

#include "zmq.hpp"

#include "coral/config.h"
#include "coral/net.hpp"
#include "coral/net/reactor.hpp"


namespace coral
{
namespace net
{

namespace service
{


class Beacon
{
public:
    Beacon(
        std::uint32_t partitionID,
        const std::string& serviceType,
        const std::string& serviceIdentifier,
        const char* payload,
        std::size_t payloadSize,
        std::chrono::milliseconds period,
        const ip::Address& networkInterface,
        ip::Port port);

    ~Beacon() CORAL_NOEXCEPT;

    Beacon(const Beacon&) = delete;
    Beacon& operator=(const Beacon&) = delete;

    CORAL_DEFINE_DEFAULT_MOVE(Beacon, m_thread, m_socket);

    void Stop();

private:
    std::thread m_thread;
    zmq::socket_t m_socket;
};


class Listener
{
public:
    using NotificationHandler = std::function<void (
        const ip::Address&,
        const std::string&,
        const std::string&,
        const char*,
        std::size_t)>;

    Listener(
        coral::net::Reactor& reactor,
        std::uint32_t partitionID,
        const ip::Endpoint& endpoint,
        NotificationHandler onNotification);

    ~Listener() CORAL_NOEXCEPT;

    Listener(const Listener&) = delete;
    Listener& operator=(const Listener&) = delete;

    Listener(Listener&&) CORAL_NOEXCEPT;

    Listener& operator=(Listener&&) CORAL_NOEXCEPT;

private:
    class Impl;
    std::unique_ptr<Impl> m_impl;
};


class Tracker
{
public:
    using AppearedHandler = std::function<void (
        const ip::Address&,
        const std::string&,
        const std::string&,
        const char*,
        std::size_t)>;

    using PayloadChangedHandler = AppearedHandler;

    using DisappearedHandler =
        std::function<void(const std::string&, const std::string&)>;

    Tracker(
        coral::net::Reactor& reactor,
        std::uint32_t partitionID,
        const ip::Endpoint& endpoint);

    ~Tracker() CORAL_NOEXCEPT;

    Tracker(const Tracker&) = delete;
    Tracker& operator=(const Tracker&) = delete;

    Tracker(Tracker&&) CORAL_NOEXCEPT;

    Tracker& operator=(Tracker&&) CORAL_NOEXCEPT;

    void AddTrackedServiceType(
        const std::string& serviceType,
        std::chrono::milliseconds expiryTime,
        AppearedHandler onAppearance,
        PayloadChangedHandler onPayloadChange,
        DisappearedHandler onDisappearance);

private:
    class Impl;
    std::unique_ptr<Impl> m_impl;
};


}}} // namespace
#endif // header guard