Java RouteEntry.nextHop方法代码示例

import org.onosproject.routing.RouteEntry; //导入方法依赖的package包/类
@Override
public ConnectPoint getEgressConnectPoint(IpAddress dstIpAddress) {
    LocationType type = getLocationType(dstIpAddress);
    if (type == LocationType.LOCAL) {
        Set<Host> hosts = hostService.getHostsByIp(dstIpAddress);
        if (!hosts.isEmpty()) {
            return hosts.iterator().next().location();
        } else {
            hostService.startMonitoringIp(dstIpAddress);
            return null;
        }
    } else if (type == LocationType.INTERNET) {
        IpAddress nextHopIpAddress = null;
        RouteEntry routeEntry = getLongestMatchableRouteEntry(dstIpAddress);
        if (routeEntry != null) {
            nextHopIpAddress = routeEntry.nextHop();
            Interface it = routingConfigurationService
                    .getMatchingInterface(nextHopIpAddress);
            if (it != null) {
                return it.connectPoint();
            } else {
                return null;
            }
        } else {
            return null;
        }
    } else {
        return null;
    }
}
 

import org.onosproject.routing.RouteEntry; //导入方法依赖的package包/类
/**
 * Processes adding a route entry.
 * <p>
 * The route entry is added to the radix tree. If there was an existing
 * next hop for this prefix, but the next hop was different, then the
 * old route entry is deleted.
 * </p>
 * <p>
 * NOTE: Currently, we don't handle routes if the next hop is within the
 * SDN domain.
 * </p>
 *
 * @param routeEntry the route entry to add
 * @param withdrawPrefixes the collection of accumulated prefixes whose
 * intents will be withdrawn
 * @return the corresponding FIB entry change, or null
 */
private FibEntry processRouteAdd(RouteEntry routeEntry,
                                 Collection<IpPrefix> withdrawPrefixes) {
    log.debug("Processing route add: {}", routeEntry);

    // Find the old next-hop if we are updating an old route entry
    IpAddress oldNextHop = null;
    RouteEntry oldRouteEntry = findRibRoute(routeEntry.prefix());
    if (oldRouteEntry != null) {
        oldNextHop = oldRouteEntry.nextHop();
    }

    // Add the new route to the RIB
    addRibRoute(routeEntry);

    if (oldNextHop != null) {
        if (oldNextHop.equals(routeEntry.nextHop())) {
            return null;            // No change
        }
        //
        // Update an existing nexthop for the prefix.
        // We need to remove the old flows for this prefix from the
        // switches before the new flows are added.
        //
        withdrawPrefixes.add(routeEntry.prefix());
    }

    if (routingConfigurationService.isIpPrefixLocal(routeEntry.prefix())) {
        // Route originated by local SDN domain
        // We don't handle these here, reactive routing APP will handle
        // these
        log.debug("Own route {} to {}",
                routeEntry.prefix(), routeEntry.nextHop());
        return null;
    }

    //
    // Find the MAC address of next hop router for this route entry.
    // If the MAC address can not be found in ARP cache, then this prefix
    // will be put in routesWaitingOnArp queue. Otherwise, generate
    // a new route intent.
    //

    // Monitor the IP address for updates of the MAC address
    hostService.startMonitoringIp(routeEntry.nextHop());

    // Check if we know the MAC address of the next hop
    MacAddress nextHopMacAddress = ip2Mac.get(routeEntry.nextHop());
    if (nextHopMacAddress == null) {
        Set<Host> hosts = hostService.getHostsByIp(routeEntry.nextHop());
        if (!hosts.isEmpty()) {
            nextHopMacAddress = hosts.iterator().next().mac();
        }
        if (nextHopMacAddress != null) {
            ip2Mac.put(routeEntry.nextHop(), nextHopMacAddress);
        }
    }
    if (nextHopMacAddress == null) {
        routesWaitingOnArp.put(routeEntry.nextHop(), routeEntry);
        return null;
    }
    return new FibEntry(routeEntry.prefix(), routeEntry.nextHop(),
            nextHopMacAddress);
}