Java FibEntry类代码示例

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Tests adding a IPv4 route entry.
 */
@Test
public void testIpv4RouteAdd() {
    // Construct a route entry
    IpPrefix prefix = Ip4Prefix.valueOf("1.1.1.0/24");
    IpAddress nextHopIp = Ip4Address.valueOf("192.168.10.1");

    RouteEntry routeEntry = new RouteEntry(prefix, nextHopIp);

    // Expected FIB entry
    FibEntry fibEntry = new FibEntry(prefix, nextHopIp,
            MacAddress.valueOf("00:00:00:00:00:01"));

    fibListener.update(Collections.singletonList(new FibUpdate(
            FibUpdate.Type.UPDATE, fibEntry)), Collections.emptyList());

    replay(fibListener);

    router.processRouteUpdates(Collections.singletonList(
            new RouteUpdate(RouteUpdate.Type.UPDATE, routeEntry)));

    verify(fibListener);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Tests adding a IPv6 route entry.
 */
@Test
public void testIpv6RouteAdd() {
    // Construct a route entry
    IpPrefix prefix = Ip6Prefix.valueOf("4000::/64");
    IpAddress nextHopIp = Ip6Address.valueOf("1000::1");

    RouteEntry routeEntry = new RouteEntry(prefix, nextHopIp);

    // Expected FIB entry
    FibEntry fibEntry = new FibEntry(prefix, nextHopIp,
            MacAddress.valueOf("00:00:00:00:00:04"));

    fibListener.update(Collections.singletonList(new FibUpdate(
            FibUpdate.Type.UPDATE, fibEntry)), Collections.emptyList());

    replay(fibListener);

    router.processRouteUpdates(Collections.singletonList(
            new RouteUpdate(RouteUpdate.Type.UPDATE, routeEntry)));

    verify(fibListener);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Tests deleting a IPv4 route entry.
 */
@Test
public void testIpv4RouteDelete() {
    // Firstly add a route
    testIpv4RouteAdd();

    RouteEntry deleteRouteEntry = new RouteEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"),
            Ip4Address.valueOf("192.168.10.1"));

    FibEntry deleteFibEntry = new FibEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"), null, null);

    reset(fibListener);
    fibListener.update(Collections.emptyList(), Collections.singletonList(
            new FibUpdate(FibUpdate.Type.DELETE, deleteFibEntry)));

    replay(fibListener);

    router.processRouteUpdates(Collections.singletonList(
            new RouteUpdate(RouteUpdate.Type.DELETE, deleteRouteEntry)));

    verify(fibListener);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Tests deleting a IPv6 route entry.
 */
@Test
public void testIpv6RouteDelete() {
    // Firstly add a route
    testIpv6RouteAdd();

    RouteEntry deleteRouteEntry = new RouteEntry(
            Ip6Prefix.valueOf("4000::/64"),
            Ip6Address.valueOf("1000::1"));

    FibEntry deleteFibEntry = new FibEntry(
            Ip6Prefix.valueOf("4000::/64"), null, null);

    reset(fibListener);
    fibListener.update(Collections.emptyList(), Collections.singletonList(
            new FibUpdate(FibUpdate.Type.DELETE, deleteFibEntry)));

    replay(fibListener);

    router.processRouteUpdates(Collections.singletonList(
            new RouteUpdate(RouteUpdate.Type.DELETE, deleteRouteEntry)));

    verify(fibListener);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
private synchronized void deleteFibEntry(Collection<FibUpdate> withdraws) {
    FlowRuleOperations.Builder builder = FlowRuleOperations.builder();

    for (FibUpdate update : withdraws) {
        FibEntry entry = update.entry();

        Group group = deleteNextHop(entry.prefix());
        if (group == null) {
            log.warn("Group not found when deleting {}", entry);
            return;
        }

        FlowRule flowRule = generateRibFlowRule(entry.prefix(), group);

        builder.remove(flowRule);
    }

    flowService.apply(builder.build());
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Tests adding a route entry.
 */
@Test
public void testRouteAdd() {
    // Construct a route entry
    IpPrefix prefix = Ip4Prefix.valueOf("1.1.1.0/24");
    IpAddress nextHopIp = Ip4Address.valueOf("192.168.10.1");

    RouteEntry routeEntry = new RouteEntry(prefix, nextHopIp);

    // Expected FIB entry
    FibEntry fibEntry = new FibEntry(prefix, nextHopIp,
                                     MacAddress.valueOf("00:00:00:00:00:01"));

    fibListener.update(Collections.singletonList(new FibUpdate(
            FibUpdate.Type.UPDATE, fibEntry)), Collections.emptyList());

    replay(fibListener);

    router.processRouteUpdates(Collections.singletonList(
            new RouteUpdate(RouteUpdate.Type.UPDATE, routeEntry)));

    verify(fibListener);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Tests deleting a route entry.
 */
@Test
public void testRouteDelete() {
    // Firstly add a route
    testRouteAdd();

    RouteEntry deleteRouteEntry = new RouteEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"),
            Ip4Address.valueOf("192.168.10.1"));

    FibEntry deleteFibEntry = new FibEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"), null, null);

    reset(fibListener);
    fibListener.update(Collections.emptyList(), Collections.singletonList(
            new FibUpdate(FibUpdate.Type.DELETE, deleteFibEntry)));

    replay(fibListener);

    router.processRouteUpdates(Collections.singletonList(
            new RouteUpdate(RouteUpdate.Type.DELETE, deleteRouteEntry)));

    verify(fibListener);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Processes route updates.
 *
 * @param routeUpdates the route updates to process
 */
void processRouteUpdates(Collection<RouteUpdate> routeUpdates) {
    synchronized (this) {
        Collection<IpPrefix> withdrawPrefixes = new LinkedList<>();
        Collection<FibUpdate> fibUpdates = new LinkedList<>();
        Collection<FibUpdate> fibWithdraws = new LinkedList<>();

        for (RouteUpdate update : routeUpdates) {
            switch (update.type()) {
            case UPDATE:

                FibEntry fib = processRouteAdd(update.routeEntry(),
                        withdrawPrefixes);
                if (fib != null) {
                    fibUpdates.add(new FibUpdate(FibUpdate.Type.UPDATE, fib));
                }

                break;
            case DELETE:
                processRouteDelete(update.routeEntry(), withdrawPrefixes);

                break;
            default:
                log.error("Unknown update Type: {}", update.type());
                break;
            }
        }

        withdrawPrefixes.forEach(p -> fibWithdraws.add(new FibUpdate(
                FibUpdate.Type.DELETE, new FibEntry(p, null, null))));

        if (!fibUpdates.isEmpty() || !fibWithdraws.isEmpty()) {
            fibComponent.update(fibUpdates, fibWithdraws);
        }
    }
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Tests updating a IPv4 route entry.
 */
@Test
public void testRouteUpdate() {
    // Firstly add a route
    testIpv4RouteAdd();

    // Route entry with updated next hop for the original prefix
    RouteEntry routeEntryUpdate = new RouteEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"),
            Ip4Address.valueOf("192.168.20.1"));

    // The old FIB entry will be withdrawn
    FibEntry withdrawFibEntry = new FibEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"), null, null);

    // A new FIB entry will be added
    FibEntry updateFibEntry = new FibEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"),
            Ip4Address.valueOf("192.168.20.1"),
            MacAddress.valueOf("00:00:00:00:00:02"));

    reset(fibListener);
    fibListener.update(Collections.singletonList(new FibUpdate(
                                FibUpdate.Type.UPDATE, updateFibEntry)),
                       Collections.singletonList(new FibUpdate(
                                FibUpdate.Type.DELETE, withdrawFibEntry)));
    replay(fibListener);

    reset(routingConfigurationService);
    expect(routingConfigurationService.isIpPrefixLocal(
            anyObject(IpPrefix.class))).andReturn(false);
    replay(routingConfigurationService);

    router.processRouteUpdates(Collections.singletonList(new RouteUpdate(
            RouteUpdate.Type.UPDATE, routeEntryUpdate)));

    verify(fibListener);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Tests updating a IPv6 route entry.
 */
@Test
public void testIpv6RouteUpdate() {
    // Firstly add a route
    testIpv6RouteAdd();

    // Route entry with updated next hop for the original prefix
    RouteEntry routeEntryUpdate = new RouteEntry(
            Ip6Prefix.valueOf("4000::/64"),
            Ip6Address.valueOf("2000::1"));

    // The old FIB entry will be withdrawn
    FibEntry withdrawFibEntry = new FibEntry(
            Ip6Prefix.valueOf("4000::/64"), null, null);

    // A new FIB entry will be added
    FibEntry updateFibEntry = new FibEntry(
            Ip6Prefix.valueOf("4000::/64"),
            Ip6Address.valueOf("2000::1"),
            MacAddress.valueOf("00:00:00:00:00:05"));

    reset(fibListener);
    fibListener.update(Collections.singletonList(new FibUpdate(
                               FibUpdate.Type.UPDATE, updateFibEntry)),
                       Collections.singletonList(new FibUpdate(
                               FibUpdate.Type.DELETE, withdrawFibEntry)));
    replay(fibListener);

    reset(routingConfigurationService);
    expect(routingConfigurationService.isIpPrefixLocal(
            anyObject(IpPrefix.class))).andReturn(false);
    replay(routingConfigurationService);

    router.processRouteUpdates(Collections.singletonList(new RouteUpdate(
            RouteUpdate.Type.UPDATE, routeEntryUpdate)));

    verify(fibListener);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
private void updateFibEntry(Collection<FibUpdate> updates) {
    Map<FibEntry, Group> toInstall = new HashMap<>(updates.size());

    for (FibUpdate update : updates) {
        FibEntry entry = update.entry();

        addNextHop(entry);

        Group group;
        synchronized (pendingUpdates) {
            NextHop nextHop = nextHops.get(entry.nextHopIp());
            group = groupService.getGroup(deviceId,
                                          new DefaultGroupKey(
                                          appKryo.serialize(nextHop.group())));

            if (group == null) {
                log.debug("Adding pending flow {}", update.entry());
                pendingUpdates.put(nextHop.group(), update.entry());
                continue;
            }
        }

        toInstall.put(update.entry(), group);
    }

    installFlows(toInstall);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
private void installFlows(Map<FibEntry, Group> entriesToInstall) {
    FlowRuleOperations.Builder builder = FlowRuleOperations.builder();

    for (Map.Entry<FibEntry, Group> entry : entriesToInstall.entrySet()) {
        FibEntry fibEntry = entry.getKey();
        Group group = entry.getValue();

        FlowRule flowRule = generateRibFlowRule(fibEntry.prefix(), group);

        builder.add(flowRule);
    }

    flowService.apply(builder.build());
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Tests updating a route entry.
 */
@Test
public void testRouteUpdate() {
    // Firstly add a route
    testRouteAdd();

    // Route entry with updated next hop for the original prefix
    RouteEntry routeEntryUpdate = new RouteEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"),
            Ip4Address.valueOf("192.168.20.1"));

    // The old FIB entry will be withdrawn
    FibEntry withdrawFibEntry = new FibEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"), null, null);

    // A new FIB entry will be added
    FibEntry updateFibEntry = new FibEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"),
            Ip4Address.valueOf("192.168.20.1"),
            MacAddress.valueOf("00:00:00:00:00:02"));

    reset(fibListener);
    fibListener.update(Collections.singletonList(new FibUpdate(
                                FibUpdate.Type.UPDATE, updateFibEntry)),
                       Collections.singletonList(new FibUpdate(
                                FibUpdate.Type.DELETE, withdrawFibEntry)));
    replay(fibListener);

    reset(routingConfigurationService);
    expect(routingConfigurationService.isIpPrefixLocal(
            anyObject(IpPrefix.class))).andReturn(false);
    replay(routingConfigurationService);

    router.processRouteUpdates(Collections.singletonList(new RouteUpdate(
            RouteUpdate.Type.UPDATE, routeEntryUpdate)));

    verify(fibListener);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的package包/类
/**
 * Tests deleting a FIB entry.
 *
 * We verify that the synchronizer records the correct state and that the
 * correct intent is withdrawn from the IntentService.
 *
 * @throws TestUtilsException
 */
@Test
public void testFibDelete() throws TestUtilsException {
    // Firstly add a route
    testFibAdd();

    Intent addedIntent =
            intentSynchronizer.getRouteIntents().iterator().next();

    // Construct the existing route entry
    FibEntry fibEntry = new FibEntry(
            Ip4Prefix.valueOf("1.1.1.0/24"), null, null);

    // Set up expectation
    reset(intentService);
    // Setup the expected intents
    intentService.withdraw(eqExceptId(addedIntent));
    replay(intentService);

    // Call the update() method in IntentSynchronizer class
    intentSynchronizer.leaderChanged(true);
    TestUtils.setField(intentSynchronizer, "isActivatedLeader", true);
    FibUpdate fibUpdate = new FibUpdate(FibUpdate.Type.DELETE, fibEntry);
    intentSynchronizer.update(Collections.emptyList(),
                              Collections.singletonList(fibUpdate));

    // Verify
    assertEquals(intentSynchronizer.getRouteIntents().size(), 0);
    verify(intentService);
}
 

import org.onosproject.routing.FibEntry; //导入依赖的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);
}