qkd-location-register.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:  Emir Dervisevic <emir.dervisevic@etf.unsa.ba>
 *          Miralem Mehic <miralem.mehic@ieee.org>
 */
#include "ns3/log.h"
#include "ns3/address.h"
#include "ns3/node.h"
#include "ns3/nstime.h"
#include "ns3/simulator.h"
#include "ns3/uinteger.h"
#include "ns3/trace-source-accessor.h"
#include <iostream>
#include <fstream>
#include <string>
 
#include "qkd-location-register.h"
#include "qkd-location-register-entry.h"
 
namespace ns3 {
 
    NS_LOG_COMPONENT_DEFINE("QKDLocationRegister");
 
    NS_OBJECT_ENSURE_REGISTERED(QKDLocationRegister);
 
    TypeId
    QKDLocationRegister::GetTypeId()
    {
      static TypeId tid = TypeId("ns3::QKDLocationRegister")
        .SetParent<Object>()
        .SetGroupName("QKDLocationRegister")
        .AddConstructor<QKDLocationRegister>()
        ;
      return tid;
    }
 
    TypeId
    QKDLocationRegister::GetInstanceTypeId() const
    {
      return GetTypeId();
    }
 
    QKDLocationRegister::QKDLocationRegister()
    {}
 
    QKDLocationRegister::QKDLocationRegister(Ptr<Node> n)
    {
        SetNode(n);
        
        Ptr<QKDKeyManagerSystemApplication> kms;
        for(uint32_t i = 0; i < m_node->GetNApplications(); i++ ){
            Ptr<Application> app = m_node->GetApplication( i );
            kms = app->GetObject<QKDKeyManagerSystemApplication>();
            if(kms) break;
        }
        NS_ASSERT(kms);
        SetAddress(kms->GetAddress());
 
    }
 
    bool
    QKDLocationRegister::AddEntry(QKDLocationRegisterEntry & rt)
    {
        NS_LOG_FUNCTION(this << m_id << rt.GetDestinationKmNodeId() << rt.GetNextHopKMNodeId());
 
        if(m_id == rt.GetDestinationKmNodeId() && m_id == rt.GetNextHopKMNodeId())
            return false;
 
        std::pair<std::map<uint32_t, QKDLocationRegisterEntry>::iterator, bool> result = m_locationEntites.insert(
            std::make_pair(rt.GetDestinationKmNodeId(),rt)
        );
        return result.second;
    }
 
    bool
    QKDLocationRegister::DeleteEntry(uint32_t dstSaeId)
    {
        NS_LOG_FUNCTION(this);
        return (m_locationEntites.erase(dstSaeId) != 0);
    }
 
    bool
    QKDLocationRegister::Lookup(uint32_t id, QKDLocationRegisterEntry & rt)
    {
        NS_LOG_FUNCTION(this << m_id << id << m_locationEntites.size());
 
        if(m_locationEntites.empty())
            return false;
 
        for(auto i = m_locationEntites.begin(); i != m_locationEntites.end(); ++i)
            NS_LOG_FUNCTION(this << "PRINT:" << m_id << i->first << id);
 
        auto i = m_locationEntites.find(id);
 
        if(i == m_locationEntites.end())
            return false;
 
        rt = i->second;
        return true;
    }
 
    bool
    QKDLocationRegister::LookupByKms(Ipv4Address dstKmsAddress, QKDLocationRegisterEntry & rt)
    {
        NS_LOG_FUNCTION(this << dstKmsAddress );
        for(auto i = m_locationEntites.begin(); i != m_locationEntites.end(); ++i)
        {
            if( i->second.GetDestinationKmsAddress() == dstKmsAddress ){
                rt = i->second;
                return true;
            }
        }
        return false;
 
    }
 
    void
    QKDLocationRegister::GetListOfAllEntries(std::map<uint32_t, QKDLocationRegisterEntry> & allRoutes)
    {
      for(auto i = m_locationEntites.begin(); i != m_locationEntites.end(); ++i)
        {
            allRoutes.insert(std::make_pair(i->first,i->second));
        }
    }
 
    void
    QKDLocationRegister::GetListOfDestinationWithNextHop(uint32_t nextHop,
                                                   std::map<uint32_t, QKDLocationRegisterEntry> & unreachable)
    {
      unreachable.clear();
      for(auto i = m_locationEntites.begin(); i
           != m_locationEntites.end(); ++i)
        {
          if(i->second.GetNextHop() == nextHop)
            {
              unreachable.insert(std::make_pair(i->first,i->second));
            }
        }
    }
 
    uint32_t
    QKDLocationRegister::GetSize()
    {
        return m_locationEntites.size();
    }
 
 
    // Given an Adjacency List, find all shortest paths from "start" to all other vertices.
    std::vector< std::pair<uint32_t, uint32_t> >
    QKDLocationRegister::DijkstraSP(uint32_t start)
    {
 
        NS_LOG_FUNCTION(this << m_id << "DijkstraSp on " << start << "m_adjList.size: " << m_adjList.size() );
        std::vector<std::pair<uint32_t, uint32_t> > dist; // First int is dist, second is the previous node.
 
        for(auto el : m_adjList){
            NS_LOG_FUNCTION("**m_adjList:**" << el.first);
        }
 
        // Initialize all source->vertex as infinite.
 
        uint32_t distSize = start > m_adjList.size() ? start+1 : m_adjList.size();
        dist.resize(distSize);
        dist[start] = std::make_pair(100, start);
 
        for(auto const& el : m_adjList)
        {
            if(el.first > dist.size()){
                dist.resize(el.first+1);
                NS_LOG_FUNCTION("Dist size is too small! \t" << el.first << "\t" << dist.size());
            }
 
            if(el.first == m_id)
            {
                dist[m_id] = std::make_pair(0, m_id);
            }else{
                dist[el.first] =
                    std::make_pair(
                            uint32_t(1000000),
                            uint32_t(el.first)
                    ); // Define "infinity" as necessary by constraints.
            }
            //NS_LOG_FUNCTION(this << m_id << "save " << el.first  << dist[el.first].first  << dist[el.first].second  );
        }
 
 
        for(auto i = dist.begin(); i != dist.end(); ++i)
            NS_LOG_FUNCTION(this << "xxxx" <<  i->first << i->second);
 
        NS_LOG_FUNCTION(this << "dist.size(): " << dist.size());
        if(dist.size() > 1 )
        {
 
            NS_LOG_FUNCTION(this << 616);
 
            // Create a PQ.
            std::priority_queue<
                std::pair<uint32_t, uint32_t>,
                std::vector< std::pair<uint32_t, uint32_t> >,
                std::greater<std::pair<uint32_t, uint32_t> >
            > pq;
 
            NS_LOG_FUNCTION(this << 625 << start);
 
            // Add source to pq, where distance is 0.
            uint32_t startZero = 0;
            std::pair<uint32_t, uint32_t> pZero = std::make_pair(start, startZero);
 
            pq.push(pZero);
 
            NS_LOG_FUNCTION(this << 630);
 
            // While pq isn't empty...
            while(!pq.empty())
            {
                NS_LOG_FUNCTION(this << m_id << "pq.size():" << pq.size());
 
                // Get min distance vertex from pq.(Call it u.)
                uint32_t u = pq.top().first;
                pq.pop();
                NS_LOG_FUNCTION(this << m_id << "u:" << u);
 
                // Visit all of u's friends. For each one(called v)....
                for(auto const& el : m_adjList)
                {
                    NS_LOG_FUNCTION(this << m_id << "PPPPP\t u:" << u << "\t el.first: " << el.first  << "m_adjList.size():" << m_adjList.size()  );
 
                    uint32_t v = el.first;
                    uint32_t weight = el.second;
 
                    if(u == v || u == m_id || v == m_id || dist[u].second == dist[v].second)continue;
 
                    NS_LOG_FUNCTION(this << "u" << u);
                    NS_LOG_FUNCTION(this << "v" << v);
                    NS_LOG_FUNCTION(this << "weight" << weight);
 
                    NS_LOG_FUNCTION(this << "dist[u].first" << dist[u].first);
                    NS_LOG_FUNCTION(this << "dist[u].second" << dist[u].second);
 
                    NS_LOG_FUNCTION(this << "dist[v].first" << dist[v].first);
                    NS_LOG_FUNCTION(this << "dist[v].second" << dist[v].second);
 
                    // If the distance to v is shorter by going through u...
                    if(dist[v].first > dist[u].first + weight)
                    {
                        NS_LOG_FUNCTION(this << "536!!!!");
                        // 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.emplace(v, dist[v].first);
                    }
                    NS_LOG_FUNCTION(this << "544!!!!");
                }
            }
        }
 
        return dist;
    }
 
    void
    QKDLocationRegister::PopulateRoutingTables()
    {
        NS_LOG_FUNCTION(this << m_id);
 
        for(auto const& el: m_controllers)
            NS_LOG_FUNCTION("**controllers:**" << el.first);
 
        for(auto const& el : m_controllers)
        {
            el.second->ClearRoutingTable();
            uint32_t sourceNode = el.first;
 
            std::vector<std::pair<uint32_t, uint32_t> > dist; // First int is dist, second is the previous node.
            dist = DijkstraSP(sourceNode);
 
            for(auto i = dist.begin(); i != dist.end(); ++i)
                NS_LOG_FUNCTION(this << "oooo" <<  i->first << i->second);
 
 
            NS_LOG_FUNCTION(this << sourceNode << dist.size() << el.first);
 
            uint32_t counter = 0;
            std::vector<uint32_t> path;
            for(auto el2 : dist)
            {
                NS_LOG_FUNCTION(this << "el2.first:" << el2.first << "\t el2.second:" << el2.second);
                path = {};
 
                if(el2.first == 0 && el2.second == 0) {
                }else{
 
                    /*
                        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!
                        el.first is the source node!
                        dist[i].first is number of hops
                        i is source node as well
                    */
                    uint32_t hops = el.first;
                    NS_LOG_FUNCTION(this << "nextHop:" << el2.second << "\thops:" << hops);
 
                    if(hops >= 1)
                    {
                        NS_LOG_FUNCTION(this << "716");
                        uint32_t tempVal(el2.second);
 
                        NS_LOG_FUNCTION(this << "720" << tempVal);
                        path.push_back(tempVal);
 
                        //Populate routing table
                        //uint32_t nextHop = ReverseColumn(path[path.size()-1]);
                        NS_LOG_FUNCTION(this << "path.size():" << path.size());
 
                        if(!path.empty()){
 
                            uint32_t nextHop = path[path.size()-1];
                            NS_LOG_FUNCTION(this << "nextHopIs:" << nextHop);
 
                            for(auto const& el : m_controllers){
                                NS_LOG_FUNCTION("****" << el.first);
                            }
 
                            if(m_controllers.find(nextHop) != m_controllers.end() )
                            {
                                Ipv4Address nextHopAddress = m_controllers.find(nextHop)->second->GetLocalKMAddress();
                                //uint32_t dstNodeId = ReverseColumn(uint32_t(i));
                                uint32_t dstNodeId = counter;
                                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
                                );
                                AddEntry(newEntry);
                                //el.second->AddRouteEntry(newEntry);
                                NS_LOG_FUNCTION(this << "Node " << m_id << " FINAL_ROUTE\t" << "nextHop: " << nextHop << "(" << nextHopAddress << ")" << "\tdstNodeId: " << dstNodeId <<  "(" << dstNodeAddress << ")" << dstKmId);
                                NS_LOG_FUNCTION(this << m_id << newEntry.GetDestinationKmNodeId() << newEntry.GetNextHopKMNodeId());
                            }
                        }
                    }
                }
 
                counter++;
 
            }
 
 
 
        }
    }
 
} // namespace ns3