natservice/natservice-impl/src/main/java/org/opendaylight/vpnservice/natservice/internal/NatUtil.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.vpnservice.natservice.internal;
  10
  11 import java.math.BigInteger;
  12 import java.util.ArrayList;
  13 import java.util.List;
  14
  15 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  16 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  17 import org.opendaylight.vpnservice.mdsalutil.NwConstants;
  18 import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
  19 import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
  20 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
  21 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  22 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstanceOpData;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstanceToVpnId;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInput;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInputBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutput;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.*;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.ext.routers.Routers;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.ext.routers.RoutersKey;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.external.ips.counter.ExternalCounters;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.external.ips.counter.ExternalCountersKey;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.external.ips.counter.external.counters.ExternalIpCounter;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.ip.mapping.IpMap;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.port.map.ip.port.mapping.IntextIpProtocolType;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.port.map.ip.port.mapping.IntextIpProtocolTypeKey;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.IpPortMap;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.IpPortMapKey;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.ip.port.map.IpPortExternal;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.router.id.name.RouterIds;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.router.id.name.RouterIdsKey;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.RouterToVpnMapping;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.router.to.vpn.mapping.Routermapping;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.router.to.vpn.mapping.RoutermappingKey;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.snatint.ip.port.map.IntipPortMap;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.snatint.ip.port.map.IntipPortMapKey;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.snatint.ip.port.map.intip.port.map.IpPort;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.snatint.ip.port.map.intip.port.map.IpPortKey;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.snatint.ip.port.map.intip.port.map.ip.port.IntIpProtoType;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.snatint.ip.port.map.intip.port.map.ip.port.IntIpProtoTypeKey;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.FloatingIpInfo;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.NeutronRouterDpns;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.Subnetmaps;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.VpnMaps;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.neutron.router.dpns.RouterDpnList;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.neutron.router.dpns.RouterDpnListKey;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.neutron.router.dpns.router.dpn.list.DpnVpninterfacesList;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.subnetmaps.Subnetmap;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.vpnmaps.VpnMap;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.vpnmaps.VpnMapKey;
  64 import org.opendaylight.yangtools.yang.binding.DataObject;
  65 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  66 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  67 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  68
  69 import com.google.common.base.Optional;
  70
  71 import org.opendaylight.bgpmanager.api.IBgpManager;
  72 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.external.networks.Networks;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.external.networks.NetworksKey;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.floating.ip.info.RouterPorts;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.floating.ip.info.RouterPortsKey;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.floating.ip.info.router.ports.Ports;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.floating.ip.info.router.ports.PortsKey;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.ExternalNetworks;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.napt.switches.RouterToNaptSwitch;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.napt.switches.RouterToNaptSwitchKey;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.DpnEndpoints;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.DPNTEPsInfo;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.DPNTEPsInfoKey;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.floating.ip.info.router.ports.ports.IpMapping;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.floating.ip.info.router.ports.ports.IpMappingKey;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.IntextIpPortMap;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.port.map.IpPortMapping;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.port.map.IpPortMappingKey;
  94 import org.opendaylight.yangtools.yang.common.RpcResult;
  95 import org.slf4j.Logger;
  96 import org.slf4j.LoggerFactory;
  97
  98 import java.net.InetAddress;
  99 import java.net.UnknownHostException;
 100 import java.util.concurrent.ExecutionException;
 101 import java.util.concurrent.Future;
 102
 103
 104
 105 public class NatUtil {
 106
 107     private static String OF_URI_SEPARATOR = ":";
 108     private static final Logger LOG = LoggerFactory.getLogger(NatUtil.class);
 109
 110     /*
 111         getCookieSnatFlow() computes and returns a unique cookie value for the NAT flows using the router ID as the reference value.
 112      */
 113     public static BigInteger getCookieSnatFlow(long routerId) {
 114         return NatConstants.COOKIE_NAPT_BASE.add(new BigInteger("0110000", 16)).add(
 115                 BigInteger.valueOf(routerId));
 116     }
 117
 118     /*
 119         getCookieNaptFlow() computes and returns a unique cookie value for the NAPT flows using the router ID as the reference value.
 120     */
 121     public static BigInteger getCookieNaptFlow(long routerId) {
 122         return NatConstants.COOKIE_NAPT_BASE.add(new BigInteger("0111000", 16)).add(
 123                 BigInteger.valueOf(routerId));
 124     }
 125
 126     /*
 127         getVpnId() returns the VPN ID from the VPN name
 128      */
 129     public static long getVpnId(DataBroker broker, String vpnName) {
 130         if(vpnName == null) {
 131             return NatConstants.INVALID_ID;
 132         }
 133
 134         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 135                 = getVpnInstanceToVpnIdIdentifier(vpnName);
 136         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 137                 = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 138
 139         long vpnId = NatConstants.INVALID_ID;
 140         if(vpnInstance.isPresent()) {
 141             vpnId = vpnInstance.get().getVpnId();
 142         }
 143         return vpnId;
 144     }
 145
 146     public static Long getVpnId(DataBroker broker, long routerId){
 147         //Get the external network ID from the ExternalRouter model
 148         Uuid networkId = NatUtil.getNetworkIdFromRouterId(broker, routerId);
 149         if(networkId == null ){
 150             LOG.error("NAT Service : networkId is null");
 151             return null;
 152         }
 153
 154         //Get the VPN ID from the ExternalNetworks model
 155         Uuid vpnUuid = NatUtil.getVpnIdfromNetworkId(broker, networkId);
 156         if(vpnUuid == null ){
 157             LOG.error("NAT Service : vpnUuid is null");
 158             return null;
 159         }
 160         Long vpnId = NatUtil.getVpnId(broker, vpnUuid.getValue());
 161         return vpnId;
 162     }
 163
 164     static InstanceIdentifier<RouterPorts> getRouterPortsId(String routerId) {
 165         return InstanceIdentifier.builder(FloatingIpInfo.class).child(RouterPorts.class, new RouterPortsKey(routerId)).build();
 166     }
 167
 168     static InstanceIdentifier<Routermapping> getRouterVpnMappingId(String routerId) {
 169         return InstanceIdentifier.builder(RouterToVpnMapping.class).child(Routermapping.class, new RoutermappingKey(routerId)).build();
 170     }
 171
 172     static InstanceIdentifier<Ports> getPortsIdentifier(String routerId, String portName) {
 173         return InstanceIdentifier.builder(FloatingIpInfo.class).child(RouterPorts.class, new RouterPortsKey(routerId))
 174                                                                .child(Ports.class, new PortsKey(portName)).build();
 175     }
 176
 177     static InstanceIdentifier<IpMapping> getIpMappingIdentifier(String routerId, String portName, String internalIp) {
 178         return InstanceIdentifier.builder(FloatingIpInfo.class).child(RouterPorts.class, new RouterPortsKey(routerId))
 179                                                                .child(Ports.class, new PortsKey(portName))
 180                                                                .child(IpMapping.class, new IpMappingKey(internalIp)).build();
 181     }
 182
 183     /*
 184         getVpnInstanceToVpnIdIdentifier() returns the VPN instance from the below model using the VPN name as the key.
 185             list vpn-instance {
 186                 key "vpn-instance-name"
 187                 leaf vpn-instance-name {
 188                     type string;
 189                 }
 190                 leaf vpn-id {
 191                     type uint32;
 192                 }
 193                 leaf vrf-id {
 194                     type string;
 195                 }
 196             }
 197     */
 198
 199     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance>
 200     getVpnInstanceToVpnIdIdentifier(String vpnName) {
 201         return InstanceIdentifier.builder(VpnInstanceToVpnId.class)
 202                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance.class,
 203                         new org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceKey(vpnName)).build();
 204     }
 205
 206      /*
 207         getFlowRef() returns a string identfier for the SNAT flows using the router ID as the reference.
 208      */
 209     public static String getFlowRef(BigInteger dpnId, short tableId, long routerID, String ip) {
 210         return new StringBuffer().append(NatConstants.NAPT_FLOWID_PREFIX).append(dpnId).append(NatConstants.FLOWID_SEPARATOR).
 211                 append(tableId).append(NatConstants.FLOWID_SEPARATOR).append(routerID)
 212                 .append(NatConstants.FLOWID_SEPARATOR).append(ip).toString();
 213     }
 214
 215     public static String getNaptFlowRef(BigInteger dpnId, short tableId, String routerID, String ip, int port) {
 216         return new StringBuffer().append(NatConstants.NAPT_FLOWID_PREFIX).append(dpnId).append(NatConstants.FLOWID_SEPARATOR).
 217                 append(tableId).append(NatConstants.FLOWID_SEPARATOR).append(routerID).append(NatConstants.FLOWID_SEPARATOR).append(ip).
 218                 append(NatConstants.FLOWID_SEPARATOR).append(port).toString();
 219     }
 220
 221     /*
 222         getNetworkIdFromRouterId() returns the network-id from the below model using the router-id as the key
 223                container ext-routers {
 224                    list routers {
 225                        key router-name;
 226                        leaf router-name { type string; }
 227                        leaf network-id { type yang:uuid; }
 228                        leaf enable-snat { type boolean; }
 229                        leaf-list external-ips {
 230                             type string; //format - ipaddress\prefixlength
 231                        }
 232                        leaf-list subnet-ids { type yang:uuid; }
 233                    }
 234                }
 235
 236     */
 237     static Uuid getNetworkIdFromRouterId(DataBroker broker, long routerId) {
 238         String routerName = getRouterName(broker, routerId);
 239         InstanceIdentifier id = buildRouterIdentifier(routerName);
 240         Optional<Routers> routerData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 241         if (routerData.isPresent()) {
 242             return routerData.get().getNetworkId();
 243         }
 244         return null;
 245     }
 246
 247     static InstanceIdentifier<Routers> buildRouterIdentifier(String routerId) {
 248         InstanceIdentifier<Routers> routerInstanceIndentifier = InstanceIdentifier.builder(ExtRouters.class).child
 249                 (Routers.class, new RoutersKey(routerId)).build();
 250         return routerInstanceIndentifier;
 251     }
 252
 253     /*
 254      * getEnableSnatFromRouterId() returns IsSnatEnabled true is routerID is present in external n/w otherwise returns false
 255      */
 256     static boolean isSnatEnabledForRouterId(DataBroker broker, String routerId){
 257         InstanceIdentifier id = buildRouterIdentifier(routerId);
 258         Optional<Routers> routerData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 259         if (routerData.isPresent()) {
 260             return routerData.get().isEnableSnat();
 261         }
 262         return false;
 263     }
 264     /*
 265         getVpnIdfromNetworkId() returns the vpnid from the below model using the network ID as the key.
 266             container external-networks {
 267                 list networks  {
 268                     key id;
 269                     leaf id {
 270                         type yang:uuid;
 271                     }
 272                     leaf vpnid { type yang:uuid; }
 273                     leaf-list router-ids { type yang:uuid; }
 274                     leaf-list subnet-ids{ type yang:uuid; }
 275                 }
 276             }
 277     */
 278     public static Uuid getVpnIdfromNetworkId(DataBroker broker, Uuid networkId) {
 279         InstanceIdentifier id = buildNetworkIdentifier(networkId);
 280         Optional<Networks> networkData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 281         if (networkData.isPresent()) {
 282             return networkData.get().getVpnid();
 283         }
 284         return null;
 285     }
 286
 287     static String getAssociatedExternalNetwork(DataBroker dataBroker, String routerId) {
 288         InstanceIdentifier<Routers> id = NatUtil.buildRouterIdentifier(routerId);
 289         Optional<Routers> routerData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
 290         if (routerData.isPresent()) {
 291             Uuid networkId = routerData.get().getNetworkId();
 292             if(networkId != null) {
 293                 return networkId.getValue();
 294             }
 295         }
 296         return null;
 297     }
 298
 299     private static InstanceIdentifier<Networks> buildNetworkIdentifier(Uuid networkId) {
 300         InstanceIdentifier<Networks> network = InstanceIdentifier.builder(ExternalNetworks.class).child
 301                 (Networks.class, new NetworksKey(networkId)).build();
 302         return network;
 303     }
 304
 305
 306
 307
 308     /*
 309         getNaptSwitchesDpnIdsfromRouterId() returns the primary-switch-id and the secondary-switch-id in a array using the router-id; as the key.
 310             container napt-switches {
 311                 list router-to-napt-switch {
 312                     key router-id;
 313                     leaf router-id { type uint32; }
 314                     leaf primary-switch-id { type uint64; }
 315                     leaf secondary-switch-id { type uint64; }
 316                 }
 317             }
 318     */
 319     public static BigInteger getPrimaryNaptfromRouterId(DataBroker broker, Long routerId) {
 320         // convert routerId to Name
 321         String routerName = getRouterName(broker, routerId);
 322         InstanceIdentifier id = buildNaptSwitchIdentifier(routerName);
 323         Optional<RouterToNaptSwitch> routerToNaptSwitchData = read(broker, LogicalDatastoreType.OPERATIONAL, id);
 324         if (routerToNaptSwitchData.isPresent()) {
 325             RouterToNaptSwitch routerToNaptSwitchInstance = routerToNaptSwitchData.get();
 326             return routerToNaptSwitchInstance.getPrimarySwitchId();
 327         }
 328         return null;
 329     }
 330
 331     private static InstanceIdentifier<RouterToNaptSwitch> buildNaptSwitchIdentifier(String routerId) {
 332         InstanceIdentifier<RouterToNaptSwitch> rtrNaptSw = InstanceIdentifier.builder(NaptSwitches.class).child
 333                 (RouterToNaptSwitch.class, new RouterToNaptSwitchKey(routerId)).build();
 334         return rtrNaptSw;
 335     }
 336
 337     public static String getRouterName(DataBroker broker, Long routerId) {
 338         InstanceIdentifier id = buildRouterIdentifier(routerId);
 339         Optional<RouterIds> routerIdsData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 340         if (routerIdsData.isPresent()) {
 341             RouterIds routerIdsInstance = routerIdsData.get();
 342             return routerIdsInstance.getRouterName();
 343         }
 344         return null;
 345     }
 346
 347     private static InstanceIdentifier<RouterIds> buildRouterIdentifier(Long routerId) {
 348         InstanceIdentifier<RouterIds> routerIds = InstanceIdentifier.builder(RouterIdName.class).child
 349                 (RouterIds.class, new RouterIdsKey(routerId)).build();
 350         return routerIds;
 351     }
 352
 353     public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
 354                                                    InstanceIdentifier<T> path) {
 355
 356         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
 357
 358         Optional<T> result = Optional.absent();
 359         try {
 360             result = tx.read(datastoreType, path).get();
 361         } catch (Exception e) {
 362             throw new RuntimeException(e);
 363         }
 364
 365         return result;
 366     }
 367
 368     static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String vrfId) {
 369         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 370                 .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(vrfId)).build();
 371     }
 372
 373     public static long readVpnId(DataBroker broker, String vpnName) {
 374
 375         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 376                 = getVpnInstanceToVpnIdIdentifier(vpnName);
 377         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 378                 = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 379
 380         long vpnId = NatConstants.INVALID_ID;
 381         if(vpnInstance.isPresent()) {
 382             vpnId = vpnInstance.get().getVpnId();
 383         }
 384         return vpnId;
 385     }
 386
 387     public static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, BigInteger cookie) {
 388         FlowEntity flowEntity = new FlowEntity(dpnId);
 389         flowEntity.setTableId(tableId);
 390         flowEntity.setCookie(cookie);
 391         return flowEntity;
 392     }
 393
 394     public static long getIpAddress(byte[] rawIpAddress) {
 395         return (((rawIpAddress[0] & 0xFF) << (3 * 8)) + ((rawIpAddress[1] & 0xFF) << (2 * 8))
 396                 + ((rawIpAddress[2] & 0xFF) << (1 * 8)) + (rawIpAddress[3] & 0xFF)) & 0xffffffffL;
 397     }
 398
 399     public static String getFlowRef(BigInteger dpnId, short tableId, InetAddress destPrefix) {
 400         return new StringBuilder(64).append(NatConstants.FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 401                 .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
 402                 .append(destPrefix.getHostAddress()).toString();
 403     }
 404
 405     public static String getEndpointIpAddressForDPN(DataBroker broker, BigInteger dpnId) {
 406         String nextHopIp = null;
 407         InstanceIdentifier<DPNTEPsInfo> tunnelInfoId =
 408             InstanceIdentifier.builder(DpnEndpoints.class).child(DPNTEPsInfo.class, new DPNTEPsInfoKey(dpnId)).build();
 409         Optional<DPNTEPsInfo> tunnelInfo = read(broker, LogicalDatastoreType.CONFIGURATION, tunnelInfoId);
 410         if (tunnelInfo.isPresent()) {
 411           List<TunnelEndPoints> nexthopIpList = tunnelInfo.get().getTunnelEndPoints();
 412           if (nexthopIpList != null && !nexthopIpList.isEmpty()) {
 413             nextHopIp = nexthopIpList.get(0).getIpAddress().getIpv4Address().getValue();
 414           }
 415         }
 416         return nextHopIp;
 417       }
 418
 419     /*
 420         getVpnRd returns the rd (route distinguisher) which is the VRF ID from the below model using the vpnName
 421             list vpn-instance {
 422                 key "vpn-instance-name"
 423                 leaf vpn-instance-name {
 424                     type string;
 425                 }
 426                 leaf vpn-id {
 427                     type uint32;
 428                 }
 429                 leaf vrf-id {
 430                     type string;
 431                 }
 432             }
 433     */
 434     public static String getVpnRd(DataBroker broker, String vpnName) {
 435
 436         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 437                 = getVpnInstanceToVpnIdIdentifier(vpnName);
 438         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 439                 = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 440
 441         String rd = null;
 442         if(vpnInstance.isPresent()) {
 443             rd = vpnInstance.get().getVrfId();
 444         }
 445         return rd;
 446     }
 447
 448     /*  getExternalIPPortMap() returns the internal IP and the port for the querried router ID, external IP and the port.
 449         container intext-ip-port-map {
 450         config true;
 451         list ip-port-mapping {
 452             key router-id;
 453             leaf router-id { type uint32; }
 454             list intext-ip-protocol-type {
 455                 key protocol;
 456                 leaf protocol { type protocol-types; }
 457                 list ip-port-map {
 458                     key ip-port-internal;
 459                     description "internal to external ip-port mapping";
 460                     leaf ip-port-internal { type string; }
 461                     container ip-port-external {
 462                        uses ip-port-entity;
 463                     }
 464                 }
 465             }
 466          }
 467        }
 468     */
 469     public static IpPortExternal getExternalIpPortMap(DataBroker broker, Long routerId, String internalIpAddress, String internalPort, NAPTEntryEvent.Protocol protocol) {
 470         ProtocolTypes protocolType = NatUtil.getProtocolType(protocol);
 471         InstanceIdentifier ipPortMapId = buildIpToPortMapIdentifier(routerId, internalIpAddress, internalPort, protocolType);
 472         Optional<IpPortMap> ipPortMapData = read(broker, LogicalDatastoreType.CONFIGURATION, ipPortMapId);
 473         if (ipPortMapData.isPresent()) {
 474             IpPortMap ipPortMapInstance = ipPortMapData.get();
 475             return ipPortMapInstance.getIpPortExternal();
 476         }
 477         return null;
 478     }
 479
 480     private static InstanceIdentifier<IpPortMap> buildIpToPortMapIdentifier(Long routerId, String internalIpAddress, String internalPort , ProtocolTypes protocolType) {
 481         InstanceIdentifier<IpPortMap> ipPortMapId = InstanceIdentifier.builder(IntextIpPortMap.class).child
 482                 (IpPortMapping.class, new IpPortMappingKey(routerId)).child(IntextIpProtocolType.class, new IntextIpProtocolTypeKey(protocolType))
 483                 .child(IpPortMap.class, new IpPortMapKey(internalIpAddress + ":" + internalPort)).build();
 484         return ipPortMapId;
 485     }
 486
 487     public static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, String flowId, int priority, String flowName,
 488                                              BigInteger cookie, List<MatchInfo> listMatchInfo) {
 489
 490         FlowEntity flowEntity = new FlowEntity(dpnId);
 491         flowEntity.setTableId(tableId);
 492         flowEntity.setFlowId(flowId);
 493         flowEntity.setPriority(priority);
 494         flowEntity.setFlowName(flowName);
 495         flowEntity.setCookie(cookie);
 496         flowEntity.setMatchInfoList(listMatchInfo);
 497         return flowEntity;
 498     }
 499
 500     static boolean isVpnInterfaceConfigured(DataBroker broker, String interfaceName)
 501     {
 502         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 503         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
 504
 505         if (configuredVpnInterface.isPresent()) {
 506             return true;
 507         }
 508         return false;
 509     }
 510
 511     static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
 512         return InstanceIdentifier.builder(VpnInterfaces.class)
 513                 .child(VpnInterface.class, new VpnInterfaceKey(vpnInterfaceName)).build();
 514     }
 515
 516     static VpnInterface getConfiguredVpnInterface(DataBroker broker, String interfaceName) {
 517         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 518         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
 519
 520         if (configuredVpnInterface.isPresent()) {
 521             return configuredVpnInterface.get();
 522         }
 523         return null;
 524     }
 525
 526     public static String getDpnFromNodeConnectorId(NodeConnectorId portId) {
 527         /*
 528          * NodeConnectorId is of form 'openflow:dpnid:portnum'
 529          */
 530         String[] split = portId.getValue().split(OF_URI_SEPARATOR);
 531         return split[1];
 532     }
 533
 534     public static BigInteger getDpIdFromInterface(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState) {
 535         String lowerLayerIf = ifState.getLowerLayerIf().get(0);
 536         NodeConnectorId nodeConnectorId = new NodeConnectorId(lowerLayerIf);
 537         return new BigInteger(getDpnFromNodeConnectorId(nodeConnectorId));
 538     }
 539
 540
 541     /*
 542     container vpnMaps {
 543         list vpnMap {
 544             key vpn-id;
 545             leaf vpn-id {
 546                 type    yang:uuid;
 547                 description "vpn-id";
 548             }
 549             leaf name {
 550                 type  string;
 551                 description "vpn name";
 552             }
 553             leaf tenant-id {
 554                 type    yang:uuid;
 555                 description "The UUID of the tenant that will own the subnet.";
 556             }
 557
 558             leaf router-id {
 559               type    yang:uuid;
 560               description "UUID of router ";
 561             }
 562             leaf-list network_ids {
 563               type    yang:uuid;
 564               description "UUID representing the network ";
 565             }
 566         }
 567     }
 568     Method returns router Id associated to a VPN
 569      */
 570
 571     public static String getRouterIdfromVpnId(DataBroker broker,String vpnName){
 572         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
 573                 .child(VpnMap.class, new VpnMapKey(new Uuid(vpnName))).build();
 574         Optional<VpnMap> optionalVpnMap = read(broker, LogicalDatastoreType.CONFIGURATION,
 575                 vpnMapIdentifier);
 576         if (optionalVpnMap.isPresent()) {
 577             return optionalVpnMap.get().getRouterId().getValue();
 578         }
 579         return null;
 580     }
 581
 582     static Uuid getVpnForRouter(DataBroker broker, String routerId) {
 583         InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
 584         Optional<VpnMaps> optionalVpnMaps = read(broker, LogicalDatastoreType.CONFIGURATION,
 585                 vpnMapsIdentifier);
 586         if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
 587             List<VpnMap> allMaps = optionalVpnMaps.get().getVpnMap();
 588             if (routerId != null) {
 589                 for (VpnMap vpnMap : allMaps) {
 590                     if (vpnMap.getRouterId() != null &&
 591                         routerId.equals(vpnMap.getRouterId().getValue()) &&
 592                         !routerId.equals(vpnMap.getVpnId().getValue())) {
 593                             return vpnMap.getVpnId();
 594                     }
 595                 }
 596             }
 597         }
 598         return null;
 599     }
 600
 601     static long getAssociatedVpn(DataBroker broker, String routerName) {
 602         InstanceIdentifier<Routermapping> routerMappingId = NatUtil.getRouterVpnMappingId(routerName);
 603         Optional<Routermapping> optRouterMapping = NatUtil.read(broker, LogicalDatastoreType.OPERATIONAL, routerMappingId);
 604         if(optRouterMapping.isPresent()) {
 605             Routermapping routerMapping = optRouterMapping.get();
 606             return routerMapping.getVpnId();
 607         }
 608         return NatConstants.INVALID_ID;
 609     }
 610
 611
 612     public static List<VpnToDpnList> getVpnToDpnList(DataBroker dataBroker, String vrfId )
 613     {
 614         List<VpnToDpnList> vpnDpnList = null;
 615
 616         InstanceIdentifier<VpnInstanceOpDataEntry> id = InstanceIdentifier
 617                 .builder(VpnInstanceOpData.class)
 618                 .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(vrfId))
 619                 .build();
 620
 621         Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
 622
 623         if(vpnInstanceOpData.isPresent())
 624         {
 625             VpnInstanceOpDataEntry vpnInstanceOpDataEntry = vpnInstanceOpData.get();
 626             vpnDpnList = vpnInstanceOpDataEntry.getVpnToDpnList();
 627         }
 628
 629         return vpnDpnList;
 630     }
 631
 632     public static String getAssociatedVPN(DataBroker dataBroker, Uuid networkId, Logger log) {
 633         Uuid vpnUuid = NatUtil.getVpnIdfromNetworkId(dataBroker, networkId);
 634         if(vpnUuid == null ){
 635             log.error("No VPN instance associated with ext network {}", networkId);
 636             return null;
 637         }
 638         return vpnUuid.getValue();
 639     }
 640
 641     public static void addPrefixToBGP(IBgpManager bgpManager, String rd, String prefix, String nextHopIp, long label, Logger log) {
 642         try {
 643             bgpManager.addPrefix(rd, prefix, nextHopIp, (int)label);
 644         } catch(Exception e) {
 645             log.error("Add prefix failed", e);
 646         }
 647     }
 648
 649     static InstanceIdentifier<Ports> buildPortToIpMapIdentifier(String routerId, String portName) {
 650         InstanceIdentifier<Ports> ipPortMapId = InstanceIdentifier.builder(FloatingIpInfo.class).child
 651                 (RouterPorts.class, new RouterPortsKey(routerId)).child(Ports.class, new PortsKey(portName)).build();
 652         return ipPortMapId;
 653     }
 654
 655     static InstanceIdentifier<RouterPorts> buildRouterPortsIdentifier(String routerId) {
 656         InstanceIdentifier<RouterPorts> routerInstanceIndentifier = InstanceIdentifier.builder(FloatingIpInfo.class).child
 657                 (RouterPorts.class, new RouterPortsKey(routerId)).build();
 658         return routerInstanceIndentifier;
 659     }
 660
 661     /* container snatint-ip-port-map {
 662         list intip-port-map {
 663             key router-id;
 664             leaf router-id { type uint32; }
 665             list ip-port {
 666                 key internal-ip;
 667                 leaf internal-ip { type string; }
 668                 list int-ip-proto-type {
 669                     key protocol;
 670                     leaf protocol { type protocol-types; }
 671                     leaf-list ports { type uint16; }
 672                 }
 673             }
 674         }
 675     }
 676     Method returns InternalIp port List
 677     */
 678
 679     public static List<Integer> getInternalIpPortListInfo(DataBroker dataBroker,Long routerId, String internalIpAddress, ProtocolTypes protocolType){
 680         Optional<IntIpProtoType> optionalIpProtoType = read(dataBroker, LogicalDatastoreType.CONFIGURATION, buildSnatIntIpPortIdentifier(routerId, internalIpAddress, protocolType));
 681         if (optionalIpProtoType.isPresent()) {
 682             return optionalIpProtoType.get().getPorts();
 683         }
 684         return null;
 685     }
 686
 687     public static InstanceIdentifier<IntIpProtoType> buildSnatIntIpPortIdentifier(Long routerId, String internalIpAddress, ProtocolTypes protocolType) {
 688         InstanceIdentifier<IntIpProtoType> intIpProtocolTypeId = InstanceIdentifier.builder(SnatintIpPortMap.class).child
 689                 (IntipPortMap.class, new IntipPortMapKey(routerId)).child(IpPort.class, new IpPortKey(internalIpAddress)).child
 690                 (IntIpProtoType.class, new IntIpProtoTypeKey(protocolType)).build();
 691         return intIpProtocolTypeId;
 692     }
 693
 694     public static ProtocolTypes getProtocolType(NAPTEntryEvent.Protocol protocol) {
 695         ProtocolTypes protocolType = ProtocolTypes.TCP.toString().equals(protocol.toString()) ? ProtocolTypes.TCP : ProtocolTypes.UDP;
 696         return protocolType;
 697     }
 698
 699     public static NaptSwitches getNaptSwitch(DataBroker broker) {
 700         Optional<NaptSwitches> switchesOptional = read(broker, LogicalDatastoreType.OPERATIONAL, getNaptSwitchesIdentifier());
 701         if(switchesOptional.isPresent()) {
 702             return switchesOptional.get();
 703         }
 704         return null;
 705     }
 706
 707     public static InstanceIdentifier<NaptSwitches> getNaptSwitchesIdentifier() {
 708         return InstanceIdentifier.create(NaptSwitches.class);
 709     }
 710
 711     public static InstanceIdentifier<RouterToNaptSwitch> buildNaptSwitchRouterIdentifier(String routerId) {
 712         return InstanceIdentifier.create(NaptSwitches.class).child(RouterToNaptSwitch.class, new RouterToNaptSwitchKey(routerId));
 713     }
 714
 715     public static String toStringIpAddress(byte[] ipAddress, Logger log)
 716     {
 717       String ip = "";
 718       if (ipAddress == null) {
 719         return ip;
 720       }
 721
 722       try {
 723         ip = InetAddress.getByAddress(ipAddress).getHostAddress();
 724       } catch(UnknownHostException e) {
 725         log.error("NAT Service : Caught exception during toStringIpAddress()");
 726       }
 727
 728       return ip;
 729     }
 730
 731     public static String getGroupIdKey(String routerName){
 732         String groupIdKey = new String("snatmiss." + routerName);
 733         return groupIdKey;
 734     }
 735
 736     public static long createGroupId(String groupIdKey,IdManagerService idManager) {
 737         AllocateIdInput getIdInput = new AllocateIdInputBuilder()
 738                 .setPoolName(NatConstants.SNAT_IDPOOL_NAME).setIdKey(groupIdKey)
 739                 .build();
 740         try {
 741             Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
 742             RpcResult<AllocateIdOutput> rpcResult = result.get();
 743             return rpcResult.getResult().getIdValue();
 744         } catch (NullPointerException | InterruptedException | ExecutionException e) {
 745             LOG.trace("", e);
 746         }
 747         return 0;
 748     }
 749
 750     public static void removePrefixFromBGP(IBgpManager bgpManager, String rd, String prefix, Logger log) {
 751         try {
 752             bgpManager.deletePrefix(rd, prefix);
 753         } catch(Exception e) {
 754             log.error("Delete prefix failed", e);
 755         }
 756     }
 757
 758     public static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, BigInteger cookie, String flowId) {
 759         FlowEntity flowEntity = new FlowEntity(dpnId);
 760         flowEntity.setTableId(tableId);
 761         flowEntity.setCookie(cookie);
 762         flowEntity.setFlowId(flowId);
 763         return flowEntity;
 764     }
 765
 766     public static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, String flowId) {
 767         FlowEntity flowEntity = new FlowEntity(dpnId);
 768         flowEntity.setTableId(tableId);
 769         flowEntity.setFlowId(flowId);
 770         return flowEntity;
 771     }
 772
 773     public static IpPortMapping getIportMapping(DataBroker broker, long routerId) {
 774         Optional<IpPortMapping> getIportMappingData = read(broker, LogicalDatastoreType.CONFIGURATION, getIportMappingIdentifier(routerId));
 775         if(getIportMappingData.isPresent()) {
 776             return getIportMappingData.get();
 777         }
 778         return null;
 779     }
 780
 781     public static InstanceIdentifier<IpPortMapping> getIportMappingIdentifier(long routerId) {
 782         return InstanceIdentifier.builder(IntextIpPortMap.class).child(IpPortMapping.class, new IpPortMappingKey(routerId)).build();
 783     }
 784
 785     public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.IpMapping> getIpMappingBuilder(Long routerId) {
 786         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.IpMapping> idBuilder = InstanceIdentifier.builder(IntextIpMap.class)
 787                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.IpMapping.class, new org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.IpMappingKey(routerId)).build();
 788         return idBuilder;
 789     }
 790
 791     public static List<String> getExternalIpsForRouter(DataBroker dataBroker,Long routerId) {
 792         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.IpMapping> ipMappingOptional = read(dataBroker,
 793                 LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId));
 794         List<String> externalIps = new ArrayList<>();
 795         if (ipMappingOptional.isPresent()) {
 796             List<IpMap> ipMaps = ipMappingOptional.get().getIpMap();
 797             for (IpMap ipMap : ipMaps) {
 798                 externalIps.add(ipMap.getExternalIp());
 799             }
 800             return externalIps;
 801         }
 802         return null;
 803     }
 804
 805     /*
 806     container external-ips-counter {
 807         config false;
 808         list external-counters{
 809             key segment-id;
 810             leaf segment-id { type uint32; }
 811             list external-ip-counter {
 812                 key external-ip;
 813                 leaf external-ip { type string; }
 814                 leaf counter { type uint8; }
 815             }
 816         }
 817     }
 818     */
 819
 820     public static String getLeastLoadedExternalIp(DataBroker dataBroker, long segmentId){
 821         String leastLoadedExternalIp =  null;
 822         InstanceIdentifier<ExternalCounters> id = InstanceIdentifier.builder(ExternalIpsCounter.class).child(ExternalCounters.class, new ExternalCountersKey(segmentId)).build();
 823         Optional <ExternalCounters> externalCountersData = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
 824         if (externalCountersData.isPresent()) {
 825             ExternalCounters externalCounter = externalCountersData.get();
 826             List<ExternalIpCounter> externalIpCounterList = externalCounter.getExternalIpCounter();
 827             short countOfLstLoadExtIp = 32767;
 828             for(ExternalIpCounter externalIpCounter : externalIpCounterList){
 829                 String curExternalIp = externalIpCounter.getExternalIp();
 830                 short countOfCurExtIp  = externalIpCounter.getCounter();
 831                 if( countOfCurExtIp < countOfLstLoadExtIp ){
 832                     countOfLstLoadExtIp = countOfCurExtIp;
 833                     leastLoadedExternalIp = curExternalIp;
 834                 }
 835             }
 836         }
 837         return leastLoadedExternalIp;
 838     }
 839
 840     public static String[] getSubnetIpAndPrefix(DataBroker dataBroker, Uuid subnetId){
 841         String subnetIP = getSubnetIp(dataBroker, subnetId);
 842         if(subnetId != null){
 843             return getSubnetIpAndPrefix(subnetIP);
 844         }
 845         return null;
 846     }
 847
 848     public static String getSubnetIp(DataBroker dataBroker, Uuid subnetId){
 849         InstanceIdentifier<Subnetmap> subnetmapId = InstanceIdentifier
 850                 .builder(Subnetmaps.class)
 851                 .child(Subnetmap.class, new SubnetmapKey(subnetId))
 852                 .build();
 853         Optional<Subnetmap> removedSubnet = read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetmapId);
 854         if(removedSubnet.isPresent()) {
 855             Subnetmap subnetMapEntry = removedSubnet.get();
 856             return subnetMapEntry.getSubnetIp();
 857         }
 858         return null;
 859
 860     }
 861     public static String[] getSubnetIpAndPrefix(String subnetString){
 862         String[] subnetSplit = subnetString.split("/");
 863         String subnetIp = subnetSplit[0];
 864         String subnetPrefix = "0";
 865         if (subnetSplit.length == 2) {
 866             subnetPrefix = subnetSplit[1];
 867         }
 868         return new String[] {subnetIp, subnetPrefix};
 869     }
 870
 871     public static String[] getExternalIpAndPrefix(String leastLoadedExtIpAddr){
 872         String[] leastLoadedExtIpAddrSplit = leastLoadedExtIpAddr.split("/");
 873         String leastLoadedExtIp = leastLoadedExtIpAddrSplit[0];
 874         String leastLoadedExtIpPrefix = String.valueOf(NatConstants.DEFAULT_PREFIX);
 875         if (leastLoadedExtIpAddrSplit.length == 2) {
 876             leastLoadedExtIpPrefix = leastLoadedExtIpAddrSplit[1];
 877         }
 878         return new String[] {leastLoadedExtIp, leastLoadedExtIpPrefix};
 879     }
 880
 881     public static List<BigInteger> getDpnsForRouter(DataBroker dataBroker, String routerUuid){
 882         InstanceIdentifier id = InstanceIdentifier.builder(NeutronRouterDpns.class).child(RouterDpnList.class, new RouterDpnListKey(routerUuid)).build();
 883         Optional<RouterDpnList> routerDpnListData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
 884         List<BigInteger> dpns = new ArrayList<>();
 885         if (routerDpnListData.isPresent()) {
 886             List<DpnVpninterfacesList> dpnVpninterfacesList = routerDpnListData.get().getDpnVpninterfacesList();
 887             for (DpnVpninterfacesList dpnVpnInterface : dpnVpninterfacesList) {
 888                 dpns.add(dpnVpnInterface.getDpnId());
 889             }
 890             return dpns;
 891         }
 892         return null;
 893     }
 894
 895     public static long getBgpVpnId(DataBroker dataBroker, String routerName){
 896         long bgpVpnId = NatConstants.INVALID_ID;
 897         Uuid bgpVpnUuid = NatUtil.getVpnForRouter(dataBroker, routerName);
 898         if(bgpVpnUuid != null){
 899             bgpVpnId = NatUtil.getVpnId(dataBroker, bgpVpnUuid.getValue());
 900         }
 901         return bgpVpnId;
 902     }
 903 }