Examples with NextHop org.opendaylight.yang.gen.v1.http.openconfig.net.yang.local.routing.rev151009.LocalStaticConfig.NextHop used on opensource projects

Example 96 with NextHop

use of org.opendaylight.yang.gen.v1.http.openconfig.net.yang.local.routing.rev151009.LocalStaticConfig.NextHop in project netvirt by opendaylight.

the class NeutronvpnManager method removeAdjacencyforExtraRoute.

// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
protected void removeAdjacencyforExtraRoute(Uuid vpnId, List<Routes> routeList) {
    for (Routes route : routeList) {
        if (route != null && route.getNexthop() != null && route.getDestination() != null) {
            boolean isLockAcquired = false;
            String nextHop = String.valueOf(route.getNexthop().getValue());
            String destination = String.valueOf(route.getDestination().getValue());
            String infName = neutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(vpnId.getValue(), nextHop);
            if (infName == null) {
                LOG.error("Unable to find VPN NextHop interface to remove extra-route destination {} on VPN {} " + "with nexthop {}", destination, vpnId.getValue(), nextHop);
                // Proceed to remove the next extra-route
                continue;
            }
            LOG.trace("Removing extra route for destination {} on vpn {} with nexthop {} and infName {}", destination, vpnId.getValue(), nextHop, infName);
            InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).child(VpnInterface.class, new VpnInterfaceKey(infName)).augmentation(Adjacencies.class).child(Adjacency.class, new AdjacencyKey(destination)).build();
            try {
                // Looking for existing prefix in MDSAL database
                Optional<Adjacency> adjacency = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
                boolean updateNextHops = false;
                List<String> nextHopList = new ArrayList<>();
                if (adjacency.isPresent()) {
                    List<String> nhListRead = adjacency.get().getNextHopIpList();
                    if (nhListRead.size() > 1) {
                        // ECMP case
                        for (String nextHopRead : nhListRead) {
                            if (nextHopRead.equals(nextHop)) {
                                updateNextHops = true;
                            } else {
                                nextHopList.add(nextHopRead);
                            }
                        }
                    }
                }
                isLockAcquired = interfaceLock.tryLock(infName, LOCK_WAIT_TIME, TimeUnit.SECONDS);
                if (updateNextHops) {
                    // An update must be done, not including the current next hop
                    InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).child(VpnInterface.class, new VpnInterfaceKey(infName)).build();
                    Adjacency newAdj = new AdjacencyBuilder(adjacency.get()).setIpAddress(destination).setNextHopIpList(nextHopList).setKey(new AdjacencyKey(destination)).build();
                    Adjacencies erAdjs = new AdjacenciesBuilder().setAdjacency(Collections.singletonList(newAdj)).build();
                    VpnInterface vpnIf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName)).addAugmentation(Adjacencies.class, erAdjs).build();
                    SingleTransactionDataBroker.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
                } else {
                    // Remove the whole route
                    SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
                    LOG.trace("extra route {} deleted successfully", route);
                }
            } catch (TransactionCommitFailedException | ReadFailedException e) {
                LOG.error("exception in deleting extra route with destination {} for interface {}", destination, infName, e);
            } finally {
                if (isLockAcquired) {
                    interfaceLock.unlock(infName);
                }
            }
        } else {
            LOG.error("Incorrect input received for extra route: {}", route);
        }
    }
}

Example 97 with NextHop

use of org.opendaylight.yang.gen.v1.http.openconfig.net.yang.local.routing.rev151009.LocalStaticConfig.NextHop in project netvirt by opendaylight.

the class NeutronvpnManager method updateVpnInterfaceWithExtraRouteAdjacency.

protected void updateVpnInterfaceWithExtraRouteAdjacency(Uuid vpnId, List<Routes> routeList) {
    checkAlarmExtraRoutes(vpnId, routeList);
    for (Routes route : routeList) {
        if (route == null || route.getNexthop() == null || route.getDestination() == null) {
            LOG.error("Incorrect input received for extra route. {}", route);
        } else {
            String nextHop = String.valueOf(route.getNexthop().getValue());
            String destination = String.valueOf(route.getDestination().getValue());
            String infName = neutronvpnUtils.getNeutronPortNameFromVpnPortFixedIp(vpnId.getValue(), nextHop);
            if (infName != null) {
                LOG.trace("Updating extra route for destination {} onto vpn {} with nexthop {} and infName {}", destination, vpnId.getValue(), nextHop, infName);
                boolean isLockAcquired = false;
                try {
                    InstanceIdentifier<VpnInterface> identifier = InstanceIdentifier.builder(VpnInterfaces.class).child(VpnInterface.class, new VpnInterfaceKey(infName)).build();
                    InstanceIdentifier<Adjacency> path = identifier.augmentation(Adjacencies.class).child(Adjacency.class, new AdjacencyKey(destination));
                    Optional<Adjacency> existingAdjacency = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, path);
                    if (existingAdjacency.isPresent() && existingAdjacency.get().getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
                        LOG.error("The route with destination {} nextHop {} is already present as" + " a primary adjacency for interface {}. Skipping adjacency addition.", destination, nextHop, infName);
                        continue;
                    }
                    Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination).setNextHopIpList(Collections.singletonList(nextHop)).setKey(new AdjacencyKey(destination)).setAdjacencyType(AdjacencyType.ExtraRoute).build();
                    isLockAcquired = interfaceLock.tryLock(infName, LOCK_WAIT_TIME, TimeUnit.SECONDS);
                    SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, path, erAdj);
                } catch (TransactionCommitFailedException e) {
                    LOG.error("exception in adding extra route with destination: {}, next hop: {}", destination, nextHop, e);
                } catch (ReadFailedException e) {
                    LOG.error("Exception on reading data-store ", e);
                } finally {
                    if (isLockAcquired) {
                        interfaceLock.unlock(infName);
                    }
                }
            } else {
                LOG.error("Unable to find VPN NextHop interface to apply extra-route destination {} on VPN {} " + "with nexthop {}", destination, vpnId.getValue(), nextHop);
            }
        }
    }
}

Example 98 with NextHop

use of org.opendaylight.yang.gen.v1.http.openconfig.net.yang.local.routing.rev151009.LocalStaticConfig.NextHop in project netvirt by opendaylight.

the class NeutronvpnManager method getAdjacencyforExtraRoute.

@Nonnull
protected List<Adjacency> getAdjacencyforExtraRoute(List<Routes> routeList, String fixedIp) {
    List<Adjacency> adjList = new ArrayList<>();
    Map<String, List<String>> adjMap = new HashMap<>();
    for (Routes route : routeList) {
        if (route == null || route.getNexthop() == null || route.getDestination() == null) {
            LOG.error("Incorrect input received for extra route. {}", route);
        } else {
            String nextHop = String.valueOf(route.getNexthop().getValue());
            String destination = String.valueOf(route.getDestination().getValue());
            if (!nextHop.equals(fixedIp)) {
                LOG.trace("FixedIP {} is not extra route nexthop for destination {}", fixedIp, destination);
                continue;
            }
            LOG.trace("Adding extra route for destination {} with nexthop {} ", destination, nextHop);
            List<String> hops = adjMap.computeIfAbsent(destination, k -> new ArrayList<>());
            if (!hops.contains(nextHop)) {
                hops.add(nextHop);
            }
        }
    }
    for (Entry<String, List<String>> entry : adjMap.entrySet()) {
        final String destination = entry.getKey();
        final List<String> ipList = entry.getValue();
        Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination).setAdjacencyType(AdjacencyType.ExtraRoute).setNextHopIpList(ipList).setKey(new AdjacencyKey(destination)).build();
        adjList.add(erAdj);
    }
    return adjList;
}

Example 99 with NextHop

use of org.opendaylight.yang.gen.v1.http.openconfig.net.yang.local.routing.rev151009.LocalStaticConfig.NextHop in project netvirt by opendaylight.

the class NeutronRouterChangeListener method handleChangedRoutes.

private void handleChangedRoutes(Uuid vpnName, List<Routes> routes, int addedOrRemoved) {
    // Some routes may point to an InterVpnLink's endpoint, lets treat them differently
    List<Routes> interVpnLinkRoutes = new ArrayList<>();
    List<Routes> otherRoutes = new ArrayList<>();
    HashMap<String, InterVpnLink> nexthopsXinterVpnLinks = new HashMap<>();
    for (Routes route : routes) {
        String nextHop = String.valueOf(route.getNexthop().getValue());
        // Nexthop is another VPN?
        Optional<InterVpnLink> interVpnLink = neutronvpnUtils.getInterVpnLinkByEndpointIp(nextHop);
        if (interVpnLink.isPresent()) {
            Optional<InterVpnLinkState> interVpnLinkState = neutronvpnUtils.getInterVpnLinkState(interVpnLink.get().getName());
            if (interVpnLinkState.isPresent() && interVpnLinkState.get().getState() == InterVpnLinkState.State.Active) {
                interVpnLinkRoutes.add(route);
                nexthopsXinterVpnLinks.put(nextHop, interVpnLink.get());
            } else {
                LOG.error("Failed installing route to {}. Reason: InterVPNLink {} is not Active", String.valueOf(route.getDestination().getValue()), interVpnLink.get().getName());
            }
        } else {
            otherRoutes.add(route);
        }
    }
    if (addedOrRemoved == NwConstants.ADD_FLOW) {
        nvpnManager.addInterVpnRoutes(vpnName, interVpnLinkRoutes, nexthopsXinterVpnLinks);
        nvpnManager.updateVpnInterfaceWithExtraRouteAdjacency(vpnName, otherRoutes);
    } else {
        nvpnManager.removeAdjacencyforExtraRoute(vpnName, otherRoutes);
        nvpnManager.removeInterVpnRoutes(vpnName, interVpnLinkRoutes, nexthopsXinterVpnLinks);
    }
}

Example 100 with NextHop

use of org.opendaylight.yang.gen.v1.http.openconfig.net.yang.local.routing.rev151009.LocalStaticConfig.NextHop in project lispflowmapping by opendaylight.

the class MappingSystem method updateServicePathMappingRecord.

private MappingData updateServicePathMappingRecord(MappingData mappingData, Eid eid) {
    // keep properties of original record
    MappingRecordBuilder recordBuilder = new MappingRecordBuilder(mappingData.getRecord());
    recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
    // there should only be one locator record
    if (mappingData.getRecord().getLocatorRecord().size() != 1) {
        LOG.warn("MappingRecord associated to ServicePath EID has more than one locator!");
        return mappingData;
    }
    LocatorRecord locatorRecord = mappingData.getRecord().getLocatorRecord().get(0);
    long serviceIndex = ((ServicePath) eid.getAddress()).getServicePath().getServiceIndex();
    int index = LispAddressUtil.STARTING_SERVICE_INDEX - (int) serviceIndex;
    Rloc rloc = locatorRecord.getRloc();
    if (rloc.getAddress() instanceof Ipv4 || rloc.getAddress() instanceof Ipv6) {
        if (index != 0) {
            LOG.warn("Service Index should be 255 for simple IP RLOCs!");
        }
        return mappingData;
    } else if (rloc.getAddress() instanceof ExplicitLocatorPath) {
        ExplicitLocatorPath elp = (ExplicitLocatorPath) rloc.getAddress();
        List<Hop> hops = elp.getExplicitLocatorPath().getHop();
        if (index < 0 || index > hops.size()) {
            LOG.warn("Service Index out of bounds!");
            return mappingData;
        }
        SimpleAddress nextHop = hops.get(index).getAddress();
        LocatorRecordBuilder lrb = new LocatorRecordBuilder(locatorRecord);
        lrb.setRloc(LispAddressUtil.toRloc(nextHop));
        recordBuilder.getLocatorRecord().add(lrb.build());
        return new MappingData(recordBuilder.build());
    } else {
        LOG.warn("Nothing to do with ServicePath mapping record");
        return mappingData;
    }
}