NodeSelector.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/ionet/Node.h"
#include "catapult/ionet/NodeInfo.h"
#include "catapult/utils/ArraySet.h"
#include <random>
 
namespace catapult { namespace ionet { class NodeContainer; } }
 
namespace catapult { namespace extensions {
 
    struct ImportanceDescriptor {
        catapult::Importance Importance;
 
        catapult::Importance TotalChainImportance;
    };
 
    using ImportanceRetriever = std::function<ImportanceDescriptor (const Key&)>;
 
    struct WeightedCandidate {
    public:
        WeightedCandidate(const ionet::Node& node, uint64_t weight)
                : Node(node)
                , Weight(weight)
        {}
 
    public:
        const ionet::Node& Node;
 
        uint64_t Weight;
    };
 
    using WeightedCandidates = std::vector<WeightedCandidate>;
 
    struct NodeSelectionResult {
        ionet::NodeSet AddCandidates;
 
        utils::KeySet RemoveCandidates;
    };
 
    struct NodeAgingConfiguration {
        ionet::ServiceIdentifier ServiceId;
 
        uint32_t MaxConnections;
 
        uint32_t MaxConnectionAge;
    };
 
    struct NodeSelectionConfiguration {
        ionet::ServiceIdentifier ServiceId;
 
        ionet::NodeRoles RequiredRole;
 
        uint32_t MaxConnections;
 
        uint32_t MaxConnectionAge;
    };
 
    enum class WeightPolicy {
        Interactions,
 
        Importance
    };
 
    class WeightPolicyGenerator {
    public:
        WeightPolicyGenerator()
                : m_generator(std::random_device()())
                , m_distr(1, 4)
        {}
 
    public:
        WeightPolicy operator()() {
            return 4 == static_cast<uint32_t>(m_distr(m_generator)) ? WeightPolicy::Importance : WeightPolicy::Interactions;
        }
 
    private:
        std::mt19937 m_generator;
        std::uniform_int_distribution<> m_distr;
    };
 
    uint32_t CalculateWeight(
            const ionet::NodeInteractions& interactions,
            WeightPolicy weightPolicy,
            const supplier<ImportanceDescriptor>& importanceSupplier);
 
    ionet::NodeSet SelectCandidatesBasedOnWeight(
            const WeightedCandidates& candidates,
            uint64_t totalCandidateWeight,
            size_t maxCandidates);
 
    NodeSelectionResult SelectNodes(
            const ionet::NodeContainer& nodes,
            const NodeSelectionConfiguration& config,
            const ImportanceRetriever& importanceRetriever);
 
    utils::KeySet SelectNodesForRemoval(
            const ionet::NodeContainer& nodes,
            const NodeAgingConfiguration& config,
            const ImportanceRetriever& importanceRetriever);
}}