lokinet/llarp/link/link_manager.hpp

#ifndef LLARP_LINK_MANAGER_HPP
#define LLARP_LINK_MANAGER_HPP

#include <link/i_link_manager.hpp>

#include <util/compare_ptr.hpp>
#include <util/thread/threading.hpp>
#include <link/server.hpp>

#include <unordered_map>
#include <set>
#include <atomic>

namespace llarp
{
  struct IRouterContactManager;

  struct LinkManager final : public ILinkManager
  {
   public:
    ~LinkManager() override = default;

    LinkLayer_ptr
    GetCompatibleLink(const RouterContact &rc) const override;

    IOutboundSessionMaker *
    GetSessionMaker() const override;

    bool
    SendTo(const RouterID &remote, const llarp_buffer_t &buf,
           ILinkSession::CompletionHandler completed) override;

    bool
    HasSessionTo(const RouterID &remote) const override;

    void
    PumpLinks() override;

    void
    AddLink(LinkLayer_ptr link, bool inbound = false) override;

    bool
    StartLinks(Logic_ptr logic,
               std::shared_ptr< thread::ThreadPool > worker) override;

    void
    Stop() override;

    void
    PersistSessionUntil(const RouterID &remote, llarp_time_t until) override;

    void
    ForEachPeer(std::function< void(const ILinkSession *, bool) > visit,
                bool randomize = false) const override;

    void
    ForEachPeer(std::function< void(ILinkSession *) > visit) override;

    void
    ForEachInboundLink(
        std::function< void(LinkLayer_ptr) > visit) const override;

    size_t
    NumberOfConnectedRouters() const override;

    size_t
    NumberOfConnectedClients() const override;

    size_t
    NumberOfPendingConnections() const override;

    bool
    GetRandomConnectedRouter(RouterContact &router) const override;

    void
    CheckPersistingSessions(llarp_time_t now) override;

    util::StatusObject
    ExtractStatus() const override;

    void
    Init(IOutboundSessionMaker *sessionMaker);

   private:
    LinkLayer_ptr
    GetLinkWithSessionTo(const RouterID &remote) const;

    std::atomic< bool > stopping;
    mutable util::Mutex _mutex;  // protects m_PersistingSessions

    using LinkSet = std::set< LinkLayer_ptr, ComparePtr< LinkLayer_ptr > >;

    LinkSet outboundLinks;
    LinkSet inboundLinks;

    // sessions to persist -> timestamp to end persist at
    std::unordered_map< RouterID, llarp_time_t, RouterID::Hash >
        m_PersistingSessions GUARDED_BY(_mutex);

    IOutboundSessionMaker *_sessionMaker;
  };

}  // namespace llarp

#endif  // LLARP_LINK_MANAGER_HPP