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 16 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 NeutronvpnManager method createPortIpAdjacencies.

protected Adjacencies createPortIpAdjacencies(Port port, Boolean isRouterInterface, WriteTransaction wrtConfigTxn, Subnetmap sn, VpnInterface vpnIface) {
    List<Adjacency> adjList = new ArrayList<>();
    if (vpnIface != null) {
        adjList = vpnIface.getAugmentation(Adjacencies.class).getAdjacency();
    }
    String infName = port.getUuid().getValue();
    LOG.trace("neutronVpnManager: create config adjacencies for Port: {}", infName);
    for (FixedIps ip : port.getFixedIps()) {
        String ipValue = String.valueOf(ip.getIpAddress().getValue());
        String ipPrefix = ip.getIpAddress().getIpv4Address() != null ? ipValue + "/32" : ipValue + "/128";
        if (sn != null && !FibHelper.doesPrefixBelongToSubnet(ipPrefix, sn.getSubnetIp(), false)) {
            continue;
        }
        Adjacency vmAdj = new AdjacencyBuilder().setKey(new AdjacencyKey(ipPrefix)).setIpAddress(ipPrefix).setMacAddress(port.getMacAddress().getValue()).setAdjacencyType(AdjacencyType.PrimaryAdjacency).setSubnetId(ip.getSubnetId()).build();
        if (!adjList.contains(vmAdj)) {
            adjList.add(vmAdj);
        }
        Subnetmap snTemp = sn != null ? sn : neutronvpnUtils.getSubnetmap(ip.getSubnetId());
        Uuid routerId = snTemp != null ? snTemp.getRouterId() : null;
        Uuid vpnId = snTemp != null ? snTemp.getVpnId() : null;
        if (vpnId != null) {
            neutronvpnUtils.createVpnPortFixedIpToPort(vpnId.getValue(), ipValue, infName, port.getMacAddress().getValue(), isRouterInterface, wrtConfigTxn);
        }
        if (snTemp != null && snTemp.getInternetVpnId() != null) {
            neutronvpnUtils.createVpnPortFixedIpToPort(sn.getInternetVpnId().getValue(), ipValue, infName, port.getMacAddress().getValue(), isRouterInterface, wrtConfigTxn);
        }
        if (routerId != null) {
            Router rtr = neutronvpnUtils.getNeutronRouter(routerId);
            if (rtr != null && rtr.getRoutes() != null) {
                List<Routes> routeList = rtr.getRoutes();
                // create extraroute Adjacence for each ipValue,
                // because router can have IPv4 and IPv6 subnet ports, or can have
                // more that one IPv4 subnet port or more than one IPv6 subnet port
                List<Adjacency> erAdjList = getAdjacencyforExtraRoute(routeList, ipValue);
                if (!erAdjList.isEmpty()) {
                    adjList.addAll(erAdjList);
                }
            }
        }
    }
    return new AdjacenciesBuilder().setAdjacency(adjList).build();
}

Example 17 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 BaseVrfEntryHandler method deleteRemoteRoute.

// Allow deprecated TransactionRunner calls for now
@SuppressWarnings("ForbidCertainMethod")
public void deleteRemoteRoute(@Nullable final Uint64 localDpnId, final Uint64 remoteDpnId, final Uint32 vpnId, final VrfTablesKey vrfTableKey, final VrfEntry vrfEntry, Optional<Routes> extraRouteOptional, @Nullable WriteTransaction tx) {
    if (tx == null) {
        LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION, newTx -> deleteRemoteRoute(localDpnId, remoteDpnId, vpnId, vrfTableKey, vrfEntry, extraRouteOptional, TransactionAdapter.toWriteTransaction(newTx))), LOG, "Error deleting remote route");
        return;
    }
    LOG.debug("deleting remote route: prefix={}, vpnId={} localDpnId {} remoteDpnId {}", vrfEntry.getDestPrefix(), vpnId, localDpnId, remoteDpnId);
    String rd = vrfTableKey.getRouteDistinguisher();
    if (localDpnId != null && !Uint64.ZERO.equals(localDpnId)) {
        // localDpnId is not known when clean up happens for last vm for a vpn on a dpn
        if (extraRouteOptional.isPresent()) {
            nextHopManager.deleteLoadBalancingNextHop(vpnId, remoteDpnId, vrfEntry.getDestPrefix());
        }
        makeConnectedRoute(remoteDpnId, vpnId, vrfEntry, rd, null, NwConstants.DEL_FLOW, tx, null);
        LOG.debug("Successfully delete FIB entry: vrfEntry={}, vpnId={}", vrfEntry.getDestPrefix(), vpnId);
        return;
    }
    // below two reads are kept as is, until best way is found to identify dpnID
    VpnNexthop localNextHopInfo = nextHopManager.getVpnNexthop(vpnId, vrfEntry.getDestPrefix());
    if (extraRouteOptional.isPresent()) {
        nextHopManager.deleteLoadBalancingNextHop(vpnId, remoteDpnId, vrfEntry.getDestPrefix());
    } else {
        checkDpnDeleteFibEntry(localNextHopInfo, remoteDpnId, vpnId, vrfEntry, rd, tx, null);
    }
}

Example 18 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 BaseVrfEntryHandler method resolveAdjacency.

@NonNull
protected List<AdjacencyResult> resolveAdjacency(final Uint64 remoteDpnId, final Uint32 vpnId, final VrfEntry vrfEntry, String rd) {
    List<RoutePaths> routePaths = new ArrayList<RoutePaths>(vrfEntry.nonnullRoutePaths().values());
    FibHelper.sortIpAddress(routePaths);
    List<AdjacencyResult> adjacencyList = new ArrayList<>();
    List<String> prefixIpList;
    LOG.trace("resolveAdjacency called with remotedDpnId {}, vpnId{}, VrfEntry {}", remoteDpnId, vpnId, vrfEntry);
    final Class<? extends TunnelTypeBase> tunnelType;
    try {
        if (RouteOrigin.value(vrfEntry.getOrigin()) != RouteOrigin.BGP) {
            tunnelType = TunnelTypeVxlan.class;
            List<String> usedRds = VpnExtraRouteHelper.getUsedRds(dataBroker, vpnId, vrfEntry.getDestPrefix());
            List<Routes> vpnExtraRoutes = VpnExtraRouteHelper.getAllVpnExtraRoutes(dataBroker, fibUtil.getVpnNameFromId(vpnId), usedRds, vrfEntry.getDestPrefix());
            if (vpnExtraRoutes.isEmpty()) {
                Prefixes prefixInfo = fibUtil.getPrefixToInterface(vpnId, vrfEntry.getDestPrefix());
                /* We don't want to provide an adjacencyList for
                     * (1) an extra-route-prefix or,
                     * (2) for a local route without prefix-to-interface.
                     * Allow only self-imported routes in such cases */
                if (prefixInfo == null && FibHelper.isControllerManagedNonSelfImportedRoute(RouteOrigin.value(vrfEntry.getOrigin()))) {
                    LOG.debug("The prefix {} in rd {} for vpn {} does not have a valid extra-route or" + " prefix-to-interface entry in the data-store", vrfEntry.getDestPrefix(), rd, vpnId);
                    return adjacencyList;
                }
                prefixIpList = Collections.singletonList(vrfEntry.getDestPrefix());
            } else {
                List<String> prefixIpListLocal = new ArrayList<>();
                vpnExtraRoutes.stream().filter(route -> route.getNexthopIpList() != null).forEach(route -> route.getNexthopIpList().forEach(extraRouteIp -> {
                    String ipPrefix;
                    if (isIpv4Address(extraRouteIp)) {
                        ipPrefix = extraRouteIp + NwConstants.IPV4PREFIX;
                    } else {
                        ipPrefix = extraRouteIp + NwConstants.IPV6PREFIX;
                    }
                    prefixIpListLocal.add(ipPrefix);
                }));
                prefixIpList = prefixIpListLocal;
            }
        } else {
            prefixIpList = Collections.singletonList(vrfEntry.getDestPrefix());
            if (vrfEntry.getEncapType() == VrfEntry.EncapType.Mplsgre) {
                tunnelType = TunnelTypeMplsOverGre.class;
            } else {
                tunnelType = TunnelTypeVxlan.class;
            }
        }
        for (String prefixIp : prefixIpList) {
            if (routePaths == null || routePaths.isEmpty()) {
                LOG.trace("Processing Destination IP {} without NextHop IP", prefixIp);
                AdjacencyResult adjacencyResult = nextHopManager.getRemoteNextHopPointer(remoteDpnId, vpnId, prefixIp, null, tunnelType);
                addAdjacencyResultToList(adjacencyList, adjacencyResult);
                continue;
            }
            adjacencyList.addAll(routePaths.stream().map(routePath -> {
                LOG.debug("NextHop IP for destination {} is {}", prefixIp, routePath.getNexthopAddress());
                return nextHopManager.getRemoteNextHopPointer(remoteDpnId, vpnId, prefixIp, routePath.getNexthopAddress(), tunnelType);
            }).filter(adjacencyResult -> adjacencyResult != null && !adjacencyList.contains(adjacencyResult)).distinct().collect(toList()));
        }
    } catch (NullPointerException e) {
        // FIXME: NPEs should not be caught but rather their root cause should be eliminated
        LOG.trace("Failed to remove adjacency", e);
    }
    return adjacencyList;
}

Example 19 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 EvpnVrfEntryHandler method createLocalEvpnFlows.

private List<Uint64> createLocalEvpnFlows(Uint32 vpnId, String rd, VrfEntry vrfEntry, Prefixes localNextHopInfo) {
    List<Uint64> returnLocalDpnId = new ArrayList<>();
    String localNextHopIP = vrfEntry.getDestPrefix();
    if (localNextHopInfo == null) {
        // Handle extra routes and imported routes
        Routes extraRoute = getVpnToExtraroute(vpnId, rd, vrfEntry.getDestPrefix());
        if (extraRoute != null && extraRoute.getNexthopIpList() != null) {
            for (String nextHopIp : extraRoute.getNexthopIpList()) {
                LOG.info("NextHop IP for destination {} is {}", vrfEntry.getDestPrefix(), nextHopIp);
                if (nextHopIp != null) {
                    localNextHopInfo = getFibUtil().getPrefixToInterface(vpnId, nextHopIp + "/32");
                    if (localNextHopInfo != null) {
                        localNextHopIP = nextHopIp + "/32";
                        Uint64 dpnId = checkCreateLocalEvpnFlows(localNextHopInfo, localNextHopIP, vpnId, rd, vrfEntry);
                        returnLocalDpnId.add(dpnId);
                    }
                }
            }
        }
    } else {
        LOG.info("Creating local EVPN flows for prefix {} rd {} route-paths {} evi {}.", vrfEntry.getDestPrefix(), rd, vrfEntry.getRoutePaths(), vrfEntry.getL3vni());
        Uint64 dpnId = checkCreateLocalEvpnFlows(localNextHopInfo, localNextHopIP, vpnId, rd, vrfEntry);
        returnLocalDpnId.add(dpnId);
    }
    return returnLocalDpnId;
}

Example 20 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 VpnInterfaceManager method getVpnsExportingMyRoute.

@SuppressWarnings("checkstyle:IllegalCatch")
private List<VpnInstanceOpDataEntry> getVpnsExportingMyRoute(final String vpnName) {
    List<VpnInstanceOpDataEntry> vpnsToExportRoute = new ArrayList<>();
    final VpnInstanceOpDataEntry vpnInstanceOpDataEntry;
    String vpnRd = vpnUtil.getVpnRd(vpnName);
    try {
        VpnInstanceOpDataEntry opDataEntry = vpnUtil.getVpnInstanceOpData(vpnRd);
        if (opDataEntry == null) {
            LOG.error("getVpnsExportingMyRoute: Null vpn instance op data for vpn {} rd {}" + " when check for vpns exporting the routes", vpnName, vpnRd);
            return vpnsToExportRoute;
        }
        vpnInstanceOpDataEntry = opDataEntry;
    } catch (Exception re) {
        LOG.error("getVpnsExportingMyRoute: DSexception when retrieving vpn instance op data for vpn {} rd {}" + " to check for vpns exporting the routes", vpnName, vpnRd, re);
        return vpnsToExportRoute;
    }
    Predicate<VpnInstanceOpDataEntry> excludeVpn = input -> {
        if (input.getVpnInstanceName() == null) {
            LOG.error("getVpnsExportingMyRoute.excludeVpn: Received vpn instance with rd {}  without a name", input.getVrfId());
            return false;
        }
        return !input.getVpnInstanceName().equals(vpnName);
    };
    Predicate<VpnInstanceOpDataEntry> matchRTs = input -> {
        Iterable<String> commonRTs = VpnUtil.intersection(VpnUtil.getRts(vpnInstanceOpDataEntry, VpnTarget.VrfRTType.ImportExtcommunity), VpnUtil.getRts(input, VpnTarget.VrfRTType.ExportExtcommunity));
        return Iterators.size(commonRTs.iterator()) > 0;
    };
    vpnsToExportRoute = vpnUtil.getAllVpnInstanceOpData().stream().filter(excludeVpn).filter(matchRTs).collect(Collectors.toList());
    return vpnsToExportRoute;
}