Java Route类代码示例

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
protected Route getRoute(DatapathId srcId, DatapathId dstId, U64 cookie) {
    // Return null route if srcId equals dstId
    if (srcId.equals(dstId)) return null;

    RouteId id = new RouteId(srcId, dstId);
    Route result = null;

    try {
        result = pathcache.get(id);
    } catch (Exception e) {
        log.error("{}", e);
    }

    if (log.isTraceEnabled()) {
        log.trace("getRoute: {} -> {}", id, result);
    }
    return result;
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
public ObfuscationMask getObfuscationMask(long dst, IOFSwitch sw, Route route) {
	//System.out.println("get mask for " + dst);
	
	if (!checkMaskID(dst, route)) { // need new mask
		if (obfuscationMasks.containsKey(dst)) { // remove because mask must not be used anymore
			//System.out.println("*** remove mask !***");
			obfuscationMasks.remove(dst);
			oLinkStateManager.resetNumberOfMaskUsages(dst);
		}
	}
	
	if (!obfuscationMasks.containsKey(dst)) {
		System.out.println("*** create new mask ***");
		obfuscationMasks.put(dst, createNewObfuscationMask(dst));
	}
	return obfuscationMasks.get(dst);
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
private boolean checkMaskID(long dst, Route route) {
	return true;
	/*
	if (!obfuscationMasks.containsKey(dst))
		return false;
	else if (obfuscationMasks.get(dst).getAvailableSourceIDs().size() == 0)
		return false;
	else if (obfuscationMasks.get(dst).getAvailableDestinationIDs().size() == 0)
		return false;
	
	if ((route != null) && (route.getPath().size() >= 2)) {
		for (NodePortTuple l: route.getPath()) {
			Iterator<Link> it = linkDiscoveryService.getPortLinks().get(l).iterator();
			while (it.hasNext()) {
				Link link = it.next();
				if (oLinkStateManager.getNumberOfMaskUsages(link, dst) +1 > ObfuscationPolicy.UNICITY_DISTANCE)
					return false;
			}
		}
	}
	return true;*/
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
/**
 * returns the minimum of the difference between the unicity distance and the number of mask usages for each link of the route
 * @param mask_id
 * @param route
 * @return
 */
public float getUnicityDiff(long dst, Route route) {
	return 999;/*
	//System.out.println("getUnicityDiff for mask"+mask_id);
	float min = Float.MAX_VALUE;
	
	if ((route != null) && (route.getPath().size() >= 2)) {
		for (NodePortTuple l: route.getPath()) {
			Iterator<Link> it = linkDiscoveryService.getPortLinks().get(l).iterator();
			while (it.hasNext()) {
				Link link = it.next();
				//System.out.println("getObservedEntropy="+oLinkStateManager.getObservedEntropy(link, mask_id));
				//System.out.println("getNumberOfMaskUsages="+oLinkStateManager.getNumberOfMaskUsages(link, mask_id));
				min = Math.min(min, ObfuscationPolicy.UNICITY_DISTANCE-oLinkStateManager.getNumberOfMaskUsages(link, dst));
			}
		}
	}
	return min;*/
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
public ArrayList<Route> getRoutes(DatapathId srcDpid, DatapathId dstDpid, boolean tunnelEnabled, int maxLength) {

	        ArrayList<DatapathId> v = new ArrayList<DatapathId>();
	        ArrayList<Route> routes = new ArrayList<Route>();

	        //routesList.clear();
	        ArrayList<Stack<NodePortTuple>> routesList = new ArrayList<Stack<NodePortTuple>>();

	        this.searchDfs(routesList,srcDpid,dstDpid,v,maxLength+1 /* +1 because #switches = #hops+1*/, new Stack<NodePortTuple>());
	        
	        
	        for(Stack<NodePortTuple> r:routesList){
	            ArrayList<NodePortTuple> ports = new ArrayList<NodePortTuple>();
	            for(NodePortTuple np:r){
	                ports.add(np);
	            }
	            Route path = new Route(srcDpid, dstDpid);
	            path.setPath(ports);
	            routes.add(path);
	        }
	      return routes;
	    }
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
protected Route getRoute(DatapathId srcId, DatapathId dstId, U64 cookie) {
    // Return null route if srcId equals dstId
    if (srcId.equals(dstId)) return null;


    RouteId id = new RouteId(srcId, dstId);
    Route result = null;

    try {
        result = pathcache.get(id);
    } catch (Exception e) {
        log.error("{}", e);
    }

    if (log.isTraceEnabled()) {
        log.trace("getRoute: {} -> {}", id, result);
    }
    return result;
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
MulticastTree(String IP, AttachmentPoint srcAP, MulticastController mc, MulticastGroup group) {
	sourceIP = IPv4.toIPv4Address(IP);
	memberPorts = new ConcurrentHashMap<Long, HashSet<OFPort>>();
	destinationDevices = new Vector<AttachmentPoint> ();
	this.mcObject = mc;
	routingService = mc.routingService;
	
	treeUpink = new ConcurrentHashMap<Long, Link>();
	switchService = mc.switchService;
	linkDiscService = mc.lds;
	floodlightProviderService = mc.floodlightProvider;
	flowPusher = mc.flowPusher;
	sourceAP = srcAP;
	pathsForDestinations = new ConcurrentHashMap<Long, Route>();
	multicastGroup = group;
	sendOFFlowModDropMulticastStream(switchService.getSwitch(srcAP.getSw()), true);
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
protected Route getRoute(long srcId, long dstId, long cookie) {
    // Return null route if srcId equals dstId
    if (srcId == dstId) return null;


    RouteId id = new RouteId(srcId, dstId);
    Route result = null;

    try {
        result = pathcache.get(id);
    } catch (Exception e) {
        log.error("{}", e);
    }

    if (log.isTraceEnabled()) {
        log.trace("getRoute: {} -> {}", id, result);
    }
    return result;
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
@Get("json")
public List<NodePortTuple> retrieve() {
    IRoutingService routing = 
            (IRoutingService)getContext().getAttributes().
                get(IRoutingService.class.getCanonicalName());
    
    String srcDpid = (String) getRequestAttributes().get("src-dpid");
    String srcPort = (String) getRequestAttributes().get("src-port");
    String dstDpid = (String) getRequestAttributes().get("dst-dpid");
    String dstPort = (String) getRequestAttributes().get("dst-port");

    log.debug( srcDpid + "--" + srcPort + "--" + dstDpid + "--" + dstPort);

    DatapathId longSrcDpid = DatapathId.of(srcDpid);
    OFPort shortSrcPort = OFPort.of(Integer.parseInt(srcPort));
    DatapathId longDstDpid = DatapathId.of(dstDpid);
    OFPort shortDstPort = OFPort.of(Integer.parseInt(dstPort));
    
    Route result = routing.getRoute(longSrcDpid, shortSrcPort, longDstDpid, shortDstPort, U64.of(0));
    
    if (result != null) {
        return routing.getRoute(longSrcDpid, shortSrcPort, longDstDpid, shortDstPort, U64.of(0)).getPath();
    }
    else {
        log.debug("ERROR! no route found");
        return null;
    }
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
@Override
public ArrayList<Route> getRoutes(DatapathId srcDpid, DatapathId dstDpid,
		boolean tunnelEnabled) {
	// Floodlight supports single path routing now

	// return single path now
	ArrayList<Route> result=new ArrayList<Route>();
	result.add(getRoute(srcDpid, dstDpid, U64.of(0), tunnelEnabled));
	return result;
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
public TopologyInstance(Map<DatapathId, Set<OFPort>> switchPorts,
                        Set<NodePortTuple> blockedPorts,
                        Map<NodePortTuple, Set<Link>> switchPortLinks,
                        Set<NodePortTuple> broadcastDomainPorts,
                        Set<NodePortTuple> tunnelPorts){

    // copy these structures
    this.switches = new HashSet<DatapathId>(switchPorts.keySet());
    this.switchPorts = new HashMap<DatapathId, Set<OFPort>>();
    for(DatapathId sw: switchPorts.keySet()) {
        this.switchPorts.put(sw, new HashSet<OFPort>(switchPorts.get(sw)));
    }

    this.blockedPorts = new HashSet<NodePortTuple>(blockedPorts);
    this.switchPortLinks = new HashMap<NodePortTuple, Set<Link>>();
    for(NodePortTuple npt: switchPortLinks.keySet()) {
        this.switchPortLinks.put(npt,
                                 new HashSet<Link>(switchPortLinks.get(npt)));
    }
    this.broadcastDomainPorts = new HashSet<NodePortTuple>(broadcastDomainPorts);
    this.tunnelPorts = new HashSet<NodePortTuple>(tunnelPorts);

    blockedLinks = new HashSet<Link>();
    clusters = new HashSet<Cluster>();
    switchClusterMap = new HashMap<DatapathId, Cluster>();
    destinationRootedTrees = new HashMap<DatapathId, BroadcastTree>();
    clusterBroadcastTrees = new HashMap<DatapathId, BroadcastTree>();
    clusterBroadcastNodePorts = new HashMap<DatapathId, Set<NodePortTuple>>();

    pathcache = CacheBuilder.newBuilder().concurrencyLevel(4)
                .maximumSize(1000L)
                .build(
                        new CacheLoader<RouteId, Route>() {
                            public Route load(RouteId rid) {
                                return pathCacheLoader.load(rid);
                            }
                        });
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
public void removeMemberFromTheTree(AttachmentPoint ap) {

		/* Remove flow from edge switch */
		DatapathId dSWId = ap.getSw();
		IOFSwitch dSW = switchService.getSwitch(dSWId);
		HashSet<OFPort> nps;
		Route r = pathsForDestinations.get(ap.getSw().getLong());
		if (r == null)
			return;
		NodePortTuple from = null;
		List<NodePortTuple> path = r.getPath();
		ListIterator<NodePortTuple> it = path.listIterator(path.size());
		while (it.hasPrevious()) {
			from = it.previous();
			dSWId = from.getNodeId();
			dSW = switchService.getSwitch(dSWId);
			nps = memberPorts.get(dSWId.getLong());
			if (nps == null) {
				logger.info("RemoveMemberFromTheTree: unexpected null nps");
				return;
			}
			nps.remove(from.getPortId());
			if (nps.size() != 0) {
				sendOFGroupModDelMemberMsg(dSW, from.getPortId());
				/* switch has downstream member other than one removed*/
				break;
			}
			memberPorts.remove(dSWId.getLong());
			if (dSWId.getLong() == sourceAP.getSw().getLong())
				sendOFFlowModDropMulticastStream(dSW, false);
			else 
				sendOFFlowModDelForGroup(dSW);
			pushOFDeleteGroup(dSW);
			if (it.hasPrevious())
				from = it.previous();	
		}
		pathsForDestinations.remove(ap.getSw().getLong());
	}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
@Get("json")
public List<NodePortTuple> retrieve() {
    IRoutingService routing = 
            (IRoutingService)getContext().getAttributes().
                get(IRoutingService.class.getCanonicalName());
    
    String srcDpid = (String) getRequestAttributes().get("src-dpid");
    String srcPort = (String) getRequestAttributes().get("src-port");
    String dstDpid = (String) getRequestAttributes().get("dst-dpid");
    String dstPort = (String) getRequestAttributes().get("dst-port");

    log.debug( srcDpid + "--" + srcPort + "--" + dstDpid + "--" + dstPort);

    long longSrcDpid = HexString.toLong(srcDpid);
    short shortSrcPort = Short.parseShort(srcPort);
    long longDstDpid = HexString.toLong(dstDpid);
    short shortDstPort = Short.parseShort(dstPort);
    
    Route result = routing.getRoute(longSrcDpid, shortSrcPort, longDstDpid, shortDstPort, 0);
    
    if (result!=null) {
        return routing.getRoute(longSrcDpid, shortSrcPort, longDstDpid, shortDstPort, 0).getPath();
    }
    else {
        log.debug("ERROR! no route found");
        return null;
    }
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
public TopologyInstance(Map<Long, Set<Short>> switchPorts,
                        Set<NodePortTuple> blockedPorts,
                        Map<NodePortTuple, Set<Link>> switchPortLinks,
                        Set<NodePortTuple> broadcastDomainPorts,
                        Set<NodePortTuple> tunnelPorts){

    // copy these structures
    this.switches = new HashSet<Long>(switchPorts.keySet());
    this.switchPorts = new HashMap<Long, Set<Short>>();
    for(long sw: switchPorts.keySet()) {
        this.switchPorts.put(sw, new HashSet<Short>(switchPorts.get(sw)));
    }

    this.blockedPorts = new HashSet<NodePortTuple>(blockedPorts);
    this.switchPortLinks = new HashMap<NodePortTuple, Set<Link>>();
    for(NodePortTuple npt: switchPortLinks.keySet()) {
        this.switchPortLinks.put(npt,
                                 new HashSet<Link>(switchPortLinks.get(npt)));
    }
    this.broadcastDomainPorts = new HashSet<NodePortTuple>(broadcastDomainPorts);
    this.tunnelPorts = new HashSet<NodePortTuple>(tunnelPorts);

    blockedLinks = new HashSet<Link>();
    clusters = new HashSet<Cluster>();
    switchClusterMap = new HashMap<Long, Cluster>();
    destinationRootedTrees = new HashMap<Long, BroadcastTree>();
    clusterBroadcastTrees = new HashMap<Long, BroadcastTree>();
    clusterBroadcastNodePorts = new HashMap<Long, Set<NodePortTuple>>();

    pathcache = CacheBuilder.newBuilder().concurrencyLevel(4)
                .maximumSize(1000L)
                .build(
                        new CacheLoader<RouteId, Route>() {
                            public Route load(RouteId rid) {
                                return pathCacheLoader.load(rid);
                            }
                        });
}
 

import net.floodlightcontroller.routing.Route; //导入依赖的package包/类
@Override
public ArrayList<Route> getRoutes(long srcDpid, long dstDpid,
                                  boolean tunnelEnabled) {
    // Floodlight supports single path routing now

    // return single path now
    ArrayList<Route> result=new ArrayList<Route>();
    result.add(getRoute(srcDpid, dstDpid, 0, tunnelEnabled));
    return result;
}