inet::L2NetworkConfigurator Class Reference

Computes L2 configuration of the network. More...

#include <L2NetworkConfigurator.h>

Inheritance diagram for inet::L2NetworkConfigurator:

Classes
class	InterfaceInfo
	Represents an interface in the network. More...
class	L2Topology
class	Link
class	Matcher
class	Node
	Represents a node in the network. More...

Public Types
typedef Ieee8021dInterfaceData::PortInfo	PortInfo

Public Member Functions
	L2NetworkConfigurator ()
virtual void	readInterfaceConfiguration (Node *rootNode)
	Reads interface elements from the configuration file and stores result. More...
virtual void	configureInterface (NetworkInterface *networkInterface)
	Configures the provided interface based on the current network configuration. More...

Protected Member Functions
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	extractTopology (L2Topology &topology)
	Extracts network topology by walking through the module hierarchy. More...
virtual void	computeConfiguration ()
	Computes the Layer 2 network configuration for all nodes in the network. More...
virtual bool	linkContainsMatchingHostExcept (InterfaceInfo *currentInfo, Matcher &hostMatcher, cModule *exceptModule)
void	ensureConfigurationComputed (L2Topology &topology)
virtual Topology::Link *	findLinkOut (Node *node, int gateId)
void	configureInterface (InterfaceInfo *interfaceInfo)

Protected Attributes
cXMLElement *	configuration = nullptr
L2Topology	topology
Node *	rootNode = nullptr

Detailed Description

Computes L2 configuration of the network.

See the NED definition for details.

Member Typedef Documentation

PortInfo

typedef Ieee8021dInterfaceData::PortInfo inet::L2NetworkConfigurator::PortInfo

Constructor & Destructor Documentation

L2NetworkConfigurator()

inet::L2NetworkConfigurator::L2NetworkConfigurator ( )

inline

{}

Member Function Documentation

computeConfiguration()

void inet::L2NetworkConfigurator::computeConfiguration ( )

protectedvirtual

Computes the Layer 2 network configuration for all nodes in the network.

The result of the computation is only stored in the network configurator.

{
    long initializeStartTime = clock();
    // extract topology into the L2Topology object
    TIME(extractTopology(topology));
    // read the configuration from XML; it will serve as input for port assignment
    TIME(readInterfaceConfiguration(rootNode));
    printElapsedTime("initialize", initializeStartTime);
}

Referenced by ensureConfigurationComputed().

configureInterface() [1/2]

void inet::L2NetworkConfigurator::configureInterface ( InterfaceInfo *  interfaceInfo )

protected

{
    NetworkInterface *networkInterface = interfaceInfo->networkInterface;
    auto interfaceData = networkInterface->getProtocolDataForUpdate<Ieee8021dInterfaceData>();
 
    interfaceData->setLinkCost(interfaceInfo->portData.linkCost);
    interfaceData->setPriority(interfaceInfo->portData.priority);
    interfaceData->setEdge(interfaceInfo->portData.edge);
}

Referenced by configureInterface().

configureInterface() [2/2]

void inet::L2NetworkConfigurator::configureInterface ( NetworkInterface *  networkInterface )

virtual

Configures the provided interface based on the current network configuration.

{
    ensureConfigurationComputed(topology);
    cModule *networkNodeModule = findContainingNode(networkInterface);
    // TODO avoid linear search
    for (int i = 0; i < topology.getNumNodes(); i++) {
        Node *node = (Node *)topology.getNode(i);
        if (node->module == networkNodeModule) {
            for (auto& elem : node->interfaceInfos) {
                InterfaceInfo *interfaceInfo = elem;
                if (interfaceInfo->networkInterface == networkInterface)
                    return configureInterface(interfaceInfo);
            }
        }
    }
}

ensureConfigurationComputed()

void inet::L2NetworkConfigurator::ensureConfigurationComputed ( L2Topology &  topology )

protected

{
    if (topology.getNumNodes() == 0)
        computeConfiguration();
}

Referenced by configureInterface(), and initialize().

extractTopology()

void inet::L2NetworkConfigurator::extractTopology ( L2Topology &  topology )

protectedvirtual

Extracts network topology by walking through the module hierarchy.

Creates vertices from modules having @networkNode property. Creates edges from connections (wired and wireless) between network interfaces.

{
    topology.extractByProperty("networkNode");
    EV_DEBUG << "Topology found " << topology.getNumNodes() << " nodes\n";
 
    if (topology.getNumNodes() == 0)
        throw cRuntimeError("Empty network!");
 
    // extract nodes, fill in interfaceTable and routingTable members in node
    for (int i = 0; i < topology.getNumNodes(); i++) {
        Node *node = (Node *)topology.getNode(i);
        node->module = node->getModule();
        cModule *ifTable = node->module->getSubmodule("interfaceTable");
 
        // EthernetHost has no InterfaceTable
        if (ifTable) // todo:
            node->interfaceTable = dynamic_cast<IInterfaceTable *>(ifTable);
    }
 
    // extract links and interfaces
    std::set<NetworkInterface *> interfacesSeen;
    std::queue<Node *> Q; // unvisited nodes in the graph
 
    rootNode = (Node *)topology.getNode(0);
    Q.push(rootNode);
 
    while (!Q.empty()) {
        Node *node = Q.front();
        Q.pop();
        IInterfaceTable *interfaceTable = node->interfaceTable;
 
        if (interfaceTable) {
            // push neighbors to the queue
            for (int i = 0; i < interfaceTable->getNumInterfaces(); i++) {
                NetworkInterface *networkInterface = interfaceTable->getInterface(i);
                if (interfacesSeen.count(networkInterface) == 0) {
                    // visiting this interface
                    interfacesSeen.insert(networkInterface);
 
                    Topology::Link *linkOut = findLinkOut(node, networkInterface->getNodeOutputGateId());
 
                    Node *childNode = nullptr;
 
                    if (linkOut) {
                        childNode = (Node *)linkOut->getLinkOutRemoteNode();
                        Q.push(childNode);
                    }
 
                    InterfaceInfo *info = new InterfaceInfo(node, childNode, networkInterface);
                    node->interfaceInfos.push_back(info);
                }
            }
        }
    }
}

Referenced by computeConfiguration().

findLinkOut()

Topology::Link * inet::L2NetworkConfigurator::findLinkOut ( Node *  node, int  gateId  )

protectedvirtual

{
    for (int i = 0; i < node->getNumOutLinks(); i++)
        if (node->getLinkOut(i)->getLinkOutLocalGateId() == gateId)
            return node->getLinkOut(i);
 
    return nullptr;
}

Referenced by extractTopology().

handleMessage()

virtual void inet::L2NetworkConfigurator::handleMessage ( cMessage *  msg )

inlineoverrideprotectedvirtual

{ throw cRuntimeError("this module doesn't handle messages, it runs only in initialize()"); }

initialize()

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

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL)
        configuration = par("config");
    else if (stage == INITSTAGE_NETWORK_CONFIGURATION)
        ensureConfigurationComputed(topology);
}

linkContainsMatchingHostExcept()

bool inet::L2NetworkConfigurator::linkContainsMatchingHostExcept ( InterfaceInfo *  currentInfo, Matcher &  hostMatcher, cModule *  exceptModule  )

protectedvirtual

{
    Node *childNode = currentInfo->childNode;
 
    if (childNode == nullptr)
        return false;
 
    cModule *hostModule = childNode->module;
 
    std::string hostFullPath = hostModule->getFullPath();
    std::string hostShortenedFullPath = hostFullPath.substr(hostFullPath.find('.') + 1);
 
    if (hostModule == exceptModule)
        return false;
 
    if (hostMatcher.matches(hostShortenedFullPath.c_str()) || hostMatcher.matches(hostFullPath.c_str()))
        return true;
 
    return false;
}

Referenced by readInterfaceConfiguration().

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

readInterfaceConfiguration()

void inet::L2NetworkConfigurator::readInterfaceConfiguration ( Node *  rootNode )

virtual

Reads interface elements from the configuration file and stores result.

{
    std::set<NetworkInterface *> matchedBefore;
    cXMLElementList interfaceElements = configuration->getChildrenByTagName("interface");
 
    for (auto& interfaceElements_i : interfaceElements) {
        std::set<NetworkInterface *> interfacesSeen;
        cXMLElement *interfaceElement = interfaceElements_i;
 
        const char *hostAttr = interfaceElement->getAttribute("hosts"); // "host* router[0..3]"
        const char *interfaceAttr = interfaceElement->getAttribute("names"); // i.e. interface names, like "eth* ppp0"
        const char *towardsAttr = interfaceElement->getAttribute("towards"); // neighbor host names, like "ap switch"
        const char *amongAttr = interfaceElement->getAttribute("among"); // neighbor host names, like "host[*] router1"
        const char *portsAttr = interfaceElement->getAttribute("ports"); // switch gate indices, like "0 1 2"
 
        // Begin RSTP properties, for more information see RSTP module
        const char *cost = interfaceElement->getAttribute("cost");
        const char *priority = interfaceElement->getAttribute("priority");
        const char *edge = interfaceElement->getAttribute("edge");
        // End RSTP properties
 
        if (amongAttr && *amongAttr) { // among="X Y Z" means hosts = "X Y Z" towards = "X Y Z"
            if ((hostAttr && *hostAttr) || (towardsAttr && *towardsAttr))
                throw cRuntimeError("The 'hosts'/'towards' and 'among' attributes are mutually exclusive, at %s",
                        interfaceElement->getSourceLocation());
            towardsAttr = hostAttr = amongAttr;
        }
 
        try {
            // parse host/interface/towards expressions
            Matcher hostMatcher(hostAttr);
            Matcher interfaceMatcher(interfaceAttr);
            Matcher towardsMatcher(towardsAttr);
            Matcher portsMatcher(portsAttr);
 
            std::queue<Node *> Q;
            Q.push(rootNode);
 
            // configure port type/cost/priority constraints on matching interfaces
            while (!Q.empty()) {
                Node *currentNode = Q.front();
                Q.pop();
 
                for (unsigned int i = 0; i < currentNode->interfaceInfos.size(); i++) {
                    NetworkInterface *ifEntry = currentNode->interfaceInfos[i]->networkInterface;
                    if (interfacesSeen.count(ifEntry) == 0 && matchedBefore.count(ifEntry) == 0) {
                        cModule *hostModule = currentNode->module;
                        std::string hostFullPath = hostModule->getFullPath();
                        std::string hostShortenedFullPath = hostFullPath.substr(hostFullPath.find('.') + 1);
 
                        // loopback interfaces
                        if (ifEntry->getNodeInputGateId() == -1) {
                            interfacesSeen.insert(ifEntry);
                            continue;
                        }
 
                        cGate *gate = hostModule->gate(ifEntry->getNodeInputGateId());
                        std::stringstream ss;
                        ss << gate->getIndex();
                        std::string port = ss.str();
 
                        // Note: "hosts", "interfaces" and "towards" must ALL match on the interface for the rule to apply
                        if ((hostMatcher.matchesAny() || hostMatcher.matches(hostShortenedFullPath.c_str()) || hostMatcher.matches(hostFullPath.c_str()))
                            && (interfaceMatcher.matchesAny() || interfaceMatcher.matches(ifEntry->getInterfaceName()))
                            && (towardsMatcher.matchesAny() || linkContainsMatchingHostExcept(currentNode->interfaceInfos[i], towardsMatcher, hostModule))
                            && (portsMatcher.matchesAny() || portsMatcher.matches(port.c_str())))
                        {
                            // cost
                            if (!opp_isempty(cost))
                                currentNode->interfaceInfos[i]->portData.linkCost = atoi(cost);
 
                            // priority
                            if (!opp_isempty(priority))
                                currentNode->interfaceInfos[i]->portData.priority = atoi(priority);
 
                            // edge
                            if (!opp_isempty(edge))
                                currentNode->interfaceInfos[i]->portData.edge = strcmp(edge, "true") ? false : true;
                            EV_DEBUG << hostModule->getFullPath() << ":" << ifEntry->getInterfaceName() << endl;
 
                            matchedBefore.insert(ifEntry);
                        }
 
                        interfacesSeen.insert(ifEntry);
                        if (currentNode->interfaceInfos[i]->childNode)
                            Q.push(currentNode->interfaceInfos[i]->childNode);
                    }
                }
            }
        }
        catch (std::exception& e) {
            throw cRuntimeError("Error in XML <interface> element at %s: %s", interfaceElement->getSourceLocation(),
                    e.what());
        }
    }
}

Referenced by computeConfiguration().

Member Data Documentation

configuration

cXMLElement* inet::L2NetworkConfigurator::configuration = nullptr

protected

Referenced by initialize(), and readInterfaceConfiguration().

rootNode

Node* inet::L2NetworkConfigurator::rootNode = nullptr

protected

Referenced by computeConfiguration(), extractTopology(), and readInterfaceConfiguration().

topology

L2Topology inet::L2NetworkConfigurator::topology

protected

Referenced by computeConfiguration(), configureInterface(), ensureConfigurationComputed(), extractTopology(), and initialize().

---

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

• L2NetworkConfigurator.h
• L2NetworkConfigurator.cc