swarm_manager.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004-2026 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 "routing_table.h"
#include "swarm_protocol.h"
 
#include <memory>
 
namespace jami {
 
using namespace swarm_protocol;
 
class SwarmManager : public std::enable_shared_from_this<SwarmManager>
{
    using ChannelCb = std::function<bool(const std::shared_ptr<dhtnet::ChannelSocketInterface>&)>;
    using NeedSocketCb = std::function<void(const std::string&, ChannelCb&&)>;
    using ToConnectCb = std::function<bool(const NodeId&)>;
    using OnConnectionChanged = std::function<void(bool ok)>;
 
public:
    explicit SwarmManager(const NodeId&, const std::mt19937_64& rand, ToConnectCb&& toConnectCb);
    ~SwarmManager();
 
    NeedSocketCb needSocketCb_;
 
    std::weak_ptr<SwarmManager> weak() { return weak_from_this(); }
 
    const NodeId& getId() const { return id_; }
 
    bool setKnownNodes(const std::vector<NodeId>& known_nodes);
 
    void setMobileNodes(const std::vector<NodeId>& mobile_nodes);
 
    void addChannel(const std::shared_ptr<dhtnet::ChannelSocketInterface>& channel);
 
    void removeNode(const NodeId& nodeId);
 
    void changeMobility(const NodeId& nodeId, bool isMobile);
 
    bool isConnected() const;
 
    std::vector<NodeId> getAllNodes() const;
 
    std::vector<NodeId> getConnectedNodes() const;
 
    std::vector<std::map<std::string, std::string>> getRoutingTableInfo() const;
 
    unsigned getActiveNodesCount() const { return routing_table.getActiveNodesCount(); }
 
    void deleteNode(const std::vector<NodeId>& nodes);
 
    // For tests
 
    RoutingTable& getRoutingTable() { return routing_table; };
 
    std::list<Bucket>& getBuckets() { return routing_table.getBuckets(); };
 
    void shutdown();
 
    void restart();
 
    void display()
    {
        JAMI_DEBUG("SwarmManager {:s} has {:d} nodes in table [P = {}]",
                   getId().to_c_str(),
                   routing_table.getNodeCount(),
                   isMobile_);
        // print nodes of routingtable
        for (auto& bucket : routing_table.getBuckets()) {
            for (auto& node : bucket.getNodes()) {
                JAMI_DEBUG("Node {:s}", node.first.toString());
            }
        }
    }
 
    /*
     * Callback for connection changed
     * @param cb
     */
    void onConnectionChanged(OnConnectionChanged cb) { onConnectionChanged_ = std::move(cb); }
 
    void setMobility(bool isMobile) { isMobile_ = isMobile; }
 
    bool isMobile() const { return isMobile_; }
 
    void maintainBuckets(const std::set<NodeId>& toConnect = {});
 
    bool isConnectedWith(const NodeId& deviceId);
 
    bool isShutdown() { return isShutdown_; };
 
private:
    bool addKnownNode(const NodeId& nodeId);
 
    void addMobileNodes(const NodeId& nodeId);
 
    void sendRequest(const std::shared_ptr<dhtnet::ChannelSocketInterface>& socket,
                     const NodeId& nodeId,
                     Query q,
                     int numberNodes = Bucket::BUCKET_MAX_SIZE);
 
    void sendAnswer(const std::shared_ptr<dhtnet::ChannelSocketInterface>& socket, const Message& msg_);
 
    void receiveMessage(const std::shared_ptr<dhtnet::ChannelSocketInterface>& socket);
 
    void resetNodeExpiry(const asio::error_code& ec,
                         const std::shared_ptr<dhtnet::ChannelSocketInterface>& socket,
                         NodeId node = {});
 
    void tryConnect(const NodeId& nodeId);
 
    void removeNodeInternal(const NodeId& nodeId);
 
    const NodeId id_;
    bool isMobile_ {false};
    std::mt19937_64 rd;
    mutable std::mutex mutex;
    RoutingTable routing_table;
 
    std::atomic_bool isShutdown_ {false};
 
    OnConnectionChanged onConnectionChanged_ {};
 
    ToConnectCb toConnectCb_;
};
 
} // namespace jami