Examples with Tables org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.Tables used on opensource projects

Example 11 with Tables

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.Tables in project openflowplugin by opendaylight.

the class OF10FeaturesReplyMessageFactoryTest method testSerialize.

@Test
public void testSerialize() throws Exception {
    GetFeaturesOutputBuilder builder = new GetFeaturesOutputBuilder();
    BufferHelper.setupHeader(builder, EncodeConstants.OF10_VERSION_ID);
    builder.setDatapathId(BigInteger.valueOf(1L));
    builder.setBuffers(1L);
    builder.setTables((short) 1);
    builder.setCapabilitiesV10(new CapabilitiesV10(true, false, true, false, true, false, true, false));
    builder.setActionsV10(new ActionTypeV10(true, false, true, false, true, false, true, false, true, false, true, false, true));
    builder.setPhyPort(createPorts());
    GetFeaturesOutput message = builder.build();
    ByteBuf serializedBuffer = UnpooledByteBufAllocator.DEFAULT.buffer();
    factory.serialize(message, serializedBuffer);
    BufferHelper.checkHeaderV10(serializedBuffer, MESSAGE_TYPE, 80);
    Assert.assertEquals("Wrong datapath id", message.getDatapathId().longValue(), serializedBuffer.readLong());
    Assert.assertEquals("Wrong n buffers", message.getBuffers().longValue(), serializedBuffer.readUnsignedInt());
    Assert.assertEquals("Wrong n tables", message.getTables().shortValue(), serializedBuffer.readUnsignedByte());
    serializedBuffer.skipBytes(3);
    Assert.assertEquals("Wrong capabilities", message.getCapabilitiesV10(), createCapabilities(serializedBuffer.readInt()));
    Assert.assertEquals("Wrong actions", message.getActionsV10(), createActionsV10(serializedBuffer.readInt()));
    PhyPort port = message.getPhyPort().get(0);
    Assert.assertEquals("Wrong port No", port.getPortNo().intValue(), serializedBuffer.readShort());
    byte[] address = new byte[6];
    serializedBuffer.readBytes(address);
    Assert.assertEquals("Wrong MacAddress", port.getHwAddr().getValue().toLowerCase(), new MacAddress(ByteBufUtils.macAddressToString(address)).getValue().toLowerCase());
    byte[] name = new byte[16];
    serializedBuffer.readBytes(name);
    Assert.assertEquals("Wrong name", port.getName(), new String(name).trim());
    Assert.assertEquals("Wrong config", port.getConfigV10(), createPortConfig(serializedBuffer.readInt()));
    Assert.assertEquals("Wrong state", port.getStateV10(), createPortState(serializedBuffer.readInt()));
    Assert.assertEquals("Wrong current", port.getCurrentFeaturesV10(), createPortFeatures(serializedBuffer.readInt()));
    Assert.assertEquals("Wrong advertised", port.getAdvertisedFeaturesV10(), createPortFeatures(serializedBuffer.readInt()));
    Assert.assertEquals("Wrong supported", port.getSupportedFeaturesV10(), createPortFeatures(serializedBuffer.readInt()));
    Assert.assertEquals("Wrong peer", port.getPeerFeaturesV10(), createPortFeatures(serializedBuffer.readInt()));
}

Example 12 with Tables

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.Tables in project netvirt by opendaylight.

the class ExternalRoutersListener method update.

@Override
public void update(InstanceIdentifier<Routers> identifier, Routers original, Routers update) {
    if (natMode != NatMode.Controller) {
        return;
    }
    LOG.trace("update : origRouter: {} updatedRouter: {}", original, update);
    String routerName = original.getRouterName();
    Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
    if (routerId == NatConstants.INVALID_ID) {
        LOG.error("update : external router event - Invalid routerId for routerName {}", routerName);
        return;
    }
    coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + update.key(), () -> {
        List<ListenableFuture<?>> futures = new ArrayList<>();
        futures.add(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, writeFlowInvTx -> {
            futures.add(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, removeFlowInvTx -> {
                Uint32 bgpVpnId = NatConstants.INVALID_ID;
                Uuid bgpVpnUuid = NatUtil.getVpnForRouter(dataBroker, routerName);
                if (bgpVpnUuid != null) {
                    bgpVpnId = NatUtil.getVpnId(dataBroker, bgpVpnUuid.getValue());
                }
                // BigInteger dpnId = getPrimaryNaptSwitch(routerName);
                /* Get Primary Napt Switch for existing router from "router-to-napt-switch" DS.
                     * if dpnId value is null or zero then go for electing new Napt switch for existing router.
                     */
                Uint64 dpnId = NatUtil.getPrimaryNaptfromRouterName(dataBroker, routerName);
                boolean isPrimaryNaptSwitchNotSelected = (dpnId == null || dpnId.equals(Uint64.valueOf(BigInteger.ZERO)));
                Uuid networkId = original.getNetworkId();
                // Check if its update on SNAT flag
                boolean originalSNATEnabled = original.isEnableSnat();
                boolean updatedSNATEnabled = update.isEnableSnat();
                LOG.debug("update :called with originalFlag and updatedFlag for SNAT enabled " + "as {} and {} with Elected Dpn {}(isPrimaryNaptSwitchNotSelected:{})", originalSNATEnabled, updatedSNATEnabled, dpnId, isPrimaryNaptSwitchNotSelected);
                // 3. First Elect dpnId and process other changes with valid dpnId
                if (originalSNATEnabled != updatedSNATEnabled || isPrimaryNaptSwitchNotSelected) {
                    if (originalSNATEnabled && !updatedSNATEnabled) {
                        if (isPrimaryNaptSwitchNotSelected) {
                            LOG.info("No Action to be taken when SNAT is disabled " + "with no Napt Switch Election for Router {}", routerName);
                            return;
                        }
                        // SNAT disabled for the router
                        Uuid networkUuid = original.getNetworkId();
                        LOG.info("update : SNAT disabled for Router {}", routerName);
                        Collection<String> externalIps = NatUtil.getExternalIpsForRouter(dataBroker, routerId);
                        final String vpnName = NatUtil.getAssociatedVPN(dataBroker, networkId);
                        handleDisableSnat(original, networkUuid, externalIps, false, vpnName, dpnId, routerId, removeFlowInvTx);
                    } else if (updatedSNATEnabled) {
                        LOG.info("update : SNAT enabled for Router {}", routerName);
                        addOrDelDefFibRouteToSNAT(routerName, routerId, bgpVpnId, bgpVpnUuid, true, writeFlowInvTx);
                        if (isPrimaryNaptSwitchNotSelected) {
                            dpnId = selectNewNAPTSwitch(routerName);
                            if (dpnId != null && !dpnId.equals(Uint64.valueOf(BigInteger.ZERO))) {
                                handleEnableSnat(update, routerId, dpnId, bgpVpnId, removeFlowInvTx);
                            } else {
                                LOG.error("update : Failed to elect Napt Switch During update event" + " of router {}", routerName);
                            }
                        }
                    }
                    LOG.info("update : no need to process external/subnet changes as it's will taken care" + "in handleDisableSnat/handleEnableSnat");
                    return;
                }
                if (!Objects.equals(original.getExtGwMacAddress(), update.getExtGwMacAddress())) {
                    NatUtil.installRouterGwFlows(txRunner, vpnManager, original, dpnId, NwConstants.DEL_FLOW);
                    NatUtil.installRouterGwFlows(txRunner, vpnManager, update, dpnId, NwConstants.ADD_FLOW);
                }
                if (updatedSNATEnabled != originalSNATEnabled) {
                    LOG.info("update : no need to process external/subnet changes as it's will taken care in " + "handleDisableSnat/handleEnableSnat");
                    return;
                }
                // Check if the Update is on External IPs
                LOG.debug("update : Checking if this is update on External IPs for router {}", routerName);
                List<String> originalExternalIps = NatUtil.getIpsListFromExternalIps(new ArrayList<ExternalIps>(original.nonnullExternalIps().values()));
                List<String> updatedExternalIps = NatUtil.getIpsListFromExternalIps(new ArrayList<ExternalIps>(update.nonnullExternalIps().values()));
                // Check if the External IPs are removed during the update.
                Set<String> removedExternalIps = new HashSet<>(originalExternalIps);
                removedExternalIps.removeAll(updatedExternalIps);
                if (removedExternalIps.size() > 0) {
                    LOG.debug("update : Start processing of the External IPs removal for router {}", routerName);
                    vpnManager.removeArpResponderFlowsToExternalNetworkIps(routerName, removedExternalIps, original.getExtGwMacAddress(), dpnId, networkId);
                    for (String removedExternalIp : removedExternalIps) {
                        /*
                    1) Remove the mappings in the IntExt IP model which has external IP.
                    2) Remove the external IP in the ExternalCounter model.
                    3) For the corresponding subnet IDs whose external IP mapping was removed, allocate one of the
                       least loaded external IP.
                       Store the subnet IP and the reallocated external IP mapping in the IntExtIp model.
                    4) Increase the count of the allocated external IP by one.
                    5) Advertise to the BGP if external IP is allocated for the first time for the router
                     i.e. the route for the external IP is absent.
                    6) Remove the NAPT translation entries from Inbound and Outbound NAPT tables for
                     the removed external IPs and also from the model.
                    7) Advertise to the BGP for removing the route for the removed external IPs.
                 */
                        String[] externalIpParts = NatUtil.getExternalIpAndPrefix(removedExternalIp);
                        String externalIp = externalIpParts[0];
                        String externalIpPrefix = externalIpParts[1];
                        String externalIpAddrStr = externalIp + "/" + externalIpPrefix;
                        LOG.debug("update : Clear the routes from the BGP and remove the FIB and TS " + "entries for removed external IP {}", externalIpAddrStr);
                        Uuid vpnUuId = NatUtil.getVpnIdfromNetworkId(dataBroker, networkId);
                        String vpnName = "";
                        if (vpnUuId != null) {
                            vpnName = vpnUuId.getValue();
                        }
                        clrRtsFromBgpAndDelFibTs(dpnId, routerId, externalIpAddrStr, vpnName, networkId, update.getExtGwMacAddress(), removeFlowInvTx);
                        LOG.debug("update : Remove the mappings in the IntExtIP model which has external IP.");
                        // Get the internal IPs which are associated to the removed external IPs
                        List<IpMap> ipMaps = naptManager.getIpMapList(dataBroker, routerId);
                        List<String> removedInternalIps = new ArrayList<>();
                        for (IpMap ipMap : ipMaps) {
                            if (ipMap.getExternalIp().equals(externalIpAddrStr)) {
                                removedInternalIps.add(ipMap.getInternalIp());
                            }
                        }
                        LOG.debug("update : Remove the mappings of the internal IPs from the IntExtIP model.");
                        for (String removedInternalIp : removedInternalIps) {
                            LOG.debug("update : Remove the IP mapping of the internal IP {} for the " + "router ID {} from the IntExtIP model", removedInternalIp, routerId);
                            naptManager.removeFromIpMapDS(routerId, removedInternalIp);
                        }
                        LOG.debug("update : Remove the count mapping of the external IP {} for the " + "router ID {} from the ExternalIpsCounter model.", externalIpAddrStr, routerId);
                        naptManager.removeExternalIpCounter(routerId, externalIpAddrStr);
                        LOG.debug("update : Allocate the least loaded external IPs to the subnets " + "whose external IPs were removed.");
                        for (String removedInternalIp : removedInternalIps) {
                            allocateExternalIp(dpnId, update, routerId, routerName, networkId, removedInternalIp, writeFlowInvTx);
                        }
                        LOG.debug("update : Remove the NAPT translation entries from " + "Inbound and Outbound NAPT tables for the removed external IPs.");
                        // Get the internalIP and internal Port which were associated to the removed external IP.
                        Map<ProtocolTypes, List<String>> protoTypesIntIpPortsMap = new HashMap<>();
                        InstanceIdentifier<IpPortMapping> ipPortMappingId = InstanceIdentifier.builder(IntextIpPortMap.class).child(IpPortMapping.class, new IpPortMappingKey(routerId)).build();
                        Optional<IpPortMapping> ipPortMapping;
                        try {
                            ipPortMapping = SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, ipPortMappingId);
                        } catch (InterruptedException | ExecutionException e) {
                            LOG.error("Failed to read ipPortMapping for router id {}", routerId, e);
                            ipPortMapping = Optional.empty();
                        }
                        if (ipPortMapping.isPresent()) {
                            for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.get().nonnullIntextIpProtocolType().values()) {
                                ProtocolTypes protoType = intextIpProtocolType.getProtocol();
                                for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap().values()) {
                                    IpPortExternal ipPortExternal = ipPortMap.getIpPortExternal();
                                    if (ipPortExternal.getIpAddress().equals(externalIp)) {
                                        List<String> removedInternalIpPorts = protoTypesIntIpPortsMap.get(protoType);
                                        if (removedInternalIpPorts != null) {
                                            removedInternalIpPorts.add(ipPortMap.getIpPortInternal());
                                            protoTypesIntIpPortsMap.put(protoType, removedInternalIpPorts);
                                        } else {
                                            removedInternalIpPorts = new ArrayList<>();
                                            removedInternalIpPorts.add(ipPortMap.getIpPortInternal());
                                            protoTypesIntIpPortsMap.put(protoType, removedInternalIpPorts);
                                        }
                                    }
                                }
                            }
                        }
                        // Remove the IP port map from the intext-ip-port-map model, which were containing
                        // the removed external IP.
                        Set<Map.Entry<ProtocolTypes, List<String>>> protoTypesIntIpPorts = protoTypesIntIpPortsMap.entrySet();
                        Map<String, List<String>> internalIpPortMap = new HashMap<>();
                        for (Map.Entry protoTypesIntIpPort : protoTypesIntIpPorts) {
                            ProtocolTypes protocolType = (ProtocolTypes) protoTypesIntIpPort.getKey();
                            List<String> removedInternalIpPorts = (List<String>) protoTypesIntIpPort.getValue();
                            for (String removedInternalIpPort : removedInternalIpPorts) {
                                // Remove the IP port map from the intext-ip-port-map model,
                                // which were containing the removed external IP
                                naptManager.removeFromIpPortMapDS(routerId, removedInternalIpPort, protocolType);
                                // Remove the IP port incomint packer map.
                                naptPacketInHandler.removeIncomingPacketMap(routerId + NatConstants.COLON_SEPARATOR + removedInternalIpPort);
                                String[] removedInternalIpPortParts = removedInternalIpPort.split(NatConstants.COLON_SEPARATOR);
                                if (removedInternalIpPortParts.length == 2) {
                                    String removedInternalIp = removedInternalIpPortParts[0];
                                    String removedInternalPort = removedInternalIpPortParts[1];
                                    List<String> removedInternalPortsList = internalIpPortMap.get(removedInternalPort);
                                    if (removedInternalPortsList != null) {
                                        removedInternalPortsList.add(removedInternalPort);
                                        internalIpPortMap.put(removedInternalIp, removedInternalPortsList);
                                        naptPacketInHandler.removeIncomingPacketMap(routerId + NatConstants.COLON_SEPARATOR + removedInternalIp + NatConstants.COLON_SEPARATOR + removedInternalPort);
                                        // Remove the NAPT translation entries from Outbound NAPT table
                                        naptEventHandler.removeNatFlows(dpnId, NwConstants.OUTBOUND_NAPT_TABLE, routerId, removedInternalIp, Integer.parseInt(removedInternalPort), protocolType.getName());
                                        naptEventHandler.removeNatFlows(dpnId, NwConstants.INBOUND_NAPT_TABLE, routerId, removedInternalIp, Integer.parseInt(removedInternalPort), protocolType.getName());
                                    } else {
                                        removedInternalPortsList = new ArrayList<>();
                                        removedInternalPortsList.add(removedInternalPort);
                                        internalIpPortMap.put(removedInternalIp, removedInternalPortsList);
                                        naptPacketInHandler.removeIncomingPacketMap(routerId + NatConstants.COLON_SEPARATOR + removedInternalIp + NatConstants.COLON_SEPARATOR + removedInternalPort);
                                        // Remove the NAPT translation entries from Outbound NAPT table
                                        naptEventHandler.removeNatFlows(dpnId, NwConstants.OUTBOUND_NAPT_TABLE, routerId, removedInternalIp, Integer.parseInt(removedInternalPort), protocolType.getName());
                                        naptEventHandler.removeNatFlows(dpnId, NwConstants.INBOUND_NAPT_TABLE, routerId, removedInternalIp, Integer.parseInt(removedInternalPort), protocolType.getName());
                                    }
                                }
                            }
                        }
                        // Delete the entry from SnatIntIpPortMap DS
                        Set<String> internalIps = internalIpPortMap.keySet();
                        for (String internalIp : internalIps) {
                            LOG.debug("update : Removing IpPort having the internal IP {} from the " + "model SnatIntIpPortMap", internalIp);
                            naptManager.removeFromSnatIpPortDS(routerId, internalIp);
                        }
                        naptManager.removeNaptPortPool(externalIp);
                    }
                    LOG.debug("update : End processing of the External IPs removal for router {}", routerName);
                }
                // Check if the External IPs are added during the update.
                Set<String> addedExternalIps = new HashSet<>(updatedExternalIps);
                addedExternalIps.removeAll(originalExternalIps);
                if (addedExternalIps.size() != 0) {
                    LOG.debug("update : Start processing of the External IPs addition for router {}", routerName);
                    vpnManager.addArpResponderFlowsToExternalNetworkIps(routerName, addedExternalIps, update.getExtGwMacAddress(), dpnId, update.getNetworkId());
                    for (String addedExternalIp : addedExternalIps) {
                        /*
                    1) Do nothing in the IntExtIp model.
                    2) Initialise the count of the added external IP to 0 in the ExternalCounter model.
                 */
                        String[] externalIpParts = NatUtil.getExternalIpAndPrefix(addedExternalIp);
                        String externalIp = externalIpParts[0];
                        String externalIpPrefix = externalIpParts[1];
                        String externalpStr = externalIp + "/" + externalIpPrefix;
                        LOG.debug("update : Initialise the count mapping of the external IP {} for the " + "router ID {} in the ExternalIpsCounter model.", externalpStr, routerId);
                        naptManager.initialiseNewExternalIpCounter(routerId, externalpStr);
                        subnetRegisterMapping(update, routerId);
                        LOG.info("update : Installing fib flow fo newly added Ips");
                        handleSnatReverseTraffic(writeFlowInvTx, dpnId, update, routerId, routerName, externalpStr);
                    }
                    LOG.debug("update : End processing of the External IPs addition during the update operation");
                }
                // Check if its Update on subnets
                LOG.debug("update : Checking if this is update on subnets for router {}", routerName);
                List<Uuid> originalSubnetIds = original.getSubnetIds();
                List<Uuid> updatedSubnetIds = update.getSubnetIds();
                Set<Uuid> addedSubnetIds = updatedSubnetIds != null ? new HashSet<>(updatedSubnetIds) : new HashSet<>();
                if (originalSubnetIds != null) {
                    addedSubnetIds.removeAll(originalSubnetIds);
                }
                // Check if the Subnet IDs are added during the update.
                if (addedSubnetIds.size() != 0) {
                    LOG.debug("update : Start processing of the Subnet IDs addition for router {}", routerName);
                    for (Uuid addedSubnetId : addedSubnetIds) {
                        /*
                    1) Select the least loaded external IP for the subnet and store the mapping of the
                    subnet IP and the external IP in the IntExtIp model.
                    2) Increase the count of the selected external IP by one.
                    3) Advertise to the BGP if external IP is allocated for the first time for the
                    router i.e. the route for the external IP is absent.
                 */
                        String subnetIp = NatUtil.getSubnetIp(dataBroker, addedSubnetId);
                        if (subnetIp != null) {
                            allocateExternalIp(dpnId, update, routerId, routerName, networkId, subnetIp, writeFlowInvTx);
                        }
                    }
                    LOG.debug("update : End processing of the Subnet IDs addition for router {}", routerName);
                }
                // Check if the Subnet IDs are removed during the update.
                Set<Uuid> removedSubnetIds = new HashSet<>(originalSubnetIds);
                removedSubnetIds.removeAll(updatedSubnetIds);
                if (removedSubnetIds.size() != 0) {
                    LOG.debug("update : Start processing of the Subnet IDs removal for router {}", routerName);
                    for (Uuid removedSubnetId : removedSubnetIds) {
                        String[] subnetAddr = NatUtil.getSubnetIpAndPrefix(dataBroker, removedSubnetId);
                        if (subnetAddr != null) {
                            /*
                        1) Remove the subnet IP and the external IP in the IntExtIp map
                        2) Decrease the count of the coresponding external IP by one.
                        3) Advertise to the BGP for removing the routes of the corresponding external
                        IP if its not allocated to any other internal IP.
                    */
                            String externalIp = naptManager.getExternalIpAllocatedForSubnet(routerId, subnetAddr[0] + "/" + subnetAddr[1]);
                            if (externalIp == null) {
                                LOG.error("update : No mapping found for router ID {} and internal IP {}", routerId, subnetAddr[0]);
                                return;
                            }
                            naptManager.updateCounter(routerId, externalIp, false);
                            // used by any other internal ip in any router
                            if (!isExternalIpAllocated(externalIp)) {
                                LOG.debug("update : external ip is not allocated to any other " + "internal IP so proceeding to remove routes");
                                clrRtsFromBgpAndDelFibTs(dpnId, routerId, networkId, Collections.singleton(externalIp), null, update.getExtGwMacAddress(), removeFlowInvTx);
                                LOG.debug("update : Successfully removed fib entries in switch {} for " + "router {} with networkId {} and externalIp {}", dpnId, routerId, networkId, externalIp);
                            }
                            LOG.debug("update : Remove the IP mapping for the router ID {} and " + "internal IP {} external IP {}", routerId, subnetAddr[0], externalIp);
                            naptManager.removeIntExtIpMapDS(routerId, subnetAddr[0] + "/" + subnetAddr[1]);
                        }
                    }
                    LOG.debug("update : End processing of the Subnet IDs removal for router {}", routerName);
                }
            }));
        }));
        return futures;
    }, NatConstants.NAT_DJC_MAX_RETRIES);
}

Example 13 with Tables

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.Tables in project netvirt by opendaylight.

the class IVpnLinkServiceImpl method handleStaticRoute.

/*
     * Takes care of an static route to see if flows related to interVpnLink
     * must be installed in tables 20 and 17
     *
     * @param vpnId Vpn to which the route belongs
     * @param route Route to handle. Will only be considered if its nexthop is the VPN's endpoint IpAddress
     *              at the other side of the InterVpnLink
     * @param iVpnLink
     */
@SuppressWarnings("checkstyle:IllegalCatch")
private void handleStaticRoute(String vpnId, Routes route, InterVpnLinkDataComposite ivpnLink) {
    IpAddress nhIpAddr = route.getNexthop();
    String routeNextHop = nhIpAddr.getIpv4Address() != null ? nhIpAddr.getIpv4Address().getValue() : nhIpAddr.getIpv6Address().getValue();
    String destination = route.getDestination().stringValue();
    // is nexthop the other endpoint's IP
    String otherEndpoint = ivpnLink.getOtherEndpoint(vpnId);
    if (!routeNextHop.equals(otherEndpoint)) {
        LOG.debug("VPN {}: Route to {} nexthop={} points to an InterVpnLink endpoint, but its not " + "the other endpoint. Other endpoint is {}", vpnId, destination, routeNextHop, otherEndpoint);
        return;
    }
    // Lets work: 1) write Fibentry, 2) advertise to BGP and 3) check if it must be leaked
    String vpnRd = vpnUtil.getVpnRd(vpnId);
    if (vpnRd == null) {
        LOG.warn("Could not find Route-Distinguisher for VpnName {}", vpnId);
        return;
    }
    Uint32 label = vpnUtil.getUniqueId(VpnConstants.VPN_IDPOOL_NAME, VpnUtil.getNextHopLabelKey(vpnId, destination));
    try {
        interVpnLinkUtil.handleStaticRoute(ivpnLink, vpnId, destination, routeNextHop, label);
    } catch (Exception e) {
        LOG.error("Exception while advertising prefix for intervpn link", e);
    }
}

Example 14 with Tables

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.Tables in project netvirt by opendaylight.

the class VPNServiceChainHandlerTest method stubGetVrfEntries.

private void stubGetVrfEntries(String rd, List<VrfEntry> vrfEntryList) throws Exception {
    VrfTables tables = new VrfTablesBuilder().withKey(new VrfTablesKey(rd)).setRouteDistinguisher(rd).setVrfEntry(vrfEntryList).build();
    CheckedFuture chkdFuture = mock(CheckedFuture.class);
    when(chkdFuture.get()).thenReturn(Optional.of(tables));
    when(readTx.read(eq(LogicalDatastoreType.CONFIGURATION), eq(VpnServiceChainUtils.buildVrfId(rd)))).thenReturn(chkdFuture);
}

Example 15 with Tables

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.graceful.restart.capability.Tables in project netvirt by opendaylight.

the class ElanMacEntryListener method remove.

@Override
public void remove(final InstanceIdentifier<MacEntry> identifier, final MacEntry del) {
    LOG.trace("ElanMacEntryListener remove : {}", del);
    elanClusterUtils.runOnlyInOwnerNode(del.getMacAddress().getValue(), "Deleting dpn macs from remote ucast mac tables", () -> {
        String elanName = identifier.firstKeyOf(MacTable.class).getElanInstanceName();
        ElanInstance elanInstance = elanInstanceCache.get(elanName).orElse(null);
        elanL2GatewayUtils.removeMacsFromElanExternalDevices(elanInstance, Lists.newArrayList(del.getMacAddress()));
        return Collections.emptyList();
    });
}