Examples with RouterId org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId used on opensource projects

Example 46 with RouterId

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId in project netvirt by opendaylight.

the class VpnManagerImpl method addExtraRoute.

@Override
public void addExtraRoute(String vpnName, String destination, String nextHop, String rd, @Nullable String routerID, Uint32 l3vni, RouteOrigin origin, @Nullable String intfName, @Nullable Adjacency operationalAdj, VrfEntry.EncapType encapType, Set<String> prefixListForRefreshFib, @NonNull TypedWriteTransaction<Configuration> confTx) {
    // add extra route to vpn mapping; advertise with nexthop as tunnel ip
    vpnUtil.syncUpdate(LogicalDatastoreType.OPERATIONAL, VpnExtraRouteHelper.getVpnToExtrarouteVrfIdIdentifier(vpnName, rd != null ? rd : routerID, destination), VpnUtil.getVpnToExtraroute(destination, Collections.singletonList(nextHop)));
    Uint64 dpnId = null;
    if (intfName != null && !intfName.isEmpty()) {
        dpnId = InterfaceUtils.getDpnForInterface(ifaceMgrRpcService, intfName);
        String nextHopIp = InterfaceUtils.getEndpointIpAddressForDPN(dataBroker, dpnId);
        if (nextHopIp == null || nextHopIp.isEmpty()) {
            LOG.error("addExtraRoute: NextHop for interface {} is null / empty." + " Failed advertising extra route for rd {} prefix {} dpn {}", intfName, rd, destination, dpnId);
            return;
        }
        nextHop = nextHopIp;
    }
    String primaryRd = vpnUtil.getPrimaryRd(vpnName);
    // TODO: This is a limitation to be stated in docs. When configuring static route to go to
    // another VPN, there can only be one nexthop or, at least, the nexthop to the interVpnLink should be in
    // first place.
    Optional<InterVpnLinkDataComposite> optVpnLink = interVpnLinkCache.getInterVpnLinkByEndpoint(nextHop);
    if (optVpnLink.isPresent() && optVpnLink.get().isActive()) {
        InterVpnLinkDataComposite interVpnLink = optVpnLink.get();
        // If the nexthop is the endpoint of Vpn2, then prefix must be advertised to Vpn1 in DC-GW, with nexthops
        // pointing to the DPNs where Vpn1 is instantiated. LFIB in these DPNS must have a flow entry, with lower
        // priority, where if Label matches then sets the lportTag of the Vpn2 endpoint and goes to LportDispatcher
        // This is like leaking one of the Vpn2 routes towards Vpn1
        String srcVpnUuid = interVpnLink.getVpnNameByIpAddress(nextHop);
        String dstVpnUuid = interVpnLink.getOtherVpnNameByIpAddress(nextHop);
        String dstVpnRd = vpnUtil.getVpnRd(dstVpnUuid);
        Uint32 newLabel = vpnUtil.getUniqueId(VpnConstants.VPN_IDPOOL_NAME, VpnUtil.getNextHopLabelKey(dstVpnRd, destination));
        if (newLabel.longValue() == VpnConstants.INVALID_LABEL) {
            LOG.error("addExtraRoute: Unable to fetch label from Id Manager. Bailing out of adding intervpnlink" + " route for destination {}", destination);
            return;
        }
        ivpnLinkService.leakRoute(interVpnLink, srcVpnUuid, dstVpnUuid, destination, newLabel, RouteOrigin.STATIC);
    } else {
        Optional<Routes> optVpnExtraRoutes = VpnExtraRouteHelper.getVpnExtraroutes(dataBroker, vpnName, rd != null ? rd : routerID, destination);
        if (optVpnExtraRoutes.isPresent()) {
            List<String> nhList = optVpnExtraRoutes.get().getNexthopIpList();
            if (nhList != null && nhList.size() > 1) {
                // If nhList is greater than one for vpnextraroute, a call to populatefib doesn't update vrfentry.
                prefixListForRefreshFib.add(destination);
            } else {
                L3vpnInput input = new L3vpnInput().setNextHop(operationalAdj).setNextHopIp(nextHop).setL3vni(l3vni.longValue()).setPrimaryRd(primaryRd).setVpnName(vpnName).setDpnId(dpnId).setEncapType(encapType).setRd(rd).setRouteOrigin(origin);
                L3vpnRegistry.getRegisteredPopulator(encapType).populateFib(input, confTx);
            }
        }
    }
}

Example 47 with RouterId

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId in project netvirt by opendaylight.

the class SubnetRoutePacketInHandler method handlePacketFromTunnelToExternalNetwork.

private void handlePacketFromTunnelToExternalNetwork(String vpnIdVpnInstanceName, String srcIpStr, byte[] dstIp, String dstIpStr, long elanTag) throws UnknownHostException {
    String routerId = vpnUtil.getAssociatedExternalRouter(srcIpStr);
    if (null == routerId) {
        LOG.debug("This ip is not associated with any external router: {}", srcIpStr);
        return;
    }
    handlePacketToExternalNetwork(new Uuid(vpnIdVpnInstanceName), routerId, dstIp, dstIpStr, elanTag);
}

Example 48 with RouterId

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId in project netvirt by opendaylight.

the class SubnetRoutePacketInHandler method handlePacketToExternalNetwork.

private void handlePacketToExternalNetwork(Uuid vpnInstanceNameUuid, String routerId, byte[] dstIp, String dstIpStr, long elanTag) throws UnknownHostException {
    Routers externalRouter = vpnUtil.getExternalRouter(routerId);
    if (externalRouter == null) {
        Counter counter = packetInCounter.label(CounterUtility.subnet_route_packet_failed.toString()).label("." + dstIpStr);
        counter.increment();
        LOG.debug("{} handlePacketToExternalNetwork: Can't find external router with id {}", LOGGING_PREFIX, routerId);
        return;
    }
    Map<ExternalIpsKey, ExternalIps> externalIpsMap = externalRouter.getExternalIps();
    if (externalIpsMap == null || externalIpsMap.isEmpty()) {
        Counter counter = packetInCounter.label(CounterUtility.subnet_route_packet_failed.toString()).label("." + dstIpStr);
        counter.increment();
        LOG.debug("{} handlePacketToExternalNetwork: Router {} doesn't have any external ips.", LOGGING_PREFIX, externalRouter.getRouterName());
        return;
    }
    java.util.Optional<ExternalIps> externalIp = externalRouter.getExternalIps().values().stream().filter(eip -> vpnInstanceNameUuid.equals(eip.getSubnetId())).findFirst();
    if (!externalIp.isPresent()) {
        Counter counter = packetInCounter.label(CounterUtility.subnet_route_packet_failed.toString()).label(externalIp.get().getIpAddress() + "." + dstIpStr);
        counter.increment();
        LOG.debug("{} handlePacketToExternalNetwork: Router {} doesn't have an external ip for subnet id {}.", LOGGING_PREFIX, externalRouter.getRouterName(), vpnInstanceNameUuid);
        return;
    }
    Uint64 dpnId = centralizedSwitchProvider.getPrimarySwitchForRouter(externalRouter.getRouterName());
    if (Uint64.ZERO.equals(dpnId)) {
        Counter counter = packetInCounter.label(CounterUtility.subnet_route_packet_failed.toString()).label(externalIp.get().getIpAddress() + "." + dstIpStr);
        counter.increment();
        LOG.debug("{} handlePacketToExternalNetwork: Could not find primary switch for router {}.", LOGGING_PREFIX, externalRouter.getRouterName());
        return;
    }
    transmitArpOrNsPacket(dpnId, externalIp.get().getIpAddress(), externalRouter.getExtGwMacAddress(), dstIp, dstIpStr, elanTag);
    Counter counter = packetInCounter.label(CounterUtility.subnet_route_packet_processed.toString()).label(externalIp.get().getIpAddress() + "." + dstIpStr);
    counter.increment();
}

Example 49 with RouterId

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId in project netvirt by opendaylight.

the class ExternalRoutersListener method removeNaptFlowsFromActiveSwitch.

public void removeNaptFlowsFromActiveSwitch(Uint32 routerId, String routerName, Uint64 dpnId, Uuid networkId, String vpnName, @NonNull Collection<String> externalIps, Collection<Uuid> externalSubnetList, TypedReadWriteTransaction<Configuration> confTx, ProviderTypes extNwProvType) throws InterruptedException, ExecutionException {
    LOG.debug("removeNaptFlowsFromActiveSwitch : Remove NAPT flows from Active switch");
    Uint64 cookieSnatFlow = NatUtil.getCookieNaptFlow(routerId);
    // Remove the PSNAT entry which forwards the packet to Outbound NAPT Table (For the
    // traffic which comes from the  VMs of the NAPT switches)
    String preSnatFlowRef = getFlowRefSnat(dpnId, NwConstants.PSNAT_TABLE, routerName);
    FlowEntity preSnatFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.PSNAT_TABLE, preSnatFlowRef);
    LOG.info("removeNaptFlowsFromActiveSwitch : Remove the flow in the {} for the active switch with the DPN ID {} " + "and router ID {}", NwConstants.PSNAT_TABLE, dpnId, routerId);
    mdsalManager.removeFlow(confTx, preSnatFlowEntity);
    // Remove the Terminating Service table entry which forwards the packet to Outbound NAPT Table (For the
    // traffic which comes from the VMs of the non NAPT switches)
    Uint64 tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, natOverVxlanUtil, elanManager, idManager, routerId, routerName);
    String tsFlowRef = getFlowRefTs(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, Uint32.valueOf(tunnelId.longValue()));
    FlowEntity tsNatFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, tsFlowRef);
    LOG.info("removeNaptFlowsFromActiveSwitch : Remove the flow in the {} for the active switch with the DPN ID {} " + "and router ID {}", NwConstants.INTERNAL_TUNNEL_TABLE, dpnId, routerId);
    mdsalManager.removeFlow(confTx, tsNatFlowEntity);
    // Remove the flow table 25->44 from NAPT Switch
    if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanManager, extNwProvType)) {
        NatUtil.removePreDnatToSnatTableEntry(confTx, mdsalManager, dpnId);
    }
    // Remove the Outbound flow entry which forwards the packet to FIB Table
    LOG.info("removeNaptFlowsFromActiveSwitch : Remove the flow in the {} for the active switch with the DPN ID {}" + " and router ID {}", NwConstants.OUTBOUND_NAPT_TABLE, dpnId, routerId);
    String outboundTcpNatFlowRef = getFlowRefOutbound(dpnId, NwConstants.OUTBOUND_NAPT_TABLE, routerId, NwConstants.IP_PROT_TCP);
    FlowEntity outboundTcpNatFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.OUTBOUND_NAPT_TABLE, outboundTcpNatFlowRef);
    mdsalManager.removeFlow(confTx, outboundTcpNatFlowEntity);
    String outboundUdpNatFlowRef = getFlowRefOutbound(dpnId, NwConstants.OUTBOUND_NAPT_TABLE, routerId, NwConstants.IP_PROT_UDP);
    FlowEntity outboundUdpNatFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.OUTBOUND_NAPT_TABLE, outboundUdpNatFlowRef);
    mdsalManager.removeFlow(confTx, outboundUdpNatFlowEntity);
    String icmpDropFlowRef = getFlowRefOutbound(dpnId, NwConstants.OUTBOUND_NAPT_TABLE, routerId, NwConstants.IP_PROT_ICMP);
    FlowEntity icmpDropFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.OUTBOUND_NAPT_TABLE, icmpDropFlowRef);
    mdsalManager.removeFlow(confTx, icmpDropFlowEntity);
    boolean lastRouterOnExternalNetwork = !NatUtil.checkForRoutersWithSameExtNetAndNaptSwitch(dataBroker, networkId, routerName, dpnId);
    if (lastRouterOnExternalNetwork) {
        removeNaptFibExternalOutputFlows(routerId, dpnId, networkId, externalIps, confTx);
    }
    // External Subnet Vpn Id.
    for (Uuid externalSubnetId : externalSubnetList) {
        Uint32 subnetVpnId = NatUtil.getVpnId(dataBroker, externalSubnetId.getValue());
        if (subnetVpnId != NatConstants.INVALID_ID && !NatUtil.checkForRoutersWithSameExtSubnetAndNaptSwitch(dataBroker, externalSubnetId, routerName, dpnId)) {
            String natPfibSubnetFlowRef = getFlowRefTs(dpnId, NwConstants.NAPT_PFIB_TABLE, subnetVpnId);
            FlowEntity natPfibFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.NAPT_PFIB_TABLE, natPfibSubnetFlowRef);
            mdsalManager.removeFlow(confTx, natPfibFlowEntity);
            LOG.debug("removeNaptFlowsFromActiveSwitch : Removed the flow in table {} with external subnet " + "Vpn Id {} as metadata on Napt Switch {}", NwConstants.NAPT_PFIB_TABLE, subnetVpnId, dpnId);
        }
    }
    // Remove the NAPT PFIB TABLE which forwards the incoming packet to FIB Table matching on the router ID.
    String natPfibFlowRef = getFlowRefTs(dpnId, NwConstants.NAPT_PFIB_TABLE, routerId);
    FlowEntity natPfibFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.NAPT_PFIB_TABLE, natPfibFlowRef);
    LOG.info("removeNaptFlowsFromActiveSwitch : Remove the flow in the {} for the active switch with the DPN ID {} " + "and router ID {}", NwConstants.NAPT_PFIB_TABLE, dpnId, routerId);
    mdsalManager.removeFlow(confTx, natPfibFlowEntity);
    if (lastRouterOnExternalNetwork) {
        // Long vpnId = NatUtil.getVpnId(dataBroker, routerId);
        // - This does not work since ext-routers is deleted already - no network info
        // Get the VPN ID from the ExternalNetworks model
        Uint32 vpnId = NatConstants.INVALID_ID;
        if (vpnName == null || vpnName.isEmpty()) {
            // ie called from router delete cases
            Uuid vpnUuid = NatUtil.getVpnIdfromNetworkId(dataBroker, networkId);
            LOG.debug("removeNaptFlowsFromActiveSwitch : vpnUuid is {}", vpnUuid);
            if (vpnUuid != null) {
                vpnId = NatUtil.getVpnId(dataBroker, vpnUuid.getValue());
                LOG.debug("removeNaptFlowsFromActiveSwitch : vpnId {} for external  network {} router delete " + "or disableSNAT scenario", vpnId, networkId);
            }
        } else {
            // ie called from disassociate vpn case
            LOG.debug("removeNaptFlowsFromActiveSwitch : This is disassociate nw with vpn case with vpnName {}", vpnName);
            vpnId = NatUtil.getVpnId(dataBroker, vpnName);
            LOG.debug("removeNaptFlowsFromActiveSwitch : vpnId for disassociate nw with vpn scenario {}", vpnId);
        }
        if (vpnId != NatConstants.INVALID_ID) {
            // Remove the NAPT PFIB TABLE which forwards the outgoing packet to FIB Table matching on the VPN ID.
            String natPfibVpnFlowRef = getFlowRefTs(dpnId, NwConstants.NAPT_PFIB_TABLE, vpnId);
            FlowEntity natPfibVpnFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.NAPT_PFIB_TABLE, natPfibVpnFlowRef);
            LOG.info("removeNaptFlowsFromActiveSwitch : Remove the flow in {} for the active switch with the " + "DPN ID {} and VPN ID {}", NwConstants.NAPT_PFIB_TABLE, dpnId, vpnId);
            mdsalManager.removeFlow(confTx, natPfibVpnFlowEntity);
        }
    }
    // For the router ID get the internal IP , internal port and the corresponding external IP and external Port.
    IpPortMapping ipPortMapping = NatUtil.getIportMapping(dataBroker, routerId);
    if (ipPortMapping == null) {
        LOG.error("removeNaptFlowsFromActiveSwitch : Unable to retrieve the IpPortMapping");
        return;
    }
    for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType().values()) {
        String protocol = intextIpProtocolType.getProtocol().name();
        for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap().values()) {
            String ipPortInternal = ipPortMap.getIpPortInternal();
            String[] ipPortParts = ipPortInternal.split(":");
            if (ipPortParts.length != 2) {
                LOG.error("removeNaptFlowsFromActiveSwitch : Unable to retrieve the Internal IP and port");
                return;
            }
            String internalIp = ipPortParts[0];
            String internalPort = ipPortParts[1];
            // Build the flow for the outbound NAPT table
            naptPacketInHandler.removeIncomingPacketMap(routerId + NatConstants.COLON_SEPARATOR + internalIp + NatConstants.COLON_SEPARATOR + internalPort);
            String switchFlowRef = NatUtil.getNaptFlowRef(dpnId, NwConstants.OUTBOUND_NAPT_TABLE, String.valueOf(routerId), internalIp, Integer.parseInt(internalPort), protocol);
            FlowEntity outboundNaptFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.OUTBOUND_NAPT_TABLE, cookieSnatFlow, switchFlowRef);
            LOG.info("removeNaptFlowsFromActiveSwitch : Remove the flow in the {} for the active switch " + "with the DPN ID {} and router ID {}", NwConstants.OUTBOUND_NAPT_TABLE, dpnId, routerId);
            mdsalManager.removeFlow(confTx, outboundNaptFlowEntity);
            // Build the flow for the inbound NAPT table
            switchFlowRef = NatUtil.getNaptFlowRef(dpnId, NwConstants.INBOUND_NAPT_TABLE, String.valueOf(routerId), internalIp, Integer.parseInt(internalPort), protocol);
            FlowEntity inboundNaptFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.INBOUND_NAPT_TABLE, cookieSnatFlow, switchFlowRef);
            LOG.info("removeNaptFlowsFromActiveSwitch : Remove the flow in the {} for the active active switch " + "with the DPN ID {} and router ID {}", NwConstants.INBOUND_NAPT_TABLE, dpnId, routerId);
            mdsalManager.removeFlow(confTx, inboundNaptFlowEntity);
        }
    }
}

Example 50 with RouterId

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.RouterId 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);
}