qkd-link-helper.cc

Go to the documentation of this file.

/*
 * Copyright(c) 2020 DOTFEESA www.tk.etf.unsa.ba
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 *
 *
 * Author: Miralem Mehic <miralem.mehic@ieee.org>
 */
 
#include "ns3/abort.h"
#include "ns3/log.h"
#include "ns3/simulator.h"
#include "ns3/queue.h"
#include "ns3/config.h"
#include "ns3/packet.h"
#include "ns3/object.h"
#include "ns3/names.h"
#include "ns3/internet-module.h"
#include "ns3/random-variable-stream.h"
#include "ns3/trace-helper.h"
#include "ns3/traffic-control-module.h"
 
#include "qkd-link-helper.h"
 
namespace ns3 {
 
NS_LOG_COMPONENT_DEFINE("QKDLinkHelper");
 
QKDLinkHelper::QKDLinkHelper()
{
    m_useRealStorages = false;
    m_controllers.clear();
    m_adjList.clear();
}
 
/**
*   @brief ADD QKDGraph
*   @param  Ptr<Node>       src
*   @param  Ptr<Node>       dst
*/
void
QKDLinkHelper::AddGraphs()
{
    std::cout << "ADD GRAPHS! " << std::endl;
    int32_t nNodes = NodeList::GetNNodes();
    for(int32_t i = 0; i < nNodes; ++i)
    {
        Ptr<Node> node = NodeList::GetNode(i);
        Ptr<QKDKeyManagerSystemApplication> kms;
        uint32_t applicationIndex = 0;
        for(uint32_t i = 0; i < node->GetNApplications(); ++i)
        {
            kms = node->GetApplication(i)->GetObject <QKDKeyManagerSystemApplication>();
            applicationIndex = i;
            if(kms) break;
        }
 
        if(kms)
        {
            QKDGraphManager *QKDGraphManager = QKDGraphManager::getInstance();
 
            std::vector<Ptr<QBuffer> > Qbuffers = kms->GetQBuffersVector();
            for(const auto& buffer : Qbuffers)
            {
                buffer->SetSrcKMSApplicationIndex(applicationIndex);
                NS_LOG_FUNCTION(this << buffer << buffer->GetState() << buffer->GetIndex() );
 
                uint32_t dstNodeId = buffer->GetRemoteNodeId();
                Ptr<Node> dstKmsNode = NodeList::GetNode(dstNodeId);
 
                std::string graphTitle = "";
                if(
                    buffer->GetInstanceTypeId().GetName() == "ns3::SBuffer"
                ){ 
 
                    Ptr<SBuffer> sbuffer = DynamicCast<SBuffer>(buffer);
                    std::string bufferDescription = sbuffer->GetDescription();
                    if(sbuffer->GetType() == SBuffer::LOCAL_SBUFFER)
                    {
                        std::ostringstream temp1;
                        temp1 << "SBUFFER (LOCAL) between " << node->GetId() << " and " << dstKmsNode->GetId();
                        graphTitle = temp1.str();
 
                    }else if(sbuffer->GetType() == SBuffer::RELAY_SBUFFER)
                    {
                        std::ostringstream temp1;
                        temp1 << "SBUFFER (RELAY) between " << node->GetId() << " and " << dstKmsNode->GetId();
                        graphTitle = temp1.str();
                    }else if(sbuffer->GetType() == SBuffer::STREAM_SBUFFER)
                    {
                        std::ostringstream temp1;
                        temp1 << "SBUFFER (STREAM) between " << node->GetId() << " and " << dstKmsNode->GetId();
                        graphTitle = temp1.str();
                    }
 
                    if(!bufferDescription.empty())
                        graphTitle = graphTitle + "_" + bufferDescription;
                }
 
                NS_LOG_FUNCTION(this << "BufferTitle: " << graphTitle);
 
                QKDGraphManager->CreateGraphForBuffer(
                    node, 
                    dstKmsNode,
                    buffer->GetIndex(), 
                    buffer->GetSrcKMSApplicationIndex(), 
                    graphTitle, 
                    "png",
                    buffer
                ); 
            }
        }
    }
}
 
/**
*   @brief ADD QKDGraph
*   @param  Ptr<Node>       src
*   @param  Ptr<Node>       dst
*/
void
QKDLinkHelper::AddGraph(
    Ptr<Node> src,
    Ptr<Node> dst
) {
    AddGraph(src, dst, "", "png");
}
 
/**
*   @brief ADD QKDGraph
*   @param  Ptr<Node>       src
*   @param  Ptr<Node>       dst
*   @param  std::string     graphName
*/
void
QKDLinkHelper::AddGraph(
    Ptr<Node> src,
    Ptr<Node> dst,
    std::string graphName
){
    AddGraph(src, dst, graphName, "png");
}
 
/**
*   @brief ADD QKDGraph
*   @param  Ptr<QKDControl> QKDControl
*   @param  Ptr<Node>       src
*   @param  Ptr<Node>       dst
*   @param  std::string     graphName
*   @param  std::string     graphType
*/
void
QKDLinkHelper::AddGraph(
    Ptr<Node> srcKMSNode,
    Ptr<Node> dstKmsNode,
    std::string graphName,
    std::string graphType
) {
 
    NS_LOG_FUNCTION(this);
 
    Ptr<QKDKeyManagerSystemApplication> kms;
    uint32_t applicationIndex = 0;
    for(uint32_t i = 0; i < srcKMSNode->GetNApplications(); ++i){
        kms = srcKMSNode->GetApplication(i)->GetObject <QKDKeyManagerSystemApplication>();
        applicationIndex = i;
        if(kms) break;
    }
    NS_ASSERT(kms);
 
    Ptr<QBuffer> buffer = kms->GetQBuffer( dstKmsNode->GetId(), "ns3::QBuffer" );
    NS_ASSERT(buffer);
 
    buffer->SetSrcKMSApplicationIndex(applicationIndex);
    NS_LOG_FUNCTION(this << buffer << buffer->GetState() << buffer->GetIndex() );
 
    QKDGraphManager *QKDGraphManager = QKDGraphManager::getInstance();
    QKDGraphManager->CreateGraphForBuffer(srcKMSNode, dstKmsNode, buffer->GetIndex(), buffer->GetSrcKMSApplicationIndex(), graphName, graphType, buffer);
}
 
/**
*   @brief Print QKDGraphs
*/
void
QKDLinkHelper::PrintGraphs()
{
    NS_LOG_FUNCTION(this);
 
    QKDGraphManager *QKDGraphManager = QKDGraphManager::getInstance();
    QKDGraphManager->PrintGraphs();
}
 
Ptr<QKDControl>
QKDLinkHelper::InstallQKDNController(Ptr<Node> n)
{
    NS_LOG_FUNCTION(this);
 
    Ptr<QKDControl> controller = n->GetObject<QKDControl>();
    if(!controller){
        ObjectFactory factory;
        factory.SetTypeId("ns3::QKDControl");
        controller = factory.Create <QKDControl>();
        controller->SetNode(n);
        n->AggregateObject(controller);
    }
    return controller;
}
 
Ptr<QCenController>
QKDLinkHelper::InstallQCenController(Ptr<Node> node)
{
    NS_LOG_FUNCTION(this);
 
    Ptr<QCenController> controller = node->GetObject<QCenController>();
    if(!controller){
        ObjectFactory factory;
        factory.SetTypeId("ns3::QCenController");
        controller = factory.Create <QCenController>();
        controller->SetNode(node);
        node->AggregateObject(controller);
    }
 
    m_cen_controller = controller;
    return controller;
}
 
void
QKDLinkHelper::ConfigureQBuffers(
    std::vector<Ptr<QKDControl> > controllers,
    uint32_t Mmin,
    uint32_t Mthr,
    uint32_t Mmax,
    uint32_t defaultKeySize
)
{
    NS_LOG_FUNCTION(this);
    return ConfigureQBuffers(controllers, Mmin, Mthr, Mmax, 0, defaultKeySize);
}
 
void
QKDLinkHelper::ConfigureQBuffers(
    std::vector<Ptr<QKDControl> > controllers,
    uint32_t Mmin,
    uint32_t Mthr,
    uint32_t Mmax,
    uint32_t Mcurr,
    uint32_t defaultKeySize
)
{
    NS_LOG_FUNCTION(this);
 
    for(auto controller : controllers)
        controller->ConfigureQBuffers(Mmin, Mthr, Mmax, Mcurr, defaultKeySize);
}
 
void
QKDLinkHelper::ConfigureRSBuffers(
    std::vector<Ptr<QKDControl> > controllers,
    uint32_t Mmin,
    uint32_t Mthr,
    uint32_t Mmax,
    uint32_t Mcurr,
    uint32_t defaultKeySize
)
{
    for(auto controller : controllers)
        controller->ConfigureRSBuffers(Mmin, Mthr, Mmax, Mcurr, defaultKeySize);
}
 
void
QKDLinkHelper::ConfigureRSBuffers(
    std::vector<Ptr<QKDControl> > controllers,
    uint32_t Mmin,
    uint32_t Mthr,
    uint32_t Mmax,
    uint32_t defaultKeySize
)
{
    return ConfigureRSBuffers(controllers, Mmin, Mthr, Mmax, 0, defaultKeySize);
}
 
void
QKDLinkHelper::CreateAndAggregateObjectFromTypeId(Ptr<Node> node, const std::string typeId)
{
    ObjectFactory factory;
    factory.SetTypeId(typeId);
    Ptr<Object> protocol = factory.Create <Object>();
    node->AggregateObject(protocol);
}
 
uint32_t
QKDLinkHelper::GetColumn(uint32_t nodeId)
{
    uint32_t output = 0;
    for(auto el : m_controllers)
    {
        if(el.first == nodeId)
            break;
        output++;
    }
 
    return output;
}
 
uint32_t
QKDLinkHelper::ReverseColumn(uint32_t position)
{
    auto it = std::next(std::begin(m_controllers), position);
    if(it == m_controllers.end())
        NS_LOG_ERROR(this);
 
    return it->first;
}
 
void
QKDLinkHelper::CreateTopologyGraph(std::vector<Ptr<QKDControl> > controllers, uint32_t reroute)
{
    NS_LOG_FUNCTION(this);
    //Code adjusted from: https://www.srcmake.com/home/cpp-shortest-path-dijkstra
    if(reroute == 0){ //Use old code
        for(size_t i = 0; i < controllers.size(); i++)
        {
            // Create a vector to represent a row, and add it to the adjList.
            std::vector<std::pair<uint32_t, uint32_t> > row;
            m_adjList.push_back(row);
        }
 
        //Read inputs into sorted map entries where key is KMNodeId and value is QKDControl
        for(auto el : controllers)
            m_controllers.insert(std::make_pair(el->GetLocalKMNodeId(), el));
        //Algorithm uses nodes from 0 to size. Our nodes have other numbers!
        //We use this map to transit from position(0 to size) to actual node Id
 
        uint32_t elNum = m_controllers.size();
        NS_ASSERT(elNum);
 
        //We use are automated procedure to fill adjList!
        uint32_t row = 0;
        for(auto const& el : m_controllers) //For each controller
        {
            NS_LOG_FUNCTION(this << "KMNodeId: " << el.first << "Row: " << row);
            //Get connecting remote KM node IDs
            std::vector<uint32_t> remoteKmNodeIds = el.second->GetRemoteKmNodeIds();
            //Go through all remote KM node IDs and fill the graph
            for(auto const& kmNodeId : remoteKmNodeIds)
            {
                NS_LOG_FUNCTION(this << "Connected to: " << kmNodeId << "Column: " << GetColumn(kmNodeId));
                m_adjList[row].push_back(std::make_pair(GetColumn(kmNodeId), uint32_t(1))); //weight is always 1 in our simple case
            }
 
            ++row;
        }
 
    }else{ //Use centralized controller. qcen-control
        m_cen_controller->RegisterDControllers(controllers); //Just initialize centralized controller!
 
    }
 
}
 
// Given an Adjacency List, find all shortest paths from "start" to all other vertices.
std::vector< std::pair<uint32_t, uint32_t> >
QKDLinkHelper::DijkstraSP(
    std::vector< std::vector<std::pair<uint32_t, uint32_t> > > adjList,
    uint32_t start)
{
    std::vector<std::pair<uint32_t, uint32_t> > dist; // First int is dist, second is the previous node.
 
    // Initialize all source->vertex as infinite.
    int n = adjList.size();
    for(int i = 0; i < n; i++)
    {
        dist.push_back(std::make_pair(uint32_t(1000000007), uint32_t(i))); // Define "infinity" as necessary by constraints.
    }
 
    // Create a PQ.
    std::priority_queue<std::pair<int, int>, std::vector< std::pair<int, int> >, std::greater<std::pair<int, int> > > pq;
 
    // Add source to pq, where distance is 0.
    pq.push(std::make_pair(int(start), 0));
    dist[start] = std::make_pair(uint32_t(0), start);
 
    // While pq isn't empty...
    while(pq.empty() == false)
    {
        // Get min distance vertex from pq.(Call it u.)
        int u = pq.top().first;
        pq.pop();
 
        // Visit all of u's friends. For each one(called v)....
        int listSize = adjList[u].size();
        for(int i = 0; i < listSize; i++)
        {
            uint32_t v = adjList[u][i].first;
            uint32_t weight = adjList[u][i].second;
 
            // If the distance to v is shorter by going through u...
            if(dist[v].first > dist[u].first + weight)
            {
                // Update the distance of v.
                dist[v].first = dist[u].first + weight;
                // Update the previous node of v.
                dist[v].second = u;
                // Insert v into the pq.
                pq.push(std::make_pair(v, dist[v].first));
            }
        }
    }
 
    return dist;
}
 
 
void
QKDLinkHelper::PopulateRoutingTables()
{
    NS_LOG_FUNCTION(this << m_controllers.size() );
 
    if(!m_controllers.empty())
    { //old code
 
        std::vector<std::pair<uint32_t, uint32_t> > dist; // First int is dist, second is the previous node.
        for(auto el : m_controllers)
        {
            dist = DijkstraSP(m_adjList, GetColumn(el.first));
            int distSize = dist.size();
            for(int i = 0; i < distSize; i++)
            {
                int currnode = i;
                std::vector<uint32_t> path;
                while(currnode != int(GetColumn(el.first)))
                {
                    path.push_back(currnode);
                    currnode = dist[currnode].second;
                }
                /*
                    path is empty if the node is the node!
                    the first element in path is destination node!
                    the last element in path is the next hop!
                    GetColumn(el.fist) is the source node!
                    dist[i].first is number of hops
                    i is source node as well
                */
                uint32_t hops = dist[i].first;
                if(hops >= 1){ //Populate routing table
                    uint32_t nextHop = ReverseColumn(path[path.size()-1]);
                    Ipv4Address nextHopAddress = m_controllers.find(nextHop)->second->GetLocalKMAddress();
                    uint32_t dstNodeId = ReverseColumn(uint32_t(i));
                    Ipv4Address dstNodeAddress = m_controllers.find(dstNodeId)->second->GetLocalKMAddress();
                    std::string dstKmId = m_controllers.find(dstNodeId)->second->GetLocalKMId();
                    QKDLocationRegisterEntry newEntry(
                        nextHop,//nextHop KM node ID
                        nextHopAddress, //nextHop KM address
                        hops, // Dirrect p2p connection(number of hops)
                        dstNodeId, //Destination KM node ID
                        dstNodeAddress, //Destination KM address
                        dstKmId
                    );
                    el.second->AddRouteEntry(newEntry);
                }
 
            }
 
        }
    }
}
 
} // namespace ns3