node.h

#ifndef B0__NODE_H__INCLUDED
#define B0__NODE_H__INCLUDED

#include <b0/user_data.h>
#include <b0/node_state.h>
#include <b0/socket.h>
#include <b0/logger/interface.h>
#include <b0/utils/time_sync.h>

#include <atomic>
#include <set>
#include <string>

#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>

namespace b0
{

namespace logger
{

class Logger;

} // namespace logger


struct NodePrivate;
struct NodePrivate2;


class Node : public logger::LogInterface, public UserData
{
public:
    using logger::LogInterface::log;

    Node(std::string nodeName = "");

    virtual ~Node();

    void setResolverAddress(const std::string &addr);

    virtual void init();

    virtual void shutdown();

    bool shutdownRequested() const;

    virtual void spinOnce();

    virtual void spin(double spinRate = 10.0);

    virtual void cleanup();

protected:
    virtual void startHeartbeatThread();

public:
    void log(LogLevel level, std::string message) const override;

    std::string getName() const;

    NodeState getState() const;

    void * getContext();

    virtual std::string getXPUBSocketAddress() const;

    virtual std::string getXSUBSocketAddress() const;

private:
    void addSocket(Socket *socket);

    void removeSocket(Socket *socket);

public:
    virtual std::string hostname();

    virtual int pid();

    virtual std::string threadID();

    virtual int freeTCPPort();

    virtual void notifyTopic(std::string topic_name, bool reverse, bool active);

    virtual void notifyService(std::string service_name, bool reverse, bool active);

    virtual void announceService(std::string service_name, std::string addr);

    virtual void resolveService(std::string service_name, std::string &addr);

    virtual void setAnnounceTimeout(int timeout = -1);

protected:
    virtual std::string freeTCPAddress();

    virtual void announceNode();

    virtual void notifyShutdown();

    virtual void heartbeatLoop();

public:
    int64_t hardwareTimeUSec() const;

    int64_t timeUSec();

private:
    std::unique_ptr<NodePrivate> private_;
    std::unique_ptr<NodePrivate2> private2_;

protected:
    std::string resolv_addr_;

    logger::LogInterface *p_logger_;

private:
    std::string name_;

    NodeState state_;

    boost::thread::id thread_id_;

    boost::thread heartbeat_thread_;

    std::set<Socket*> sockets_;

    std::string xsub_sock_addr_;

    std::string xpub_sock_addr_;

    static std::atomic<bool> quit_flag_;

    bool shutdown_flag_;

    static bool sigint_handler_setup_;

    TimeSync time_sync_;

    static void signalHandler(int s);

    static void setupSIGINTHandler();

public:
    friend class Socket;
};

} // namespace b0

#endif // B0__NODE_H__INCLUDED