routing_table.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004-2025 Savoir-faire Linux Inc.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
 
#include "manager.h"
 
#include <dhtnet/multiplexed_socket.h>
 
#include <opendht/infohash.h>
 
#include <asio.hpp>
#include <asio/detail/deadline_timer_service.hpp>
 
#include <vector>
#include <memory>
#include <list>
#include <set>
#include <algorithm>
 
using NodeId = dht::PkId;
 
namespace jami {
 
static constexpr const std::chrono::minutes FIND_PERIOD {10};
 
struct NodeInfo
{
    bool isMobile_ {false};
    std::shared_ptr<dhtnet::ChannelSocketInterface> socket {};
    asio::steady_timer refresh_timer {*Manager::instance().ioContext(), FIND_PERIOD};
    NodeInfo() = delete;
    NodeInfo(NodeInfo&&) = default;
    NodeInfo(std::shared_ptr<dhtnet::ChannelSocketInterface> socket_)
        : socket(socket_)
    {}
    NodeInfo(bool mobile, std::shared_ptr<dhtnet::ChannelSocketInterface> socket_)
        : isMobile_(mobile)
        , socket(socket_)
    {}
};
 
class Bucket
 
{
public:
    static constexpr int BUCKET_MAX_SIZE = 2;
 
    Bucket() = delete;
    Bucket(const Bucket&) = delete;
    Bucket(const NodeId&);
 
    bool addNode(const std::shared_ptr<dhtnet::ChannelSocketInterface>& socket);
 
    bool addNode(NodeInfo&& info);
 
    bool removeNode(const NodeId& nodeId);
 
    std::map<NodeId, NodeInfo>& getNodes() { return nodes; }
 
    std::set<NodeId> getNodeIds() const;
 
    bool hasNode(const NodeId& nodeId) const;
 
    bool addKnownNode(const NodeId& nodeId);
 
    void removeKnownNode(const NodeId& nodeId) { known_nodes.erase(nodeId); }
 
    const std::set<NodeId>& getKnownNodes() const { return known_nodes; }
 
    NodeId getKnownNode(unsigned index) const;
 
    bool hasKnownNode(const NodeId& nodeId) const
    {
        return known_nodes.find(nodeId) != known_nodes.end();
    }
 
    bool addMobileNode(const NodeId& nodeId);
 
    void removeMobileNode(const NodeId& nodeId) { mobile_nodes.erase(nodeId); }
 
    bool hasMobileNode(const NodeId& nodeId)
    {
        return mobile_nodes.find(nodeId) != mobile_nodes.end();
    }
 
    const std::set<NodeId>& getMobileNodes() const { return mobile_nodes; }
 
    bool addConnectingNode(const NodeId& nodeId);
 
    void removeConnectingNode(const NodeId& nodeId) { connecting_nodes.erase(nodeId); }
 
    const std::set<NodeId>& getConnectingNodes() const { return connecting_nodes; };
 
    bool hasConnectingNode(const NodeId& nodeId) const
    {
        return connecting_nodes.find(nodeId) != connecting_nodes.end();
    }
 
    bool isEmpty() const { return nodes.empty(); }
 
    bool isFull() const { return nodes.size() == BUCKET_MAX_SIZE; };
 
    std::set<NodeId> getKnownNodesRandom(unsigned numberNodes, std::mt19937_64& rd) const;
 
    NodeId randomId(std::mt19937_64& rd) const
    {
        auto node = getKnownNodesRandom(1, rd);
        return *node.begin();
    }
 
    asio::steady_timer& getNodeTimer(const std::shared_ptr<dhtnet::ChannelSocketInterface>& socket);
 
    bool shutdownNode(const NodeId& nodeId);
 
    void shutdownAllNodes();
 
    void printBucket(unsigned number) const;
 
    void changeMobility(const NodeId& nodeId, bool isMobile);
 
    unsigned getNodesSize() const { return nodes.size(); }
 
    unsigned getKnownNodesSize() const { return known_nodes.size(); }
 
    unsigned getConnectingNodesSize() const { return connecting_nodes.size(); }
 
    NodeId getLowerLimit() const { return lowerLimit_; };
 
    void setLowerLimit(const NodeId& nodeId) { lowerLimit_ = nodeId; }
 
    // For tests
 
    std::set<std::shared_ptr<dhtnet::ChannelSocketInterface>> getNodeSockets() const;
 
private:
    NodeId lowerLimit_;
    std::map<NodeId, NodeInfo> nodes;
    std::set<NodeId> known_nodes;
    std::set<NodeId> connecting_nodes;
    std::set<NodeId> mobile_nodes;
    mutable std::mutex mutex;
};
 
// ####################################################################################################
 
class RoutingTable
{
public:
    RoutingTable();
 
    bool addNode(const std::shared_ptr<dhtnet::ChannelSocketInterface>& socket);
 
    bool addNode(const std::shared_ptr<dhtnet::ChannelSocketInterface>& channel,
                 std::list<Bucket>::iterator& bucket);
 
    bool removeNode(const NodeId& nodeId);
 
    bool hasNode(const NodeId& nodeId);
 
    bool addKnownNode(const NodeId& nodeId);
 
    bool hasKnownNode(const NodeId& nodeId) const
    {
        auto bucket = findBucket(nodeId);
        return bucket->hasKnownNode(nodeId);
    }
 
    bool addMobileNode(const NodeId& nodeId);
 
    void removeMobileNode(const NodeId& nodeId);
 
    bool hasMobileNode(const NodeId& nodeId);
 
    bool addConnectingNode(const NodeId& nodeId);
 
    void removeConnectingNode(const NodeId& nodeId);
 
    bool hasConnectingNode(const NodeId& nodeId) const
    {
        auto bucket = findBucket(nodeId);
        return bucket->hasConnectingNode(nodeId);
    }
 
    std::list<Bucket>::iterator findBucket(const NodeId& nodeId);
 
    inline const std::list<Bucket>::const_iterator findBucket(const NodeId& nodeId) const
    {
        return std::list<Bucket>::const_iterator(
            const_cast<RoutingTable*>(this)->findBucket(nodeId));
    }
 
    std::vector<NodeId> closestNodes(const NodeId& nodeId, unsigned count);
 
    unsigned getRoutingTableSize() const { return buckets.size(); }
 
    unsigned getRoutingTableNodeCount() const
    {
        size_t count = 0;
        for (const auto& b : buckets)
            count += b.getNodesSize();
        return count;
    }
 
    void printRoutingTable() const;
 
    void shutdownNode(const NodeId& nodeId);
 
    void shutdownAllNodes()
    {
        for (auto& bucket : buckets)
            bucket.shutdownAllNodes();
    }
 
    void setId(const NodeId& node) { id_ = node; }
 
    NodeId getId() const { return id_; }
 
    std::list<Bucket>& getBuckets() { return buckets; }
 
    std::vector<NodeId> getNodes() const;
 
    std::vector<NodeId> getKnownNodes() const;
 
    std::vector<NodeId> getMobileNodes() const;
 
    std::vector<NodeId> getConnectingNodes() const;
 
    std::vector<NodeId> getBucketMobileNodes() const;
 
    bool contains(const std::list<Bucket>::iterator& it, const NodeId& nodeId) const;
 
    std::vector<NodeId> getAllNodes() const;
 
    void deleteNode(const NodeId& nodeId);
 
private:
    RoutingTable(const RoutingTable&) = delete;
    RoutingTable& operator=(const RoutingTable&) = delete;
 
    NodeId middle(std::list<Bucket>::iterator& it) const;
 
    unsigned depth(std::list<Bucket>::iterator& bucket) const;
 
    bool split(std::list<Bucket>::iterator& bucket);
 
    NodeId id_;
 
    std::list<Bucket> buckets;
 
    mutable std::mutex mutex_;
};
}; // namespace jami