Examples with Routes org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes used on opensource projects

Example 41 with Routes

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes in project netvirt by opendaylight.

the class VrfEntryListener method cleanUpDpnForVpn.

public void cleanUpDpnForVpn(final Uint64 dpnId, final Uint32 vpnId, final String rd, final FutureCallback<List<?>> callback) {
    LOG.trace("cleanUpDpnForVpn: Remove dpn {} for vpn {} : cleanUpDpnForVpn", dpnId, rd);
    jobCoordinator.enqueueJob(FibUtil.getJobKeyForVpnIdDpnId(vpnId, dpnId), () -> {
        InstanceIdentifier<VrfTables> id = buildVrfId(rd);
        final VpnInstanceOpDataEntry vpnInstance = fibUtil.getVpnInstance(rd);
        List<SubTransaction> txnObjects = new ArrayList<>();
        final Optional<VrfTables> vrfTable = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
        List<ListenableFuture<?>> futures = new ArrayList<>();
        if (!vrfTable.isPresent()) {
            LOG.error("cleanUpDpnForVpn: VRF Table not available for RD {}", rd);
            if (callback != null) {
                ListenableFuture<List<Object>> listenableFuture = Futures.allAsList(futures);
                Futures.addCallback(listenableFuture, callback, MoreExecutors.directExecutor());
            }
            return futures;
        }
        final ReentrantLock lock = lockFor(vpnInstance);
        lock.lock();
        try {
            futures.add(retryingTxRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
                String vpnName = fibUtil.getVpnNameFromId(vpnInstance.getVpnId());
                for (final VrfEntry vrfEntry : vrfTable.get().nonnullVrfEntry().values()) {
                    /* parentRd is only filled for external PNF cases where the interface on the external
                             * network VPN are used to cleanup the flows. For all other cases, use "rd" for
                             * #fibUtil.isInterfacePresentInDpn().
                             * */
                    String parentRd = vrfEntry.getParentVpnRd() != null ? vrfEntry.getParentVpnRd() : rd;
                    /* Handle subnet routes here */
                    SubnetRoute subnetRoute = vrfEntry.augmentation(SubnetRoute.class);
                    if (subnetRoute != null && !fibUtil.isInterfacePresentInDpn(parentRd, dpnId)) {
                        LOG.trace("SUBNETROUTE: cleanUpDpnForVpn: Cleaning subnetroute {} on dpn {}" + " for vpn {}", vrfEntry.getDestPrefix(), dpnId, rd);
                        baseVrfEntryHandler.makeConnectedRoute(dpnId, vpnId, vrfEntry, rd, null, NwConstants.DEL_FLOW, TransactionAdapter.toWriteTransaction(tx), null);
                        Map<RoutePathsKey, RoutePaths> keyRoutePathsMap = vrfEntry.getRoutePaths();
                        if (keyRoutePathsMap != null) {
                            for (RoutePaths routePath : keyRoutePathsMap.values()) {
                                makeLFibTableEntry(dpnId, routePath.getLabel(), null, DEFAULT_FIB_FLOW_PRIORITY, NwConstants.DEL_FLOW, tx);
                                LOG.trace("SUBNETROUTE: cleanUpDpnForVpn: Released subnetroute label {}" + " for rd {} prefix {}", routePath.getLabel(), rd, vrfEntry.getDestPrefix());
                            }
                        }
                        installSubnetBroadcastAddrDropRule(dpnId, rd, vpnId, vrfEntry, NwConstants.DEL_FLOW, tx);
                        continue;
                    }
                    // ping responder for router interfaces
                    RouterInterface routerInt = vrfEntry.augmentation(RouterInterface.class);
                    if (routerInt != null) {
                        LOG.trace("Router augmented vrfentry found for rd:{}, uuid:{}, ip:{}, mac:{}", rd, routerInt.getUuid(), routerInt.getIpAddress(), routerInt.getMacAddress());
                        routerInterfaceVrfEntryHandler.installRouterFibEntry(vrfEntry, dpnId, vpnId, routerInt.getIpAddress(), new MacAddress(routerInt.getMacAddress()), NwConstants.DEL_FLOW);
                        continue;
                    }
                    // Handle local flow deletion for imports
                    if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.SELF_IMPORTED) {
                        java.util.Optional<Uint32> optionalLabel = FibUtil.getLabelFromRoutePaths(vrfEntry);
                        if (optionalLabel.isPresent()) {
                            List<String> nextHopList = FibHelper.getNextHopListFromRoutePaths(vrfEntry);
                            LabelRouteInfo lri = getLabelRouteInfo(optionalLabel.get());
                            if (isPrefixAndNextHopPresentInLri(vrfEntry.getDestPrefix(), nextHopList, lri) && Objects.equals(lri.getDpnId(), dpnId)) {
                                deleteLocalFibEntry(vpnId, rd, vrfEntry);
                            }
                        }
                    }
                    // Passing null as we don't know the dpn
                    // to which prefix is attached at this point
                    List<String> usedRds = VpnExtraRouteHelper.getUsedRds(dataBroker, vpnInstance.getVpnId(), vrfEntry.getDestPrefix());
                    Optional<Routes> extraRouteOptional;
                    // 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.empty();
                    }
                    if (RouteOrigin.BGP.getValue().equals(vrfEntry.getOrigin())) {
                        bgpRouteVrfEntryHandler.deleteRemoteRoute(null, dpnId, vpnId, vrfTable.get().key(), vrfEntry, extraRouteOptional, TransactionAdapter.toWriteTransaction(tx), txnObjects);
                    } else {
                        if (subnetRoute == null || !fibUtil.isInterfacePresentInDpn(parentRd, dpnId)) {
                            baseVrfEntryHandler.deleteRemoteRoute(null, dpnId, vpnId, vrfTable.get().key(), vrfEntry, extraRouteOptional, TransactionAdapter.toWriteTransaction(tx));
                        }
                    }
                }
            }));
        } finally {
            lock.unlock();
        }
        if (callback != null) {
            ListenableFuture<List<Object>> listenableFuture = Futures.allAsList(futures);
            Futures.addCallback(listenableFuture, callback, MoreExecutors.directExecutor());
        }
        return futures;
    });
}

Example 42 with Routes

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes in project netvirt by opendaylight.

the class VrfEntryListener method createLocalFibEntry.

private List<Uint64> createLocalFibEntry(Uint32 vpnId, String rd, VrfEntry vrfEntry, int etherType) {
    List<Uint64> returnLocalDpnId = new ArrayList<>();
    String localNextHopIP = vrfEntry.getDestPrefix();
    Prefixes localNextHopInfo = fibUtil.getPrefixToInterface(vpnId, localNextHopIP);
    String vpnName = fibUtil.getVpnNameFromId(vpnId);
    if (localNextHopInfo == null) {
        boolean localNextHopSeen = false;
        List<Routes> vpnExtraRoutes = null;
        // Synchronized to prevent missing bucket action due to race condition between refreshFib and
        // add/updateFib threads on missing nexthop in VpnToExtraroutes
        // FIXME: use an Identifier structure?
        final ReentrantLock lock = JvmGlobalLocks.getLockForString(localNextHopIP + FibConstants.SEPARATOR + rd);
        lock.lock();
        try {
            List<String> usedRds = VpnExtraRouteHelper.getUsedRds(dataBroker, vpnId, localNextHopIP);
            vpnExtraRoutes = VpnExtraRouteHelper.getAllVpnExtraRoutes(dataBroker, vpnName, usedRds, localNextHopIP);
            if (LOG.isDebugEnabled()) {
                LOG.debug("Creating Local fib entry with vpnName {} usedRds {} localNextHopIP {} vpnExtraRoutes {}", vpnName, usedRds, localNextHopIP, vpnExtraRoutes);
            }
            // Is this fib route an extra route? If yes, get the nexthop which would be an adjacency in the vpn
            for (Routes vpnExtraRoute : vpnExtraRoutes) {
                String ipPrefix;
                if (isIpv4Address(vpnExtraRoute.getNexthopIpList().get(0))) {
                    ipPrefix = vpnExtraRoute.getNexthopIpList().get(0) + NwConstants.IPV4PREFIX;
                } else {
                    ipPrefix = vpnExtraRoute.getNexthopIpList().get(0) + NwConstants.IPV6PREFIX;
                }
                Prefixes localNextHopInfoLocal = fibUtil.getPrefixToInterface(vpnId, ipPrefix);
                if (localNextHopInfoLocal != null) {
                    localNextHopSeen = true;
                    Uint64 dpnId = checkCreateLocalFibEntry(localNextHopInfoLocal, localNextHopInfoLocal.getIpAddress(), vpnId, rd, vrfEntry, vpnExtraRoute, vpnExtraRoutes, etherType, /*parentVpnId*/
                    null);
                    returnLocalDpnId.add(dpnId);
                }
            }
        } finally {
            lock.unlock();
        }
        if (!localNextHopSeen && RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.SELF_IMPORTED) {
            java.util.Optional<Uint32> optionalLabel = FibUtil.getLabelFromRoutePaths(vrfEntry);
            if (optionalLabel.isPresent()) {
                Uint32 label = optionalLabel.get();
                List<String> nextHopAddressList = FibHelper.getNextHopListFromRoutePaths(vrfEntry);
                final LabelRouteInfoKey lriKey = new LabelRouteInfoKey(label);
                final ReentrantLock labelLock = lockFor(lriKey);
                labelLock.lock();
                try {
                    LabelRouteInfo lri = getLabelRouteInfo(lriKey);
                    Uint32 parentVpnId = lri.getParentVpnid();
                    if (isPrefixAndNextHopPresentInLri(localNextHopIP, nextHopAddressList, lri)) {
                        Optional<VpnInstanceOpDataEntry> vpnInstanceOpDataEntryOptional = fibUtil.getVpnInstanceOpData(rd);
                        if (vpnInstanceOpDataEntryOptional.isPresent()) {
                            String vpnInstanceName = vpnInstanceOpDataEntryOptional.get().getVpnInstanceName();
                            if (lri.getVpnInstanceList() != null && lri.getVpnInstanceList().contains(vpnInstanceName)) {
                                localNextHopInfo = updateVpnReferencesInLri(lri, vpnInstanceName, true);
                                localNextHopIP = lri.getPrefix();
                            } else {
                                localNextHopInfo = updateVpnReferencesInLri(lri, vpnInstanceName, false);
                                localNextHopIP = lri.getPrefix();
                            }
                        }
                        if (localNextHopInfo != null) {
                            LOG.debug("Fetched labelRouteInfo for label {} interface {} and got dpn {}", label, localNextHopInfo.getVpnInterfaceName(), lri.getDpnId());
                            if (vpnExtraRoutes.isEmpty()) {
                                Uint64 dpnId = checkCreateLocalFibEntry(localNextHopInfo, localNextHopIP, vpnId, rd, vrfEntry, null, vpnExtraRoutes, etherType, parentVpnId);
                                returnLocalDpnId.add(dpnId);
                            } else {
                                for (Routes extraRoutes : vpnExtraRoutes) {
                                    Uint64 dpnId = checkCreateLocalFibEntry(localNextHopInfo, localNextHopIP, vpnId, rd, vrfEntry, extraRoutes, vpnExtraRoutes, etherType, parentVpnId);
                                    returnLocalDpnId.add(dpnId);
                                }
                            }
                        }
                    }
                } finally {
                    labelLock.unlock();
                }
            }
        }
        if (returnLocalDpnId.isEmpty()) {
            LOG.error("Local DPNID is empty for rd {}, vpnId {}, vrfEntry {}", rd, vpnId, vrfEntry);
        }
    } else {
        Uint64 dpnId = checkCreateLocalFibEntry(localNextHopInfo, localNextHopIP, vpnId, rd, vrfEntry, /*routes*/
        null, /*vpnExtraRoutes*/
        null, etherType, /*parentVpnId*/
        null);
        if (dpnId != null) {
            returnLocalDpnId.add(dpnId);
        }
    }
    return returnLocalDpnId;
}

Example 43 with Routes

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes in project netvirt by opendaylight.

the class VrfEntryListener method cleanUpOpDataForFib.

protected void cleanUpOpDataForFib(Uint32 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 && extraRoute.getNexthopIpList() != 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<Uint32> optionalLabel = FibUtil.getLabelFromRoutePaths(vrfEntry);
            if (optionalLabel.isPresent()) {
                Uint32 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 44 with Routes

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes in project netvirt by opendaylight.

the class BgpRouteVrfEntryHandler method createFibEntries.

/*
      Please note that the following createFibEntries will be invoked only for BGP Imported Routes.
      The invocation of the following method is via create() callback from the MDSAL Batching Infrastructure
      provided by ResourceBatchingManager
     */
private void createFibEntries(WriteTransaction writeTx, final InstanceIdentifier<VrfEntry> vrfEntryIid, final VrfEntry vrfEntry, List<SubTransaction> subTxns) {
    final VrfTablesKey vrfTableKey = vrfEntryIid.firstKeyOf(VrfTables.class);
    LOG.trace("Creating fib entry for vrfEntry with destPrefix{}, rd {}", vrfEntry.getDestPrefix(), vrfTableKey.getRouteDistinguisher());
    final VpnInstanceOpDataEntry vpnInstance = getFibUtil().getVpnInstance(vrfTableKey.getRouteDistinguisher());
    if (vpnInstance == null || vpnInstance.getVpnId() == null) {
        LOG.error("Vpn Instance not availabe {}", vrfTableKey.getRouteDistinguisher());
        return;
    }
    final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap = vpnInstance.nonnullVpnToDpnList();
    if (keyVpnToDpnListMap != null) {
        for (VpnToDpnList vpnDpn : keyVpnToDpnListMap.values()) {
            LOG.trace("Dpnstate is {} for dpn {} in vpn {}", vpnDpn.getDpnState(), vpnDpn.getDpnId(), vpnInstance.getVpnId());
            if (vpnDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
                createRemoteFibEntry(vpnDpn.getDpnId(), vpnInstance.getVpnId(), vrfTableKey.getRouteDistinguisher(), vrfEntry, writeTx, subTxns);
            }
        }
    }
    LOG.trace("Created fib entry for vrfEntry with destPrefix{}, rd {}", vrfEntry.getDestPrefix(), vrfTableKey.getRouteDistinguisher());
}

Example 45 with Routes

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes in project netvirt by opendaylight.

the class FibRpcServiceImpl method createFibEntry.

/**
 * To install FIB routes on specified dpn with given instructions.
 */
@Override
public ListenableFuture<RpcResult<CreateFibEntryOutput>> createFibEntry(CreateFibEntryInput input) {
    Uint64 dpnId = input.getSourceDpid();
    String vpnName = input.getVpnName();
    String vpnRd = getVpnRd(dataBroker, vpnName);
    String ipAddress = input.getIpAddress();
    LOG.info("Create custom FIB entry - {} on dpn {} for VPN {} ", ipAddress, dpnId, vpnName);
    Map<InstructionKey, Instruction> instructionMap = input.nonnullInstruction();
    LOG.info("ADD: Adding Custom Fib Entry rd {} prefix {} label {}", vpnRd, ipAddress, input.getServiceId());
    IpAddresses.IpAddressSource ipAddressSource = IpAddresses.IpAddressSource.forValue(input.getIpAddressSource().getIntValue());
    vpnFootprintService.updateVpnToDpnMapping(dpnId, vpnName, vpnRd, null, /* interfaceName*/
    new ImmutablePair<>(ipAddressSource, ipAddress), true);
    Uint32 vpnId = getVpnId(dataBroker, vpnName);
    makeLocalFibEntry(vpnId, dpnId, ipAddress, new ArrayList<Instruction>(instructionMap.values()));
    LOG.info("ADD: Added Custom Fib Entry rd {} prefix {} label {}", vpnRd, ipAddress, input.getServiceId());
    return RpcResultBuilder.success(new CreateFibEntryOutputBuilder().build()).buildFuture();
}