inet::TED Class Reference

Contains the Traffic Engineering Database and provides public methods to access it from MPLS signalling protocols (LDP, RSVP-TE). More...

#include <TED.h>

Inheritance diagram for inet::TED:

Classes
struct	edge_t
	Only used internally, during shortest path calculation: edge in the graph we build from links in TELinkStateInfoVector. More...
struct	vertex_t
	Only used internally, during shortest path calculation: vertex in the graph we build from links in TELinkStateInfoVector. More...

Public Member Functions
	TED ()
virtual	~TED ()
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual bool	checkLinkValidity (TELinkStateInfo link, TELinkStateInfo *&match)
virtual void	updateTimestamp (TELinkStateInfo *link)
Public interface to the Traffic Engineering Database
virtual IPv4Address	getInterfaceAddrByPeerAddress (IPv4Address peerIP)
virtual IPv4Address	peerRemoteInterface (IPv4Address peerIP)
virtual IPv4Address	getPeerByLocalAddress (IPv4Address localInf)
virtual IPv4Address	primaryAddress (IPv4Address localInf)
virtual bool	isLocalPeer (IPv4Address inetAddr)
virtual bool	isLocalAddress (IPv4Address addr)
virtual unsigned int	linkIndex (IPv4Address localInf)
virtual unsigned int	linkIndex (IPv4Address advrouter, IPv4Address linkid)
virtual IPAddressVector	getLocalAddress ()
virtual void	rebuildRoutingTable ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Public Attributes
TELinkStateInfoVector	ted
	The link state database. More...

Protected Member Functions
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	initializeTED ()
virtual IPAddressVector	calculateShortestPath (IPAddressVector dest, const TELinkStateInfoVector &topology, double req_bandwidth, int priority)
virtual int	assignIndex (std::vector< vertex_t > &vertices, IPv4Address nodeAddr)
std::vector< vertex_t >	calculateShortestPaths (const TELinkStateInfoVector &topology, double req_bandwidth, int priority)

Protected Attributes
IIPv4RoutingTable *	rt = nullptr
IInterfaceTable *	ift = nullptr
IPv4Address	routerId
IPAddressVector	interfaceAddrs
int	maxMessageId = 0

Detailed Description

Contains the Traffic Engineering Database and provides public methods to access it from MPLS signalling protocols (LDP, RSVP-TE).

See NED file for more info.

Constructor & Destructor Documentation

inet::TED::TED

(

)

{
}

inet::TED::~TED ( )

virtual

{
}

Member Function Documentation

int inet::TED::assignIndex ( std::vector< vertex_t > &  vertices, IPv4Address  nodeAddr  )

protectedvirtual

Referenced by calculateShortestPaths().

{
    // find node in vertices[] whose IPv4 address is nodeAddr
    for (unsigned int i = 0; i < vertices.size(); i++)
        if (vertices[i].node == nodeAddr)
            return i;


    // if not found, create
    vertex_t newVertex;
    newVertex.node = nodeAddr;
    newVertex.dist = LS_INFINITY;
    newVertex.parent = -1;

    vertices.push_back(newVertex);
    return vertices.size() - 1;
}

IPAddressVector inet::TED::calculateShortestPath ( IPAddressVector  dest, const TELinkStateInfoVector &  topology, double  req_bandwidth, int  priority  )

protectedvirtual

{
    // FIXME comment: what do we do here?
    std::vector<vertex_t> V = calculateShortestPaths(topology, req_bandwidth, priority);

    double minDist = LS_INFINITY;
    int minIndex = -1;

    // FIXME comment: what do we do in this block?
    for (unsigned int i = 0; i < V.size(); i++) {
        if (V[i].dist >= minDist)
            continue;

        if (find(dest.begin(), dest.end(), V[i].node) == dest.end())
            continue;

        minDist = V[i].dist;
        minIndex = i;
    }

    IPAddressVector result;

    if (minIndex < 0)
        return result;

    result.push_back(V[minIndex].node);
    while (V[minIndex].parent != -1) {
        minIndex = V[minIndex].parent;
        result.insert(result.begin(), V[minIndex].node);
    }

    return result;
}

std::vector< TED::vertex_t > inet::TED::calculateShortestPaths ( const TELinkStateInfoVector &  topology, double  req_bandwidth, int  priority  )

protected

Referenced by calculateShortestPath(), and rebuildRoutingTable().

{
    std::vector<vertex_t> vertices;
    std::vector<edge_t> edges;

    // select edges that have enough bandwidth left, and store them into edges[].
    // meanwhile, collect vertices in vectices[].
    for (auto & elem : topology) {
        if (!elem.state)
            continue;

        if (elem.UnResvBandwidth[priority] < req_bandwidth)
            continue;

        edge_t edge;
        edge.src = assignIndex(vertices, elem.advrouter);
        edge.dest = assignIndex(vertices, elem.linkid);
        edge.metric = elem.metric;
        edges.push_back(edge);
    }

    IPv4Address srcAddr = routerId;

    int srcIndex = assignIndex(vertices, srcAddr);
    vertices[srcIndex].dist = 0.0;

    // FIXME comment: Dijkstra? just guessing...
    for (unsigned int i = 1; i < vertices.size(); i++) {
        bool mod = false;

        for (auto & edge : edges) {
            int src = edge.src;
            int dest = edge.dest;

            ASSERT(src >= 0);
            ASSERT(dest >= 0);
            ASSERT(src < (int)vertices.size());
            ASSERT(dest < (int)vertices.size());
            ASSERT(src != dest);

            if (vertices[src].dist + edge.metric >= vertices[dest].dist)
                continue;

            vertices[dest].dist = vertices[src].dist + edge.metric;
            vertices[dest].parent = src;

            mod = true;
        }

        if (!mod)
            break;
    }

    return vertices;
}

bool inet::TED::checkLinkValidity ( TELinkStateInfo  link, TELinkStateInfo *&  match  )

virtual

Referenced by inet::LinkStateRouting::processLINK_STATE_MESSAGE().

{
    match = nullptr;

    for (auto & elem : ted) {
        if (elem.sourceId == link.sourceId && elem.messageId == link.messageId && elem.timestamp == link.timestamp) {
            // we've already seen this message, ignore it
            return false;
        }

        if (elem.advrouter == link.advrouter && elem.linkid == link.linkid) {
            // we've have info about this link

            if (elem.timestamp < link.timestamp || (elem.timestamp == link.timestamp && elem.messageId < link.messageId)) {
                // but it's older, use this new
                match = &(elem);
                break;
            }
            else {
                // and it's newer, forget this message
                return false;
            }
        }
    }

    // no or not up2date info, link is interesting
    return true;
}

IPv4Address inet::TED::getInterfaceAddrByPeerAddress ( IPv4Address  peerIP )

virtual

Referenced by rebuildRoutingTable().

{
    for (auto & elem : ted)
        if (elem.linkid == peerIP && elem.advrouter == routerId)
            return elem.local;

    throw cRuntimeError("not a local peer: %s", peerIP.str().c_str());
}

IPAddressVector inet::TED::getLocalAddress ( )

virtual

{
    return interfaceAddrs;
}

IPv4Address inet::TED::getPeerByLocalAddress ( IPv4Address  localInf )

virtual

Referenced by rebuildRoutingTable().

{
    unsigned int index = linkIndex(localInf);
    return ted[index].linkid;
}

void inet::TED::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    ASSERT(false);
}

bool inet::TED::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

overridevirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

Implements inet::ILifecycle.

{
    Enter_Method_Silent();
    if (dynamic_cast<NodeStartOperation *>(operation)) {
        if ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_APPLICATION_LAYER)
            initializeTED();
    }
    else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
        if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_APPLICATION_LAYER) {
            ted.clear();
            interfaceAddrs.clear();
        }
    }
    else if (dynamic_cast<NodeCrashOperation *>(operation)) {
        if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH) {
            ted.clear();
            interfaceAddrs.clear();
        }
    }
    return true;
}

void inet::TED::initialize ( int  stage )

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        maxMessageId = 0;

        WATCH_VECTOR(ted);

        rt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);
        ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        routerId = rt->getRouterId();
        ASSERT(!routerId.isUnspecified());

        bool isOperational;
        NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));
        isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;
        if (isOperational)
            initializeTED();
    }
}

void inet::TED::initializeTED ( )

protectedvirtual

Referenced by handleOperationStage(), and initialize().

{
    //
    // Extract initial TED contents from the routing table.
    //
    // We need to create one TED entry (TELinkStateInfo) for each link,
    // i.e. for each physical interface.
    //
    for (int i = 0; i < ift->getNumInterfaces(); i++) {
        InterfaceEntry *ie = ift->getInterface(i);

        if (ie->getNodeOutputGateId() == -1) // ignore if it's not a physical interface
            continue;

        //
        // We'll need to fill in "linkid" and "remote" (ie. peer addr).
        //
        // Real link state protocols find the peer address by exchanging HELLO messages;
        // in this model we haven't implemented HELLO but provide peer addresses via
        // preconfigured static host routes in routing table.
        //
        // find bandwidth of the link
        cGate *g = getParentModule()->gate(ie->getNodeOutputGateId());
        ASSERT(g);
        double linkBandwidth = g->getChannel()->getNominalDatarate();

        // find destination node for current interface
        cModule *destNode = nullptr;
        while (g) {
            g = g->getNextGate();
            cModule *mod = g->getOwnerModule();
            cProperties *props = mod->getProperties();
            if (props && props->getAsBool("networkNode")) {
                destNode = mod;
                break;
            }
        }
        if (!g) // not connected
            continue;
        IIPv4RoutingTable *destRt = L3AddressResolver().findIPv4RoutingTableOf(destNode);
        if (!destRt) // switch, hub, bus, accesspoint, etc
            continue;
        IPv4Address destRouterId = destRt->getRouterId();
        IInterfaceTable *destIft = L3AddressResolver().findInterfaceTableOf(destNode);
        ASSERT(destIft);
        InterfaceEntry *destIe = destIft->getInterfaceByNodeInputGateId(g->getId());
        ASSERT(destIe);

        //
        // fill in and insert TED entry
        //
        TELinkStateInfo entry;
        entry.advrouter = routerId;
        ASSERT(ie->ipv4Data());
        entry.local = ie->ipv4Data()->getIPAddress();
        entry.linkid = destRouterId;
        ASSERT(destIe->ipv4Data());
        entry.remote = destIe->ipv4Data()->getIPAddress();
        entry.MaxBandwidth = linkBandwidth;
        for (int j = 0; j < 8; j++)
            entry.UnResvBandwidth[j] = entry.MaxBandwidth;
        entry.state = true;

        // use g->getChannel()->par("delay").doubleValue() for shortest delay calculation
        entry.metric = ie->ipv4Data()->getMetric();

        EV_INFO << "metric set to=" << entry.metric << endl;

        entry.sourceId = routerId.getInt();
        entry.messageId = ++maxMessageId;
        entry.timestamp = simTime();

        ted.push_back(entry);
    }

    // extract list of local interface addresses into interfaceAddrs[]
    for (int i = 0; i < ift->getNumInterfaces(); i++) {
        InterfaceEntry *ie = ift->getInterface(i);
        InterfaceEntry *ie2 = rt->getInterfaceByAddress(ie->ipv4Data()->getIPAddress());
        if (ie2 != ie)
            throw cRuntimeError("MPLS models assume interfaces to have unique addresses, "
                                "but address of '%s' (%s) is not unique",
                    ie->getName(), ie->ipv4Data()->getIPAddress().str().c_str());
        if (!ie->isLoopback())
            interfaceAddrs.push_back(ie->ipv4Data()->getIPAddress());
    }

    rebuildRoutingTable();
}

bool inet::TED::isLocalAddress ( IPv4Address  addr )

virtual

{
    for (auto & elem : interfaceAddrs)
        if (elem == addr)
            return true;

    return false;
}

bool inet::TED::isLocalPeer ( IPv4Address  inetAddr )

virtual

Referenced by peerRemoteInterface(), and rebuildRoutingTable().

{
    for (auto & elem : ted)
        if (elem.linkid == inetAddr && elem.advrouter == routerId)
            return true;

    return false;
}

unsigned int inet::TED::linkIndex ( IPv4Address  localInf )

virtual

Referenced by getPeerByLocalAddress(), inet::LDP::processHelloTimeout(), and inet::LDP::processLDPHello().

{
    for (unsigned int i = 0; i < ted.size(); i++)
        if (ted[i].advrouter == routerId && ted[i].local == localInf)
            return i;

    ASSERT(false);
    return -1;    // to eliminate warning
}

unsigned int inet::TED::linkIndex ( IPv4Address  advrouter, IPv4Address  linkid  )

virtual

{
    for (unsigned int i = 0; i < ted.size(); i++)
        if (ted[i].advrouter == advrouter && ted[i].linkid == linkid)
            return i;

    ASSERT(false);
    return -1;    // to eliminate warning
}

virtual int inet::TED::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

IPv4Address inet::TED::peerRemoteInterface ( IPv4Address  peerIP )

virtual

{
    ASSERT(isLocalPeer(peerIP));
    for (auto & elem : ted)
        if (elem.linkid == peerIP && elem.advrouter == routerId)
            return elem.remote;

    throw cRuntimeError("not a local peer: %s", peerIP.str().c_str());
}

IPv4Address inet::TED::primaryAddress ( IPv4Address  localInf )

virtual

{
    for (auto & elem : ted) {
        if (elem.local == localInf)
            return elem.advrouter;

        if (elem.remote == localInf)
            return elem.linkid;
    }
    ASSERT(false);
    return IPv4Address();    // to eliminate warning
}

void inet::TED::rebuildRoutingTable ( )

virtual

Referenced by initializeTED(), inet::LDP::processHelloTimeout(), inet::LDP::processLDPHello(), and inet::LinkStateRouting::processLINK_STATE_MESSAGE().

{
    EV_INFO << "rebuilding routing table at " << routerId << endl;

    std::vector<vertex_t> V = calculateShortestPaths(ted, 0.0, 7);

    // remove all routing entries, except multicast ones (we don't care about them)
    int n = rt->getNumRoutes();
    int j = 0;
    for (int i = 0; i < n; i++) {
        IPv4Route *entry = rt->getRoute(j);
        if (entry->getDestination().isMulticast()) {
            ++j;
        }
        else {
            rt->deleteRoute(entry);
        }
    }

//  for (unsigned int i = 0; i < V.size(); i++)
//  {
//      EV << "V[" << i << "].node=" << V[i].node << endl;
//      EV << "V[" << i << "].parent=" << V[i].parent << endl;
//      EV << "V[" << i << "].dist=" << V[i].dist << endl;
//  }

    // insert remote destinations

    for (unsigned int i = 0; i < V.size(); i++) {
        if (V[i].node == routerId) // us
            continue;

        if (V[i].parent == -1) // unreachable
            continue;

        if (isLocalPeer(V[i].node)) // local peer
            continue;

        int nHop = i;

        while (!isLocalPeer(V[nHop].node)) {
            nHop = V[nHop].parent;
        }

        ASSERT(isLocalPeer(V[nHop].node));

        IPv4Route *entry = new IPv4Route;
        entry->setDestination(V[i].node);

        if (V[i].node == V[nHop].node) {
            entry->setGateway(IPv4Address());
        }
        else {
            entry->setGateway(V[nHop].node);
        }
        entry->setInterface(rt->getInterfaceByAddress(getInterfaceAddrByPeerAddress(V[nHop].node)));
        entry->setSourceType(IRoute::OSPF);

        entry->setNetmask(IPv4Address::ALLONES_ADDRESS);
        entry->setMetric(0);

        EV_DETAIL << "  inserting route: dest=" << entry->getDestination() << " interface=" << entry->getInterfaceName() << " nexthop=" << entry->getGateway() << "\n";

        rt->addRoute(entry);
    }

    // insert local peers

    for (auto & elem : interfaceAddrs) {
        IPv4Route *entry = new IPv4Route;

        entry->setDestination(getPeerByLocalAddress(elem));
        entry->setGateway(IPv4Address());
        entry->setInterface(rt->getInterfaceByAddress(elem));
        entry->setSourceType(IRoute::OSPF);

        entry->setNetmask(IPv4Address::ALLONES_ADDRESS);
        entry->setMetric(0);    // XXX FIXME what's that?

        EV_DETAIL << "  inserting route: local=" << elem << " peer=" << entry->getDestination() << " interface=" << entry->getInterfaceName() << "\n";

        rt->addRoute(entry);
    }
}

void inet::TED::updateTimestamp ( TELinkStateInfo *  link )

virtual

Referenced by inet::LinkStateRouting::receiveSignal().

{
    ASSERT(link->advrouter == routerId);

    link->timestamp = simTime();
    link->messageId = ++maxMessageId;
}

Member Data Documentation

IInterfaceTable* inet::TED::ift = nullptr

protected

Referenced by initialize(), and initializeTED().

IPAddressVector inet::TED::interfaceAddrs

protected

Referenced by getLocalAddress(), handleOperationStage(), initializeTED(), isLocalAddress(), and rebuildRoutingTable().

int inet::TED::maxMessageId = 0

protected

Referenced by initialize(), initializeTED(), and updateTimestamp().

IPv4Address inet::TED::routerId

protected

Referenced by calculateShortestPaths(), getInterfaceAddrByPeerAddress(), initialize(), initializeTED(), isLocalPeer(), linkIndex(), peerRemoteInterface(), rebuildRoutingTable(), and updateTimestamp().

IIPv4RoutingTable* inet::TED::rt = nullptr

protected

Referenced by initialize(), initializeTED(), and rebuildRoutingTable().

TELinkStateInfoVector inet::TED::ted

The link state database.

(TELinkStateInfoVector is defined in TED.msg)

Referenced by checkLinkValidity(), getInterfaceAddrByPeerAddress(), getPeerByLocalAddress(), inet::LinkStateRouting::handleMessage(), handleOperationStage(), initialize(), initializeTED(), isLocalPeer(), linkIndex(), peerRemoteInterface(), primaryAddress(), inet::LDP::processHelloTimeout(), inet::LDP::processLDPHello(), inet::LinkStateRouting::processLINK_STATE_MESSAGE(), rebuildRoutingTable(), inet::LinkStateRouting::receiveSignal(), and inet::LinkStateRouting::sendToPeers().

---

The documentation for this class was generated from the following files:

• TED.h
• TED.cc