Floodlight源码阅读之网络拓扑

在上一篇文章中介绍Floodlight怎样做拓扑发现，这篇文章介绍一下网络拓扑是怎样形成的。TopologyManager这个类负责网络拓扑的产生。这个类首先实现了IFloodlightModule这个接口，是Floodlight的一个模块。其实是实现了ILinkDiscoveryListener用于监听网络中链路的变化；还实现了IOFMessageListener用于接收和处理网络包。

和其他的Floodlight模块一样，首先看启动方法startup。

    @Override
    public void startUp(FloodlightModuleContext context) {
        clearCurrentTopology();
        // Initialize role to floodlight provider role.
        this.role = floodlightProviderService.getRole();

        ScheduledExecutorService ses = threadPoolService.getScheduledExecutor();
        newInstanceTask = new SingletonTask(ses, new UpdateTopologyWorker());

        if (role != HARole.STANDBY) {
            newInstanceTask.reschedule(TOPOLOGY_COMPUTE_INTERVAL_MS, TimeUnit.MILLISECONDS);
        }

        linkDiscoveryService.addListener(this);
        floodlightProviderService.addOFMessageListener(OFType.PACKET_IN, this);
        floodlightProviderService.addHAListener(this.haListener);
        addRestletRoutable();
    }

在这个启动方法中第一行就是清理拓扑

    /**
     * Clears the current topology. Note that this does NOT
     * send out updates.
     */
    public void clearCurrentTopology() {
        this.clear();
        linksUpdated = true;
        dtLinksUpdated = true;
        tunnelPortsUpdated = true;
        createNewInstance("startup");
        lastUpdateTime = new Date();
    }

clear方法清理所以内存中保存的节点链路拓扑信息。

    public void clear() {
        switchPorts.clear();
        tunnelPorts.clear();
        switchPortLinks.clear();
        portBroadcastDomainLinks.clear();
        directLinks.clear();
    }

关于这个nosql内存数据库下一章讲解。

当清理完数据后开始创建新的拓扑

  /**
     * This function computes a new topology instance.
     * It ignores links connected to all broadcast domain ports
     * and tunnel ports. The method returns if a new instance of
     * topology was created or not.
     */
    protected boolean createNewInstance(String reason) {
        Set<NodePortTuple> blockedPorts = new HashSet<NodePortTuple>();

        if (!linksUpdated) return false;

        Map<NodePortTuple, Set<Link>> openflowLinks;
        openflowLinks =
                new HashMap<NodePortTuple, Set<Link>>();
        Set<NodePortTuple> nptList = switchPortLinks.keySet();

        if (nptList != null) {
            for (NodePortTuple npt : nptList) {
                Set<Link> linkSet = switchPortLinks.get(npt);
                if (linkSet == null) continue;
                openflowLinks.put(npt, new HashSet<Link>(linkSet));
            }
        }

        // Identify all broadcast domain ports.
        // Mark any port that has inconsistent set of links
        // as broadcast domain ports as well.
        Set<NodePortTuple> broadcastDomainPorts =
                identifyBroadcastDomainPorts();

        // Remove all links incident on broadcast domain ports.
        for (NodePortTuple npt : broadcastDomainPorts) {
            if (switchPortLinks.get(npt) == null) continue;
            for (Link link : switchPortLinks.get(npt)) {
                removeLinkFromStructure(openflowLinks, link);
            }
        }

        // Remove all tunnel links.
        for (NodePortTuple npt : tunnelPorts) {
            if (switchPortLinks.get(npt) == null) continue;
            for (Link link : switchPortLinks.get(npt)) {
                removeLinkFromStructure(openflowLinks, link);
            }
        }
        //switchPorts contains only ports that are part of links. Calculation of broadcast ports needs set of all ports.
        Map<DatapathId, Set<OFPort>> allPorts = new HashMap<DatapathId, Set<OFPort>>();
        ;
        for (DatapathId sw : switchPorts.keySet()) {
            allPorts.put(sw, this.getPorts(sw));
        }

        TopologyInstance nt = new TopologyInstance(switchPorts,
                blockedPorts,
                openflowLinks,
                broadcastDomainPorts,
                tunnelPorts,
                switchPortLinks,
                allPorts,
                portBroadcastDomainLinks);

        nt.compute();

        // We set the instances with and without tunnels to be identical.
        // If needed, we may compute them differently.
        currentInstance = nt;
        currentInstanceWithoutTunnels = nt;

        TopologyEventInfo topologyInfo =
                new TopologyEventInfo(0, nt.getClusters().size(),
                        new HashMap<DatapathId, List<NodePortTuple>>(),
                        0);
        eventCategory.newEventWithFlush(new TopologyEvent(reason, topologyInfo));

        return true;
    }

主要计算方法是nt.conpute()这个方法

这个方法有七步看代码如下

    public void compute() {
        // Step 1: Compute clusters ignoring broadcast domain links
        // Create nodes for clusters in the higher level topology
        // Must ignore blocked links.
        identifyOpenflowDomains();

        // Step 1.1: Add links to clusters
        // Avoid adding blocked links to clusters
        addLinksToOpenflowDomains();

        // Step 2. Compute shortest path trees in each cluster for
        // unicast routing.  The trees are rooted at the destination.
        // Cost for tunnel links and direct links are the same.
        calculateShortestPathTreeInClusters();
		
		// Step 3. Compute broadcast tree in each cluster.
        // Cost for tunnel links are high to discourage use of
        // tunnel links.  The cost is set to the number of nodes
        // in the cluster + 1, to use as minimum number of
        // clusters as possible.
        calculateBroadcastNodePortsInClusters();
        
        // Step 4. Compute e2e shortest path trees on entire topology for unicast routing.
		// The trees are rooted at the destination.
        // Cost for tunnel links and direct links are the same.
		calculateAllShortestPaths();

        // Compute the archipelagos (def: cluster of islands). An archipelago will
        // simply be a group of connected islands. Each archipelago will have its own
        // finiteBroadcastTree which will be randomly chosen.
        calculateArchipelagos();
		
		// Step 5. Compute broadcast tree for the whole topology (needed to avoid loops).
        // Cost for tunnel links are high to discourage use of
        // tunnel links.  The cost is set to the number of nodes
        // in the cluster + 1, to use as minimum number of
        // clusters as possible.
        calculateAllBroadcastNodePorts();

		// Step 6. Compute set of ports for broadcasting. Edge ports are included.
       	calculateBroadcastPortMap();
       	
        // Step 7. print topology.
        printTopology();
    }

identifyOpenflowDomains这个方法通过深度优先遍历算法遍历拓扑节点

addLinksToOpenflowDomains添加集群直接的的link

calculateShortestPathTreeInClusters通过给链路添加权重在通clusterDijkstra最短路径算法计算拓扑最短路径

后面几个方法是整个网络的最短路径计算，详细部分文章后面一一解说