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 ()
Public Member Functions inherited from inet::RoutingProtocolBase
	RoutingProtocolBase ()
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
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	handleMessageWhenUp (cMessage *msg) override
virtual void	initializeTED ()
virtual Ipv4AddressVector	calculateShortestPath (Ipv4AddressVector dest, const TeLinkStateInfoVector &topology, double req_bandwidth, int priority)
Protected Member Functions inherited from inet::RoutingProtocolBase
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Public interface to the Traffic Engineering Database
ModuleRefByPar< IIpv4RoutingTable >	rt
ModuleRefByPar< IInterfaceTable >	ift
Ipv4Address	routerId
Ipv4AddressVector	interfaceAddrs
int	maxMessageId = 0
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 Ipv4AddressVector	getLocalAddress ()
virtual void	rebuildRoutingTable ()
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual bool	checkLinkValidity (TeLinkStateInfo link, TeLinkStateInfo *&match)
virtual void	updateTimestamp (TeLinkStateInfo *link)
virtual int	assignIndex (std::vector< vertex_t > &vertices, Ipv4Address nodeAddr)
std::vector< vertex_t >	calculateShortestPaths (const TeLinkStateInfoVector &topology, double req_bandwidth, int priority)

Additional Inherited Members
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

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

Ted()

inet::Ted::Ted

(

)

{
}

~Ted()

inet::Ted::~Ted ( )

virtual

{
}

Member Function Documentation

assignIndex()

int inet::Ted::assignIndex ( std::vector< vertex_t > &  vertices, Ipv4Address  nodeAddr  )

protectedvirtual

{
    // 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;
}

Referenced by calculateShortestPaths().

calculateShortestPath()

Ipv4AddressVector inet::Ted::calculateShortestPath ( Ipv4AddressVector  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 (!contains(dest, V[i].node))
            continue;
 
        minDist = V[i].dist;
        minIndex = i;
    }
 
    Ipv4AddressVector 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;
}

calculateShortestPaths()

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

protected

{
    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;
}

Referenced by calculateShortestPath(), and rebuildRoutingTable().

checkLinkValidity()

bool inet::Ted::checkLinkValidity ( TeLinkStateInfo  link, TeLinkStateInfo *&  match  )

virtual

{
    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;
}

getInterfaceAddrByPeerAddress()

Ipv4Address inet::Ted::getInterfaceAddrByPeerAddress ( Ipv4Address  peerIP )

virtual

{
    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());
}

Referenced by rebuildRoutingTable().

getLocalAddress()

Ipv4AddressVector inet::Ted::getLocalAddress ( )

virtual

{
    return interfaceAddrs;
}

getPeerByLocalAddress()

Ipv4Address inet::Ted::getPeerByLocalAddress ( Ipv4Address  localInf )

virtual

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

Referenced by rebuildRoutingTable().

handleCrashOperation()

void inet::Ted::handleCrashOperation ( LifecycleOperation *  operation )

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    ted.clear();
    interfaceAddrs.clear();
}

handleMessageWhenUp()

void inet::Ted::handleMessageWhenUp ( cMessage *  msg )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    throw cRuntimeError("Message not allowed");
}

handleStartOperation()

void inet::Ted::handleStartOperation ( LifecycleOperation *  operation )

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    initializeTED();
}

handleStopOperation()

void inet::Ted::handleStopOperation ( LifecycleOperation *  operation )

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    ted.clear();
    interfaceAddrs.clear();
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    RoutingProtocolBase::initialize(stage);
    // TODO INITSTAGE
    if (stage == INITSTAGE_LOCAL) {
        maxMessageId = 0;
 
        WATCH_VECTOR(ted);
 
        rt.reference(this, "routingTableModule", true);
        ift.reference(this, "interfaceTableModule", true);
    }
}

initializeTED()

void inet::Ted::initializeTED ( )

protectedvirtual

{
    routerId = rt->getRouterId();
    ASSERT(!routerId.isUnspecified());
 
    //
    // 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++) {
        NetworkInterface *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 = CHK(getParentModule()->gate(ie->getNodeOutputGateId()));
        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().interfaceTableOf(destNode);
        NetworkInterface *destIe = CHK(destIft->findInterfaceByNodeInputGateId(g->getId()));
 
        //
        // fill in and insert TED entry
        //
        TeLinkStateInfo entry;
        entry.advrouter = routerId;
        entry.local = ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
        entry.linkid = destRouterId;
        entry.remote = destIe->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
        entry.MaxBandwidth = linkBandwidth;
        for (int j = 0; j < 8; j++)
            entry.UnResvBandwidth[j] = entry.MaxBandwidth;
        entry.state = true;
 
        // use g->getChannel()->par("delay") for shortest delay calculation
        entry.metric = ie->getProtocolData<Ipv4InterfaceData>()->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++) {
        NetworkInterface *ie = ift->getInterface(i);
        NetworkInterface *ie2 = rt->getInterfaceByAddress(ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
        if (ie2 != ie)
            throw cRuntimeError("MPLS models assume interfaces to have unique addresses, "
                                "but address of '%s' (%s) is not unique",
                    ie->getInterfaceName(), ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress().str().c_str());
        if (!ie->isLoopback())
            interfaceAddrs.push_back(ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
    }
 
    rebuildRoutingTable();
}

Referenced by handleStartOperation().

isLocalAddress()

bool inet::Ted::isLocalAddress ( Ipv4Address  addr )

virtual

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

isLocalPeer()

bool inet::Ted::isLocalPeer ( Ipv4Address  inetAddr )

virtual

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

Referenced by peerRemoteInterface(), and rebuildRoutingTable().

linkIndex() [1/2]

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
}

linkIndex() [2/2]

unsigned int inet::Ted::linkIndex ( Ipv4Address  localInf )

virtual

{
    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
}

Referenced by getPeerByLocalAddress().

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

peerRemoteInterface()

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());
}

primaryAddress()

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
}

rebuildRoutingTable()

void inet::Ted::rebuildRoutingTable ( )

virtual

{
    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); // FIXME what's that?
 
        EV_DETAIL << "  inserting route: local=" << elem << " peer=" << entry->getDestination() << " interface=" << entry->getInterfaceName() << "\n";
 
        rt->addRoute(entry);
    }
}

Referenced by initializeTED().

updateTimestamp()

void inet::Ted::updateTimestamp ( TeLinkStateInfo *  link )

virtual

{
    ASSERT(link->advrouter == routerId);
 
    link->timestamp = simTime();
    link->messageId = ++maxMessageId;
}

Member Data Documentation

ift

ModuleRefByPar<IInterfaceTable> inet::Ted::ift

protected

Referenced by initialize(), and initializeTED().

interfaceAddrs

Ipv4AddressVector inet::Ted::interfaceAddrs

protected

Referenced by getLocalAddress(), handleCrashOperation(), handleStopOperation(), initializeTED(), isLocalAddress(), and rebuildRoutingTable().

maxMessageId

int inet::Ted::maxMessageId = 0

protected

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

routerId

Ipv4Address inet::Ted::routerId

protected

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

rt

ModuleRefByPar<IIpv4RoutingTable> inet::Ted::rt

protected

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

ted

TeLinkStateInfoVector inet::Ted::ted

The link state database.

(TeLinkStateInfoVector is defined in Ted.msg)

Referenced by checkLinkValidity(), getInterfaceAddrByPeerAddress(), getPeerByLocalAddress(), handleCrashOperation(), handleStopOperation(), initialize(), initializeTED(), isLocalPeer(), linkIndex(), peerRemoteInterface(), primaryAddress(), and rebuildRoutingTable().

---

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

• Ted.h
• Ted.cc