Search in sources :

Example 91 with Identifier

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.Identifier in project netvirt by opendaylight.

the class VpnServiceChainUtils method buildLPortDispFromScfToL3VpnFlow.

/**
 * Build the flow that must be inserted when there is a ScHop whose
 * egressPort is a VPN Pseudo Port. In that case, packets must be moved
 * from the SCF to VPN Pipeline.
 * <p>
 * Flow matches:  VpnPseudo port lPortTag + SI=L3VPN
 * Actions: Write vrfTag in Metadata + goto FIB Table
 * </p>
 * @param vpnId Dataplane identifier of the VPN, the Vrf Tag.
 * @param dpId The DPN where the flow must be installed/removed
 * @param lportTag Dataplane identifier for the VpnPseudoPort
 * @param addOrRemove States if it must build a Flow to be created or
 *     removed
 *
 * @return the Flow object
 */
public static Flow buildLPortDispFromScfToL3VpnFlow(Long vpnId, BigInteger dpId, Integer lportTag, int addOrRemove) {
    LOG.info("buildLPortDispFlowForScf vpnId={} dpId={} lportTag={} addOrRemove={} ", vpnId, dpId, lportTag, addOrRemove);
    List<MatchInfo> matches = buildMatchOnLportTagAndSI(lportTag, ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME, NwConstants.L3VPN_SERVICE_INDEX));
    List<Instruction> instructions = buildSetVrfTagAndGotoFibInstructions(vpnId.intValue());
    String flowRef = getScfToL3VpnLportDispatcherFlowRef(lportTag);
    Flow result;
    if (addOrRemove == NwConstants.ADD_FLOW) {
        result = MDSALUtil.buildFlowNew(NwConstants.LPORT_DISPATCHER_TABLE, flowRef, CloudServiceChainConstants.DEFAULT_SCF_FLOW_PRIORITY, flowRef, 0, 0, VpnServiceChainUtils.getCookieL3(vpnId.intValue()), matches, instructions);
    } else {
        result = new FlowBuilder().setTableId(NwConstants.LPORT_DISPATCHER_TABLE).setId(new FlowId(flowRef)).build();
    }
    return result;
}
Also used : FlowId(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId) FlowBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder) MatchInfo(org.opendaylight.genius.mdsalutil.MatchInfo) Instruction(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction) Flow(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow)

Example 92 with Identifier

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.Identifier 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);
}
Also used : NatserviceConfig(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig) Arrays(java.util.Arrays) RouterIds(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.router.id.name.RouterIds) ActionDrop(org.opendaylight.genius.mdsalutil.actions.ActionDrop) FibRpcService(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService) ProviderTypes(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes) InetAddress(java.net.InetAddress) Future(java.util.concurrent.Future) ActionInfo(org.opendaylight.genius.mdsalutil.ActionInfo) IpMap(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.map.ip.mapping.IpMap) Subnetmap(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap) Map(java.util.Map) IBgpManager(org.opendaylight.netvirt.bgpmanager.api.IBgpManager) TunnelTypeGre(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre) BigInteger(java.math.BigInteger) VpnRpcService(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.VpnRpcService) ActionLearn(org.opendaylight.genius.mdsalutil.actions.ActionLearn) MatchMetadata(org.opendaylight.genius.mdsalutil.matches.MatchMetadata) RouterIdName(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.RouterIdName) Set(java.util.Set) ActionNxLoadInPort(org.opendaylight.genius.mdsalutil.actions.ActionNxLoadInPort) RemoveFibEntryInput(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInput) FlowEntity(org.opendaylight.genius.mdsalutil.FlowEntity) ProtocolTypes(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProtocolTypes) IpPortMappingKey(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.IpPortMappingKey) GetTunnelInterfaceNameInputBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInputBuilder) TypedWriteTransaction(org.opendaylight.mdsal.binding.util.TypedWriteTransaction) CreateFibEntryInput(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput) TypedReadWriteTransaction(org.opendaylight.mdsal.binding.util.TypedReadWriteTransaction) NonNull(org.eclipse.jdt.annotation.NonNull) ActionSetFieldTunnelId(org.opendaylight.genius.mdsalutil.actions.ActionSetFieldTunnelId) Uint64(org.opendaylight.yangtools.yang.common.Uint64) OdlInterfaceRpcService(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService) ManagedNewTransactionRunner(org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner) IElanService(org.opendaylight.netvirt.elanmanager.api.IElanService) NxmOfFieldType(org.opendaylight.genius.mdsalutil.NwConstants.NxmOfFieldType) ArrayList(java.util.ArrayList) TunnelTypeVxlan(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan) ActionPuntToController(org.opendaylight.genius.mdsalutil.actions.ActionPuntToController) RemoveVpnLabelOutput(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelOutput) ActionPopMpls(org.opendaylight.genius.mdsalutil.actions.ActionPopMpls) MatchIpProtocol(org.opendaylight.genius.mdsalutil.matches.MatchIpProtocol) RouterIdsKey(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.router.id.name.RouterIdsKey) ActionGroup(org.opendaylight.genius.mdsalutil.actions.ActionGroup) GenerateVpnLabelInputBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.GenerateVpnLabelInputBuilder) AbstractAsyncDataTreeChangeListener(org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener) RemoveVpnLabelInput(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelInput) MatchFromField(org.opendaylight.genius.mdsalutil.actions.ActionLearn.MatchFromField) UnknownHostException(java.net.UnknownHostException) FutureCallback(com.google.common.util.concurrent.FutureCallback) ExecutionException(java.util.concurrent.ExecutionException) Futures(com.google.common.util.concurrent.Futures) InstructionInfo(org.opendaylight.genius.mdsalutil.InstructionInfo) RemoveFibEntryOutput(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryOutput) InstanceIdentifier(org.opendaylight.yangtools.yang.binding.InstanceIdentifier) IMdsalApiManager(org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager) LogicalDatastoreType(org.opendaylight.mdsal.common.api.LogicalDatastoreType) IpAddress(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress) IpPortMapping(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.IpPortMapping) InstructionGotoTable(org.opendaylight.genius.mdsalutil.instructions.InstructionGotoTable) GroupTypes(org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes) MetaDataUtil(org.opendaylight.genius.mdsalutil.MetaDataUtil) DataBroker(org.opendaylight.mdsal.binding.api.DataBroker) CONFIGURATION(org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION) SingleTransactionDataBroker(org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker) IFibManager(org.opendaylight.netvirt.fibmanager.api.IFibManager) IpMapBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.map.ip.mapping.IpMapBuilder) GenerateVpnLabelOutput(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.GenerateVpnLabelOutput) LoggerFactory(org.slf4j.LoggerFactory) Flow(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow) ActionNxResubmit(org.opendaylight.genius.mdsalutil.actions.ActionNxResubmit) Uuid(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid) IpMapKey(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.map.ip.mapping.IpMapKey) PreDestroy(javax.annotation.PreDestroy) Nullable(org.eclipse.jdt.annotation.Nullable) IpPortExternal(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.ip.port.map.IpPortExternal) MDSALUtil(org.opendaylight.genius.mdsalutil.MDSALUtil) Routers(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers) CreateFibEntryOutput(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput) Ipv4Address(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address) GetTunnelInterfaceNameOutput(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameOutput) ExternalIpsCounter(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalIpsCounter) Subnets(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets) ExternalIpCounter(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.external.counters.ExternalIpCounter) RouterToNaptSwitchBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchBuilder) Collection(java.util.Collection) Configuration(org.opendaylight.mdsal.binding.util.Datastore.Configuration) InstructionApplyActions(org.opendaylight.genius.mdsalutil.instructions.InstructionApplyActions) Objects(java.util.Objects) List(java.util.List) ManagedNewTransactionRunnerImpl(org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl) TunnelTypeBase(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase) NaptSwitches(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.NaptSwitches) ExtRouters(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExtRouters) Optional(java.util.Optional) ExternalIps(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps) InstructionKey(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey) MatchFromValue(org.opendaylight.genius.mdsalutil.actions.ActionLearn.MatchFromValue) MoreExecutors(com.google.common.util.concurrent.MoreExecutors) SubnetmapKey(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey) ListenableFuture(com.google.common.util.concurrent.ListenableFuture) CreateFibEntryInputBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder) IntextIpProtocolType(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.IntextIpProtocolType) RpcResult(org.opendaylight.yangtools.yang.common.RpcResult) ExternalCounters(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.ExternalCounters) RouterToNaptSwitch(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch) Executors(org.opendaylight.infrautils.utils.concurrent.Executors) HashMap(java.util.HashMap) Singleton(javax.inject.Singleton) InstructionWriteMetadata(org.opendaylight.genius.mdsalutil.instructions.InstructionWriteMetadata) JdkFutureAdapters(com.google.common.util.concurrent.JdkFutureAdapters) HashSet(java.util.HashSet) Inject(javax.inject.Inject) RoutersKey(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey) RemoveVpnLabelInputBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelInputBuilder) MatchTunnelId(org.opendaylight.genius.mdsalutil.matches.MatchTunnelId) RemoveFibEntryInputBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInputBuilder) MatchInfo(org.opendaylight.genius.mdsalutil.MatchInfo) RouterIdsBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.router.id.name.RouterIdsBuilder) MatchEthernetType(org.opendaylight.genius.mdsalutil.matches.MatchEthernetType) NwConstants(org.opendaylight.genius.mdsalutil.NwConstants) NatMode(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig.NatMode) IInterfaceManager(org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager) IntextIpPortMap(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.IntextIpPortMap) Uint32(org.opendaylight.yangtools.yang.common.Uint32) Logger(org.slf4j.Logger) RouteOrigin(org.opendaylight.netvirt.fibmanager.api.RouteOrigin) Subnetmaps(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps) JobCoordinator(org.opendaylight.infrautils.jobcoordinator.JobCoordinator) IVpnManager(org.opendaylight.netvirt.vpnmanager.api.IVpnManager) IpPortMap(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.IpPortMap) GroupEntity(org.opendaylight.genius.mdsalutil.GroupEntity) IdManagerService(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService) Inet6Address(java.net.Inet6Address) Port(org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port) GenerateVpnLabelInput(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.GenerateVpnLabelInput) MatchMplsLabel(org.opendaylight.genius.mdsalutil.matches.MatchMplsLabel) BucketInfo(org.opendaylight.genius.mdsalutil.BucketInfo) Collections(java.util.Collections) Instruction(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction) RouterToNaptSwitchKey(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchKey) ItmRpcService(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService) HashMap(java.util.HashMap) ArrayList(java.util.ArrayList) IpPortMapping(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.IpPortMapping) ProtocolTypes(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProtocolTypes) ArrayList(java.util.ArrayList) List(java.util.List) IpPortExternal(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.ip.port.map.IpPortExternal) ExecutionException(java.util.concurrent.ExecutionException) Uint32(org.opendaylight.yangtools.yang.common.Uint32) HashSet(java.util.HashSet) IpPortMappingKey(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.IpPortMappingKey) IpMap(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.map.ip.mapping.IpMap) ExternalIps(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps) Uuid(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid) IntextIpPortMap(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.IntextIpPortMap) IpPortMap(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.IpPortMap) IntextIpProtocolType(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.IntextIpProtocolType) ListenableFuture(com.google.common.util.concurrent.ListenableFuture) IpMap(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.map.ip.mapping.IpMap) Map(java.util.Map) HashMap(java.util.HashMap) IntextIpPortMap(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.IntextIpPortMap) IpPortMap(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.IpPortMap) Uint64(org.opendaylight.yangtools.yang.common.Uint64)

Example 93 with Identifier

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.Identifier in project netvirt by opendaylight.

the class ExternalRoutersListener method remove.

@Override
public void remove(InstanceIdentifier<Routers> identifier, Routers router) {
    if (natMode != NatMode.Controller) {
        return;
    }
    LOG.trace("remove : Router delete method");
    if (identifier == null || router == null) {
        LOG.error("remove : returning without processing since routers is null");
        return;
    }
    String routerName = router.getRouterName();
    coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + router.key(), () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
        LOG.info("remove : Removing default NAT route from FIB on all dpns part of router {} ", routerName);
        Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
        if (routerId == NatConstants.INVALID_ID) {
            LOG.error("remove : Remove external router event - Invalid routerId for routerName {}", routerName);
            return;
        }
        Uint32 bgpVpnId = NatConstants.INVALID_ID;
        Uuid bgpVpnUuid = NatUtil.getVpnForRouter(dataBroker, routerName);
        if (bgpVpnUuid != null) {
            bgpVpnId = NatUtil.getVpnId(dataBroker, bgpVpnUuid.getValue());
        }
        addOrDelDefFibRouteToSNAT(routerName, routerId, bgpVpnId, bgpVpnUuid, false, tx);
        Uuid networkUuid = router.getNetworkId();
        Uint64 primarySwitchId = NatUtil.getPrimaryNaptfromRouterName(dataBroker, routerName);
        if (primarySwitchId == null || primarySwitchId.equals(Uint64.ZERO)) {
            // No NAPT switch for external router, probably because the router is not attached to
            // any
            // internal networks
            LOG.debug("No NAPT switch for router {}, check if router is attached to any internal " + "network", routerName);
            return;
        } else {
            Collection<String> externalIps = NatUtil.getExternalIpsForRouter(dataBroker, routerId);
            final String vpnName = NatUtil.getAssociatedVPN(dataBroker, networkUuid);
            handleDisableSnat(router, networkUuid, externalIps, true, vpnName, primarySwitchId, routerId, tx);
        }
        if (NatUtil.releaseId(idManager, NatConstants.ODL_VNI_POOL_NAME, routerName) == NatConstants.INVALID_ID) {
            LOG.error("remove: Unable to release VNI for router - {}", routerName);
        }
    })), NatConstants.NAT_DJC_MAX_RETRIES);
}
Also used : Uuid(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid) Uint32(org.opendaylight.yangtools.yang.common.Uint32) Uint64(org.opendaylight.yangtools.yang.common.Uint64)

Example 94 with Identifier

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.Identifier in project netvirt by opendaylight.

the class ExternalNetworksChangeListener method update.

@Override
public void update(InstanceIdentifier<Networks> identifier, Networks original, Networks update) {
    // Check for VPN disassociation
    Uuid originalVpn = original.getVpnid();
    Uuid updatedVpn = update.getVpnid();
    if (originalVpn == null && updatedVpn != null) {
        // external network is dis-associated from L3VPN instance
        associateExternalNetworkWithVPN(update);
    } else if (originalVpn != null && updatedVpn == null) {
        // external network is associated with vpn
        disassociateExternalNetworkFromVPN(update, originalVpn.getValue());
        // Remove the SNAT entries
        removeSnatEntries(original, original.getId());
    }
}
Also used : Uuid(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid)

Example 95 with Identifier

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev200120.Identifier in project netvirt by opendaylight.

the class FloatingIPListener method processFloatingIPDel.

private void processFloatingIPDel(final InstanceIdentifier<InternalToExternalPortMap> identifier, final InternalToExternalPortMap mapping) {
    LOG.trace("processFloatingIPDel : key: {}, value: {}", mapping.key(), mapping);
    final String routerId = identifier.firstKeyOf(RouterPorts.class).getRouterId();
    final PortsKey pKey = identifier.firstKeyOf(Ports.class);
    String interfaceName = pKey.getPortName();
    InstanceIdentifier<RouterPorts> portIid = identifier.firstIdentifierOf(RouterPorts.class);
    coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + mapping.key(), () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> removeNATFlowEntries(interfaceName, mapping, portIid, routerId, null, tx))), NatConstants.NAT_DJC_MAX_RETRIES);
}
Also used : RouterPorts(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.RouterPorts) PortsKey(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.router.ports.PortsKey)

Aggregations

Identifier (org.apache.cxf.ws.rm.v200702.Identifier)72 ArrayList (java.util.ArrayList)71 Uint64 (org.opendaylight.yangtools.yang.common.Uint64)59 Test (org.junit.Test)52 Uuid (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid)50 InstanceIdentifier (org.opendaylight.yangtools.yang.binding.InstanceIdentifier)50 ExecutionException (java.util.concurrent.ExecutionException)38 Uint32 (org.opendaylight.yangtools.yang.common.Uint32)37 Logger (org.slf4j.Logger)35 LoggerFactory (org.slf4j.LoggerFactory)35 Inject (javax.inject.Inject)32 Singleton (javax.inject.Singleton)32 DataBroker (org.opendaylight.mdsal.binding.api.DataBroker)32 LogicalDatastoreType (org.opendaylight.mdsal.common.api.LogicalDatastoreType)32 PreDestroy (javax.annotation.PreDestroy)30 ManagedNewTransactionRunner (org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner)30 ManagedNewTransactionRunnerImpl (org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl)30 Executors (org.opendaylight.infrautils.utils.concurrent.Executors)28 CONFIGURATION (org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION)27 AbstractAsyncDataTreeChangeListener (org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener)26