peer_network.h

Go to the documentation of this file.

#pragma once
 
#include "librats/util/rats_export.h"
#include "librats/core/bytes.h"
#include "librats/wire/frame.h"   // MessageType
#include "librats/peer/peer_id.h"
#include "librats/peer/peer_info.h"
#include "librats/core/address.h"
#include "librats/core/types.h"  // CloseReason
 
#include <cstdint>
#include <functional>
#include <string>
#include <vector>
 
namespace librats {
 
class Peer;
 
class RATS_API PeerNetwork {
public:
    virtual ~PeerNetwork() = default;
    using MessageHandler = std::function<void(const Peer&, ByteView)>;
 
    using PeerEventHandler       = std::function<void(const Peer&)>;
    using PeerDisconnectHandler  = std::function<void(const PeerId&, CloseReason)>;
    using DialFailedHandler      = std::function<void(const Address&)>;
 
    virtual const PeerId&       local_id() const = 0;
    virtual uint16_t            listen_port() const = 0;     
    virtual uint8_t             transports() const { return PeerTransportTcp; }
    virtual const std::string&  protocol() const = 0;        
    virtual void                connect(const Address& address) = 0;  
    virtual bool                send(const PeerId& to, MessageType type, ByteView payload) = 0;
    virtual bool                broadcast(MessageType type, ByteView payload) = 0;
    virtual std::vector<PeerId>  connected_peers() const = 0;
    virtual std::vector<PeerInfo> peers() const = 0;  
    virtual void                on(MessageType type, MessageHandler handler) = 0;
 
    // Lifecycle hooks. Multiple subsystems (and the application) may subscribe;
    // all run on a reactor thread. Register before start().
    virtual void                on_peer_connected(PeerEventHandler handler) = 0;
    virtual void                on_peer_disconnected(PeerDisconnectHandler handler) = 0;
    // An outbound dial WE initiated closed before it ever established (TCP connect
    // refused/timed out, or the handshake failed). Carries the address we dialed.
    // There is no on_peer_disconnected for a connection that never came up, so this
    // is the only signal a redial policy gets that an in-flight dial has resolved.
    virtual void                on_dial_failed(DialFailedHandler handler) = 0;
    virtual void                on_peer_writable(PeerEventHandler /*handler*/) {}
    virtual bool                peer_writable(const PeerId& /*id*/) const { return true; }
};
 
struct NodeContext;  // node/node_context.h — bundles network + events + services
 
class RATS_API Subsystem {
public:
    virtual ~Subsystem() = default;
    virtual void attach(NodeContext& ctx) = 0;
    virtual void start() = 0;
    virtual void stop() = 0;
};
 
} // namespace librats