lokinet/llarp/router/outbound_session_maker.hpp

#ifndef LLARP_ROUTER_OUTBOUND_SESSION_MAKER_HPP
#define LLARP_ROUTER_OUTBOUND_SESSION_MAKER_HPP

#include <router/i_outbound_session_maker.hpp>

#include <router/i_rc_lookup_handler.hpp>
#include <util/thread/logic.hpp>
#include <util/thread/threading.hpp>
#include <util/thread/thread_pool.hpp>

#include <profiling.hpp>

#include <unordered_map>
#include <list>
#include <memory>

struct llarp_nodedb;

namespace llarp
{
  struct PendingSession;

  struct ILinkManager;
  struct I_RCLookupHandler;

  struct OutboundSessionMaker final : public IOutboundSessionMaker
  {
    using CallbacksQueue = std::list<RouterCallback>;

   public:
    ~OutboundSessionMaker() override = default;

    bool
    OnSessionEstablished(ILinkSession* session) override;

    void
    OnConnectTimeout(ILinkSession* session) override;

    void
    CreateSessionTo(const RouterID& router, RouterCallback on_result) override EXCLUDES(_mutex);

    void
    CreateSessionTo(const RouterContact& rc, RouterCallback on_result) override EXCLUDES(_mutex);

    bool
    HavePendingSessionTo(const RouterID& router) const override EXCLUDES(_mutex);

    void
    ConnectToRandomRouters(int numDesired) override;

    util::StatusObject
    ExtractStatus() const override;

    bool
    ShouldConnectTo(const RouterID& router) const override EXCLUDES(_mutex);

    void
    Init(
        ILinkManager* linkManager,
        I_RCLookupHandler* rcLookup,
        Profiling* profiler,
        std::shared_ptr<Logic> logic,
        llarp_nodedb* nodedb,
        std::shared_ptr<llarp::thread::ThreadPool> threadpool);

    void
    SetOurRouter(RouterID r)
    {
      us = std::move(r);
    }

    /// always maintain this many connections to other routers
    size_t minConnectedRouters = 4;
    /// hard upperbound limit on the number of router to router connections
    size_t maxConnectedRouters = 6;

   private:
    void
    DoEstablish(const RouterID& router) EXCLUDES(_mutex);

    void
    GotRouterContact(const RouterID& router, const RouterContact& rc) EXCLUDES(_mutex);

    void
    InvalidRouter(const RouterID& router);

    void
    RouterNotFound(const RouterID& router);

    void
    OnRouterContactResult(
        const RouterID& router, const RouterContact* const rc, const RCRequestResult result);

    void
    VerifyRC(const RouterContact rc);

    void
    CreatePendingSession(const RouterID& router) EXCLUDES(_mutex);

    void
    FinalizeRequest(const RouterID& router, const SessionResult type) EXCLUDES(_mutex);

    mutable util::Mutex _mutex;  // protects pendingSessions, pendingCallbacks

    std::unordered_map<RouterID, std::shared_ptr<PendingSession>, RouterID::Hash> pendingSessions
        GUARDED_BY(_mutex);

    std::unordered_map<RouterID, CallbacksQueue, RouterID::Hash> pendingCallbacks
        GUARDED_BY(_mutex);

    ILinkManager* _linkManager = nullptr;
    I_RCLookupHandler* _rcLookup = nullptr;
    Profiling* _profiler = nullptr;
    llarp_nodedb* _nodedb = nullptr;
    std::shared_ptr<Logic> _logic;
    std::shared_ptr<llarp::thread::ThreadPool> _threadpool;
    RouterID us;
  };

}  // namespace llarp

#endif  // LLARP_ROUTER_OUTBOUND_SESSION_MAKER_HPP