Examples with Adjacency org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency used on opensource projects

Example 46 with Adjacency

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency in project netvirt by opendaylight.

the class VrfEntryListener method cleanUpOpDataForFib.

protected void cleanUpOpDataForFib(Long vpnId, String primaryRd, final VrfEntry vrfEntry) {
    /* Get interface info from prefix to interface mapping;
        Use the interface info to get the corresponding vpn interface op DS entry,
        remove the adjacency corresponding to this fib entry.
        If adjacency removed is the last adjacency, clean up the following:
         - vpn interface from dpntovpn list, dpn if last vpn interface on dpn
         - prefix to interface entry
         - vpn interface op DS
     */
    LOG.debug("Cleanup of prefix {} in VPN {}", vrfEntry.getDestPrefix(), vpnId);
    Prefixes prefixInfo = fibUtil.getPrefixToInterface(vpnId, vrfEntry.getDestPrefix());
    if (prefixInfo == null) {
        List<String> usedRds = VpnExtraRouteHelper.getUsedRds(dataBroker, vpnId, vrfEntry.getDestPrefix());
        String usedRd = usedRds.isEmpty() ? primaryRd : usedRds.get(0);
        Routes extraRoute = baseVrfEntryHandler.getVpnToExtraroute(vpnId, usedRd, vrfEntry.getDestPrefix());
        if (extraRoute != null) {
            for (String nextHopIp : extraRoute.getNexthopIpList()) {
                LOG.debug("NextHop IP for destination {} is {}", vrfEntry.getDestPrefix(), nextHopIp);
                if (nextHopIp != null) {
                    String ipPrefix;
                    if (isIpv4Address(nextHopIp)) {
                        ipPrefix = nextHopIp + NwConstants.IPV4PREFIX;
                    } else {
                        ipPrefix = nextHopIp + NwConstants.IPV6PREFIX;
                    }
                    prefixInfo = fibUtil.getPrefixToInterface(vpnId, ipPrefix);
                    checkCleanUpOpDataForFib(prefixInfo, vpnId, primaryRd, vrfEntry, extraRoute);
                }
            }
        }
        if (prefixInfo == null) {
            java.util.Optional<Long> optionalLabel = FibUtil.getLabelFromRoutePaths(vrfEntry);
            if (optionalLabel.isPresent()) {
                Long label = optionalLabel.get();
                List<String> nextHopAddressList = FibHelper.getNextHopListFromRoutePaths(vrfEntry);
                LabelRouteInfo lri = getLabelRouteInfo(label);
                if (isPrefixAndNextHopPresentInLri(vrfEntry.getDestPrefix(), nextHopAddressList, lri)) {
                    PrefixesBuilder prefixBuilder = new PrefixesBuilder();
                    prefixBuilder.setDpnId(lri.getDpnId());
                    prefixBuilder.setVpnInterfaceName(lri.getVpnInterfaceName());
                    prefixBuilder.setIpAddress(lri.getPrefix());
                    prefixInfo = prefixBuilder.build();
                    LOG.debug("Fetched labelRouteInfo for label {} interface {} and got dpn {}", label, prefixInfo.getVpnInterfaceName(), lri.getDpnId());
                    checkCleanUpOpDataForFib(prefixInfo, vpnId, primaryRd, vrfEntry, extraRoute);
                }
            }
        }
    } else {
        checkCleanUpOpDataForFib(prefixInfo, vpnId, primaryRd, vrfEntry, null);
    }
}

Example 47 with Adjacency

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency in project netvirt by opendaylight.

the class BgpRouteVrfEntryHandler method deleteFibEntries.

/*
      Please note that the following deleteFibEntries will be invoked only for BGP Imported Routes.
      The invocation of the following method is via delete() callback from the MDSAL Batching Infrastructure
      provided by ResourceBatchingManager
     */
private void deleteFibEntries(WriteTransaction writeTx, final InstanceIdentifier<VrfEntry> identifier, final VrfEntry vrfEntry, List<SubTransaction> subTxns) {
    final VrfTablesKey vrfTableKey = identifier.firstKeyOf(VrfTables.class);
    String rd = vrfTableKey.getRouteDistinguisher();
    final VpnInstanceOpDataEntry vpnInstance = getFibUtil().getVpnInstance(vrfTableKey.getRouteDistinguisher());
    if (vpnInstance == null) {
        LOG.debug("VPN Instance for rd {} is not available from VPN Op Instance Datastore", rd);
        return;
    }
    String vpnName = getFibUtil().getVpnNameFromId(vpnInstance.getVpnId());
    final Collection<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
    if (vpnToDpnList != null) {
        List<String> usedRds = VpnExtraRouteHelper.getUsedRds(dataBroker, vpnInstance.getVpnId(), vrfEntry.getDestPrefix());
        Optional<Routes> extraRouteOptional;
        // Is this fib route an extra route? If yes, get the nexthop which would be an adjacency in the vpn
        if (usedRds != null && !usedRds.isEmpty()) {
            if (usedRds.size() > 1) {
                LOG.error("The extra route prefix is still present in some DPNs");
                return;
            } else {
                extraRouteOptional = VpnExtraRouteHelper.getVpnExtraroutes(dataBroker, vpnName, usedRds.get(0), vrfEntry.getDestPrefix());
            }
        } else {
            extraRouteOptional = Optional.absent();
        }
        for (VpnToDpnList curDpn : vpnToDpnList) {
            if (curDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
                deleteRemoteRoute(BigInteger.ZERO, curDpn.getDpnId(), vpnInstance.getVpnId(), vrfTableKey, vrfEntry, extraRouteOptional, writeTx, subTxns);
            }
        }
    }
}

Example 48 with Adjacency

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency 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 49 with Adjacency

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency in project netvirt by opendaylight.

the class NeutronvpnManager method withdrawPortIpFromVpnIface.

protected void withdrawPortIpFromVpnIface(Uuid vpnId, Uuid internetVpnId, Port port, Subnetmap sn, WriteTransaction wrtConfigTxn) {
    String infName = port.getUuid().getValue();
    InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
    Optional<VpnInterface> optionalVpnInterface = null;
    LOG.debug("withdrawPortIpFromVpnIface vpn {} internetVpn {} Port {}", vpnId, internetVpnId, infName);
    try {
        optionalVpnInterface = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
    } catch (ReadFailedException e) {
        LOG.error("withdrawPortIpFromVpnIface: Error reading the VPN interface for {}", vpnIfIdentifier, e);
        return;
    }
    if (!optionalVpnInterface.isPresent()) {
        return;
    }
    LOG.trace("withdraw adjacencies for Port: {} subnet {}", port.getUuid().getValue(), sn != null ? sn.getSubnetIp() : "null");
    List<Adjacency> vpnAdjsList = optionalVpnInterface.get().getAugmentation(Adjacencies.class).getAdjacency();
    List<Adjacency> updatedAdjsList = new ArrayList<>();
    boolean isIpFromAnotherSubnet = false;
    for (Adjacency adj : vpnAdjsList) {
        String adjString = FibHelper.getIpFromPrefix(adj.getIpAddress());
        if (sn == null || !Objects.equals(adj.getSubnetId(), sn.getId())) {
            if (adj.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
                isIpFromAnotherSubnet = true;
            }
            updatedAdjsList.add(adj);
            continue;
        }
        if (adj.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
            LOG.error("withdrawPortIpFromVpnIface: suppressing primaryAdjacency {} FixedIp for vpnId {}", adjString, vpnId);
            if (vpnId != null) {
                neutronvpnUtils.removeVpnPortFixedIpToPort(vpnId.getValue(), String.valueOf(adjString), wrtConfigTxn);
            }
            if (internetVpnId != null) {
                neutronvpnUtils.removeVpnPortFixedIpToPort(internetVpnId.getValue(), String.valueOf(adjString), wrtConfigTxn);
            }
        } else {
            if (port.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_ROUTER_INF) && sn.getRouterId() != null) {
                Router rtr = neutronvpnUtils.getNeutronRouter(sn.getRouterId());
                if (rtr != null && rtr.getRoutes() != null) {
                    List<Routes> extraRoutesToRemove = new ArrayList<>();
                    for (Routes rt : rtr.getRoutes()) {
                        if (rt.getNexthop().toString().equals(adjString)) {
                            extraRoutesToRemove.add(rt);
                        }
                    }
                    if (vpnId != null) {
                        LOG.error("withdrawPortIpFromVpnIface: suppressing extraRoute {} for vpnId {}", extraRoutesToRemove, vpnId);
                        removeAdjacencyforExtraRoute(vpnId, extraRoutesToRemove);
                    }
                /* removeAdjacencyforExtraRoute done also for internet-vpn-id, in previous call */
                }
            }
        }
    }
    Adjacencies adjacencies = new AdjacenciesBuilder().setAdjacency(updatedAdjsList).build();
    if (vpnId != null) {
        updateVpnInterfaceWithAdjacencies(vpnId, infName, adjacencies, wrtConfigTxn);
    }
    if (internetVpnId != null) {
        updateVpnInterfaceWithAdjacencies(internetVpnId, infName, adjacencies, wrtConfigTxn);
    }
    if (!isIpFromAnotherSubnet) {
        // no more subnetworks for neutron port
        if (sn != null && sn.getRouterId() != null) {
            removeFromNeutronRouterInterfacesMap(sn.getRouterId(), port.getUuid().getValue());
        }
        deleteVpnInterface(infName, null, /* vpn-id */
        wrtConfigTxn);
        return;
    }
    return;
}

Example 50 with Adjacency

use of org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency 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);
            }
        }
    }
}