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 (InterfaceEntry *interfaceEntry)
	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::LinkOut *	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

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

Constructor & Destructor Documentation

inet::L2NetworkConfigurator::L2NetworkConfigurator ( )

inline

{ }

Member Function Documentation

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.

Referenced by ensureConfigurationComputed().

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

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

protected

Referenced by configureInterface(), inet::L2NodeConfigurator::configureNode(), and inet::L2NodeConfigurator::receiveSignal().

{
    InterfaceEntry *interfaceEntry = interfaceInfo->interfaceEntry;
    Ieee8021dInterfaceData *interfaceData = interfaceEntry->ieee8021dData();

    interfaceData->setLinkCost(interfaceInfo->portData.linkCost);
    interfaceData->setPriority(interfaceInfo->portData.priority);
    interfaceData->setEdge(interfaceInfo->portData.edge);
}

void inet::L2NetworkConfigurator::configureInterface ( InterfaceEntry *  interfaceEntry )

virtual

Configures the provided interface based on the current network configuration.

{
    ensureConfigurationComputed(topology);
    cModule *networkNodeModule = findContainingNode(interfaceEntry->getInterfaceModule());
    // 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->interfaceEntry == interfaceEntry)
                    return configureInterface(interfaceInfo);
            }
        }
    }
}

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

protected

Referenced by configureInterface(), and initialize().

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

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

protectedvirtual

Extracts network topology by walking through the module hierarchy.

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

Referenced by computeConfiguration().

{
    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");

        // EtherHost has no InterfaceTable
        if (ifTable) //todo:
            node->interfaceTable = dynamic_cast<IInterfaceTable *>(ifTable);
    }

    // extract links and interfaces
    std::set<InterfaceEntry *> 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++) {
                InterfaceEntry *interfaceEntry = interfaceTable->getInterface(i);
                if (interfacesSeen.count(interfaceEntry) == 0) {
                    // visiting this interface
                    interfacesSeen.insert(interfaceEntry);

                    Topology::LinkOut *linkOut = findLinkOut(node, interfaceEntry->getNodeOutputGateId());

                    Node *childNode = nullptr;

                    if (linkOut) {
                        childNode = (Node *)linkOut->getRemoteNode();
                        Q.push(childNode);
                    }

                    InterfaceInfo *info = new InterfaceInfo(node, childNode, interfaceEntry);
                    node->interfaceInfos.push_back(info);
                }
            }
        }
    }
}

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

protectedvirtual

Referenced by extractTopology().

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


    return nullptr;
}

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

inlineoverrideprotectedvirtual

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

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

overrideprotectedvirtual

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

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

protectedvirtual

Referenced by readInterfaceConfiguration().

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

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

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

virtual

Reads interface elements from the configuration file and stores result.

Referenced by computeConfiguration().

{
    std::set<InterfaceEntry *> matchedBefore;
    cXMLElementList interfaceElements = configuration->getChildrenByTagName("interface");

    for (auto & interfaceElements_i : interfaceElements) {
        std::set<InterfaceEntry *> 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++) {
                    InterfaceEntry *ifEntry = currentNode->interfaceInfos[i]->interfaceEntry;
                    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->getFullName()))
                            && (towardsMatcher.matchesAny() || linkContainsMatchingHostExcept(currentNode->interfaceInfos[i], towardsMatcher, hostModule))
                            && (portsMatcher.matchesAny() || portsMatcher.matches(port.c_str())))
                        {
                            // cost
                            if (isNotEmpty(cost))
                                currentNode->interfaceInfos[i]->portData.linkCost = atoi(cost);

                            // priority
                            if (isNotEmpty(priority))
                                currentNode->interfaceInfos[i]->portData.priority = atoi(priority);

                            //edge
                            if (isNotEmpty(edge))
                                currentNode->interfaceInfos[i]->portData.edge = strcmp(edge, "true") ? false : true;
                            EV_DEBUG << hostModule->getFullPath() << ":" << ifEntry->getFullName() << 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());
        }
    }
}

Member Data Documentation

cXMLElement* inet::L2NetworkConfigurator::configuration = nullptr

protected

Referenced by initialize(), and readInterfaceConfiguration().

Node* inet::L2NetworkConfigurator::rootNode = nullptr

protected

Referenced by computeConfiguration(), and extractTopology().

L2Topology inet::L2NetworkConfigurator::topology

protected

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

---

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

• L2NetworkConfigurator.h
• L2NetworkConfigurator.cc