vpnservice/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnUtil.java

   1 /*
   2  * Copyright (c) 2015 - 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.netvirt.vpnmanager;
  10
  11 import java.math.BigInteger;
  12 import java.net.InetAddress;
  13 import java.util.concurrent.ExecutionException;
  14 import java.util.concurrent.Future;
  15 import java.util.List;
  16
  17 import com.google.common.base.Optional;
  18 import com.google.common.primitives.Ints;
  19 import com.google.common.util.concurrent.CheckedFuture;
  20 import com.google.common.util.concurrent.FutureCallback;
  21 import com.google.common.util.concurrent.Futures;
  22
  23 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  24 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  25 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  26 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  27 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  28 import org.opendaylight.genius.mdsalutil.NwConstants;
  29 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
  30 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
  31 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  32 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  33 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
  34 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  35 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  36 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.*;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIds;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIdsKey;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesKey;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterfaceBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterface;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterfaceKey;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.Vpn;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.VpnKey;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.vpn.Extraroute;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.vpn.ExtrarouteBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.vpn.ExtrarouteKey;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesListKey;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.IfIndexesInterfaceMap;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceKey;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.L3nexthop;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthops;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthopsKey;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronPortData;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.port.data.PortFixedipToPortName;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.port.data.PortFixedipToPortNameKey;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagName;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanTagNameMap;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagNameKey;
  90 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  91 import org.opendaylight.yangtools.yang.common.RpcResult;
  92 import org.opendaylight.yangtools.yang.binding.DataObject;
  93 import org.slf4j.Logger;
  94 import org.slf4j.LoggerFactory;
  95
  96 public class VpnUtil {
  97     private static final Logger LOG = LoggerFactory.getLogger(VpnUtil.class);
  98     private static final int DEFAULT_PREFIX_LENGTH = 32;
  99     private static final String PREFIX_SEPARATOR = "/";
 100
 101     static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
 102         return InstanceIdentifier.builder(VpnInterfaces.class)
 103                 .child(VpnInterface.class, new VpnInterfaceKey(vpnInterfaceName)).build();
 104     }
 105
 106     static InstanceIdentifier<VpnInstance> getVpnInstanceIdentifier(String vpnName) {
 107         return InstanceIdentifier.builder(VpnInstances.class)
 108                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 109     }
 110
 111     static VpnInterface getVpnInterface(String intfName, String vpnName, Adjacencies aug) {
 112         return new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(intfName)).setVpnInstanceName(vpnName)
 113                 .addAugmentation(Adjacencies.class, aug)
 114                 .build();
 115     }
 116
 117     static InstanceIdentifier<Prefixes> getPrefixToInterfaceIdentifier(long vpnId, String ipPrefix) {
 118         return InstanceIdentifier.builder(PrefixToInterface.class)
 119             .child(VpnIds.class, new VpnIdsKey(vpnId)).child(Prefixes.class,
 120                                                              new PrefixesKey(ipPrefix)).build();
 121     }
 122
 123     static Prefixes getPrefixToInterface(BigInteger dpId, String vpnInterfaceName, String ipPrefix) {
 124         return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(
 125             vpnInterfaceName).setIpAddress(ipPrefix).build();
 126     }
 127
 128     static InstanceIdentifier<Extraroute> getVpnToExtrarouteIdentifier(String vrfId, String ipPrefix) {
 129         return InstanceIdentifier.builder(VpnToExtraroute.class)
 130                 .child(Vpn.class, new VpnKey(vrfId)).child(Extraroute.class,
 131                  new ExtrarouteKey(ipPrefix)).build();
 132     }
 133
 134     static Extraroute getVpnToExtraroute(String ipPrefix, String nextHop) {
 135         return new ExtrarouteBuilder().setPrefix(ipPrefix).setNexthopIp(nextHop).build();
 136     }
 137
 138     static Adjacencies
 139     getVpnInterfaceAugmentation(List<Adjacency> nextHops) {
 140         return new AdjacenciesBuilder().setAdjacency(nextHops).build();
 141     }
 142
 143     public static InstanceIdentifier<IdPool> getPoolId(String poolName){
 144         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
 145                         InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
 146         InstanceIdentifier<IdPool> id = idBuilder.build();
 147         return id;
 148     }
 149
 150     static InstanceIdentifier<VpnInterfaces> getVpnInterfacesIdentifier() {
 151         return InstanceIdentifier.builder(VpnInterfaces.class).build();
 152     }
 153
 154     static InstanceIdentifier<Interface> getInterfaceIdentifier(String interfaceName) {
 155         return InstanceIdentifier.builder(Interfaces.class)
 156                 .child(Interface.class, new InterfaceKey(interfaceName)).build();
 157     }
 158
 159     static InstanceIdentifier<VpnToDpnList> getVpnToDpnListIdentifier(String rd, BigInteger dpnId) {
 160         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 161             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd))
 162             .child(VpnToDpnList.class, new VpnToDpnListKey(dpnId)).build();
 163     }
 164
 165     public static BigInteger getCookieArpFlow(int interfaceTag) {
 166         return VpnConstants.COOKIE_L3_BASE.add(new BigInteger("0110000", 16)).add(
 167             BigInteger.valueOf(interfaceTag));
 168     }
 169
 170     public static String getFlowRef(BigInteger dpnId, short tableId, int ethType, int lPortTag, int arpType) {
 171             return new StringBuffer().append(VpnConstants.FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 172                     .append(tableId).append(NwConstants.FLOWID_SEPARATOR).append(ethType).append(lPortTag)
 173                     .append(NwConstants.FLOWID_SEPARATOR).append(arpType).toString();
 174     }
 175
 176     public static int getUniqueId(IdManagerService idManager, String poolName,String idKey) {
 177         AllocateIdInput getIdInput = new AllocateIdInputBuilder()
 178                                            .setPoolName(poolName)
 179                                            .setIdKey(idKey).build();
 180
 181         try {
 182             Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
 183             RpcResult<AllocateIdOutput> rpcResult = result.get();
 184             if(rpcResult.isSuccessful()) {
 185                 return rpcResult.getResult().getIdValue().intValue();
 186             } else {
 187                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
 188             }
 189         } catch (InterruptedException | ExecutionException e) {
 190             LOG.warn("Exception when getting Unique Id",e);
 191         }
 192         return 0;
 193     }
 194
 195     public static void releaseId(IdManagerService idManager, String poolName, String idKey) {
 196         ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
 197         try {
 198             Future<RpcResult<Void>> result = idManager.releaseId(idInput);
 199             RpcResult<Void> rpcResult = result.get();
 200             if(!rpcResult.isSuccessful()) {
 201                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
 202             }
 203         } catch (InterruptedException | ExecutionException e) {
 204             LOG.warn("Exception when getting Unique Id for key {}", idKey, e);
 205         }
 206     }
 207
 208     public static String getNextHopLabelKey(String rd, String prefix){
 209         String key = rd + VpnConstants.SEPARATOR + prefix;
 210         return key;
 211     }
 212
 213     public static long getVpnId(DataBroker broker, String vpnName) {
 214
 215         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 216             = getVpnInstanceToVpnIdIdentifier(vpnName);
 217         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 218             = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 219
 220         long vpnId = VpnConstants.INVALID_ID;
 221         if(vpnInstance.isPresent()) {
 222             vpnId = vpnInstance.get().getVpnId();
 223         }
 224         return vpnId;
 225     }
 226
 227     public static String getVpnRd(DataBroker broker, String vpnName) {
 228
 229         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 230                 = getVpnInstanceToVpnIdIdentifier(vpnName);
 231         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 232                 = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 233
 234         String rd = null;
 235         if(vpnInstance.isPresent()) {
 236             rd = vpnInstance.get().getVrfId();
 237         }
 238         return rd;
 239     }
 240
 241     static String getVpnRdFromVpnInstanceConfig(DataBroker broker, String vpnName) {
 242         InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
 243                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 244         Optional<VpnInstance> vpnInstance = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 245         String rd = null;
 246         if(vpnInstance.isPresent()) {
 247             VpnInstance instance = vpnInstance.get();
 248             VpnAfConfig config = instance.getIpv4Family();
 249             rd = config.getRouteDistinguisher();
 250         }
 251         return rd;
 252     }
 253
 254     static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance
 255            getVpnInstanceToVpnId(String vpnName, long vpnId, String rd) {
 256         return new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceBuilder()
 257             .setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).build();
 258
 259     }
 260
 261     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance>
 262            getVpnInstanceToVpnIdIdentifier(String vpnName) {
 263         return InstanceIdentifier.builder(VpnInstanceToVpnId.class)
 264             .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance.class,
 265                    new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceKey(vpnName)).build();
 266     }
 267
 268     static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
 269         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 270             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
 271     }
 272
 273     static VpnInstanceOpDataEntry getVpnInstanceOpDataBuilder(String rd, long vpnId) {
 274         return new VpnInstanceOpDataEntryBuilder().setVrfId(rd).setVpnId(vpnId).build();
 275     }
 276
 277     static VpnInstanceOpDataEntry updateIntfCntInVpnInstOpData(Long count, String vrfId) {
 278         return new VpnInstanceOpDataEntryBuilder().setVpnInterfaceCount(count).setVrfId(vrfId).build();
 279     }
 280
 281         static InstanceIdentifier<RouterInterface> getRouterInterfaceId(String interfaceName) {
 282         return InstanceIdentifier.builder(RouterInterfaces.class)
 283                 .child(RouterInterface.class, new RouterInterfaceKey(interfaceName)).build();
 284     }
 285
 286     static RouterInterface getRouterInterface(String interfaceName, String routerName) {
 287         return new RouterInterfaceBuilder().setKey(new RouterInterfaceKey(interfaceName))
 288                 .setInterfaceName(interfaceName).setRouterName(routerName).build();
 289     }
 290
 291     static VpnInstanceOpDataEntry getVpnInstanceOpData(DataBroker broker, String rd) {
 292         InstanceIdentifier<VpnInstanceOpDataEntry> id = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
 293         Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = read(broker, LogicalDatastoreType.OPERATIONAL, id);
 294         if(vpnInstanceOpData.isPresent()) {
 295             return vpnInstanceOpData.get();
 296         }
 297         return null;
 298     }
 299
 300     static VpnInterface getConfiguredVpnInterface(DataBroker broker, String interfaceName) {
 301         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 302         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
 303
 304         if (configuredVpnInterface.isPresent()) {
 305             return configuredVpnInterface.get();
 306         }
 307         return null;
 308     }
 309
 310     static VpnInterface getOperationalVpnInterface(DataBroker broker, String interfaceName) {
 311         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 312         Optional<VpnInterface> operationalVpnInterface = read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
 313
 314         if (operationalVpnInterface.isPresent()) {
 315             return operationalVpnInterface.get();
 316         }
 317         return null;
 318     }
 319
 320     static boolean isVpnInterfaceConfigured(DataBroker broker, String interfaceName)
 321     {
 322         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 323         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
 324
 325         if (configuredVpnInterface.isPresent()) {
 326             return true;
 327         }
 328         return false;
 329     }
 330
 331     static String getIpPrefix(String prefix) {
 332         String prefixValues[] = prefix.split("/");
 333         if (prefixValues.length == 1) {
 334             prefix = prefix + PREFIX_SEPARATOR + DEFAULT_PREFIX_LENGTH ;
 335         }
 336         return prefix;
 337     }
 338
 339     static final FutureCallback<Void> DEFAULT_CALLBACK =
 340             new FutureCallback<Void>() {
 341                 public void onSuccess(Void result) {
 342                     LOG.debug("Success in Datastore operation");
 343                 }
 344
 345                 public void onFailure(Throwable error) {
 346                     LOG.error("Error in Datastore operation", error);
 347                 }
 348             };
 349
 350     public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
 351                                                     InstanceIdentifier<T> path) {
 352
 353         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
 354
 355         Optional<T> result = Optional.absent();
 356         try {
 357             result = tx.read(datastoreType, path).get();
 358         } catch (Exception e) {
 359             throw new RuntimeException(e);
 360         } finally {
 361             tx.close();
 362         }
 363
 364         return result;
 365     }
 366
 367     static <T extends DataObject> void asyncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
 368                                                       InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 369         WriteTransaction tx = broker.newWriteOnlyTransaction();
 370         tx.merge(datastoreType, path, data, true);
 371         Futures.addCallback(tx.submit(), callback);
 372     }
 373
 374     static <T extends DataObject> void asyncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
 375                                                    InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 376         WriteTransaction tx = broker.newWriteOnlyTransaction();
 377         tx.put(datastoreType, path, data, true);
 378         Futures.addCallback(tx.submit(), callback);
 379     }
 380
 381     static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
 382                                                InstanceIdentifier<T> path, FutureCallback<Void> callback) {
 383         WriteTransaction tx = broker.newWriteOnlyTransaction();
 384         tx.delete(datastoreType, path);
 385         Futures.addCallback(tx.submit(), callback);
 386     }
 387
 388     public static <T extends DataObject> void syncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
 389                     InstanceIdentifier<T> path, T data) {
 390         WriteTransaction tx = broker.newWriteOnlyTransaction();
 391         tx.put(datastoreType, path, data, true);
 392         CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
 393         try {
 394             futures.get();
 395         } catch (InterruptedException | ExecutionException e) {
 396             LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data);
 397             throw new RuntimeException(e.getMessage());
 398         }
 399     }
 400
 401     public static <T extends DataObject> void syncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
 402                     InstanceIdentifier<T> path, T data) {
 403         WriteTransaction tx = broker.newWriteOnlyTransaction();
 404         tx.merge(datastoreType, path, data, true);
 405         CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
 406         try {
 407             futures.get();
 408         } catch (InterruptedException | ExecutionException e) {
 409             LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data);
 410             throw new RuntimeException(e.getMessage());
 411         }
 412     }
 413
 414     public static long getRemoteBCGroup(long elanTag) {
 415         return VpnConstants.ELAN_GID_MIN + ((elanTag % VpnConstants.ELAN_GID_MIN) *2);
 416     }
 417
 418     // interface-index-tag operational container
 419     public static IfIndexInterface getInterfaceInfoByInterfaceTag(DataBroker broker, long interfaceTag) {
 420         InstanceIdentifier<IfIndexInterface> interfaceId = getInterfaceInfoEntriesOperationalDataPath(interfaceTag);
 421         Optional<IfIndexInterface> existingInterfaceInfo = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
 422         if(existingInterfaceInfo.isPresent()) {
 423             return existingInterfaceInfo.get();
 424         }
 425         return null;
 426     }
 427
 428     private static InstanceIdentifier<IfIndexInterface> getInterfaceInfoEntriesOperationalDataPath(long interfaceTag) {
 429         return InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class,
 430                 new IfIndexInterfaceKey((int) interfaceTag)).build();
 431     }
 432
 433     public static String getNeutronPortNamefromPortFixedIp(DataBroker broker, String fixedIp) {
 434         InstanceIdentifier id = buildFixedIpToPortNameIdentifier(fixedIp);
 435         Optional<PortFixedipToPortName> portFixedipToPortNameData = read(broker, LogicalDatastoreType.CONFIGURATION,
 436                 id);
 437         if (portFixedipToPortNameData.isPresent()) {
 438             return portFixedipToPortNameData.get().getPortName();
 439         }
 440         return null;
 441     }
 442
 443     private static InstanceIdentifier<PortFixedipToPortName> buildFixedIpToPortNameIdentifier(String fixedIp) {
 444         InstanceIdentifier<PortFixedipToPortName> id = InstanceIdentifier.builder(NeutronPortData.class).child
 445                 (PortFixedipToPortName.class, new PortFixedipToPortNameKey(fixedIp)).build();
 446         return id;
 447     }
 448
 449     public static ElanTagName getElanInfoByElanTag(DataBroker broker,long elanTag) {
 450         InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
 451         Optional<ElanTagName> existingElanInfo = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, elanId);
 452         if(existingElanInfo.isPresent()) {
 453             return existingElanInfo.get();
 454         }
 455         return null;
 456     }
 457
 458     private static InstanceIdentifier<ElanTagName> getElanInfoEntriesOperationalDataPath(long elanTag) {
 459         return InstanceIdentifier.builder(ElanTagNameMap.class).child(ElanTagName.class,
 460                 new ElanTagNameKey(elanTag)).build();
 461     }
 462
 463
 464     public static boolean isIpInSubnet(int ipAddress, String subnetCidr) {
 465         String[] subSplit = subnetCidr.split("/");
 466         if (subSplit.length < 2) {
 467             return false;
 468         }
 469
 470         String subnetStr = subSplit[0];
 471         int subnet = 0;
 472         try {
 473             InetAddress subnetAddress = InetAddress.getByName(subnetStr);
 474             subnet = Ints.fromByteArray(subnetAddress.getAddress());
 475         } catch (Exception ex) {
 476             LOG.error("Passed in Subnet IP string not convertible to InetAdddress " + subnetStr);
 477             return false;
 478         }
 479         int prefixLength = Integer.valueOf(subSplit[1]);
 480         int mask = -1 << (32 - prefixLength);
 481         if ((subnet & mask) == (ipAddress & mask)) {
 482             return true;
 483         }
 484         return false;
 485     }
 486
 487     public static void removePrefixToInterfaceForVpnId(DataBroker broker, long vpnId) {
 488         try {
 489             // Clean up PrefixToInterface Operational DS
 490             delete(broker, LogicalDatastoreType.OPERATIONAL,
 491                     InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build(),
 492                     DEFAULT_CALLBACK);
 493         } catch (Exception e) {
 494             LOG.error("Exception during cleanup of PrefixToInterface for VPN ID {}", vpnId, e);
 495         }
 496     }
 497
 498     public static void removeVpnExtraRouteForVpn(DataBroker broker, String vpnName) {
 499         try {
 500             // Clean up VPNExtraRoutes Operational DS
 501             delete(broker, LogicalDatastoreType.OPERATIONAL,
 502                     InstanceIdentifier.builder(VpnToExtraroute.class).child(Vpn.class, new VpnKey(vpnName)).build(),
 503                     DEFAULT_CALLBACK);
 504         } catch (Exception e) {
 505             LOG.error("Exception during cleanup of VPNToExtraRoute for VPN {}", vpnName, e);
 506         }
 507     }
 508
 509     public static void removeVpnOpInstance(DataBroker broker, String vpnName) {
 510         try {
 511             // Clean up VPNInstanceOpDataEntry
 512             delete(broker, LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(vpnName),
 513                     DEFAULT_CALLBACK);
 514         } catch (Exception e) {
 515             LOG.error("Exception during cleanup of VPNInstanceOpDataEntry for VPN {}", vpnName, e);
 516         }
 517     }
 518
 519     public static void removeVpnInstanceToVpnId(DataBroker broker, String vpnName) {
 520         try {
 521             delete(broker, LogicalDatastoreType.CONFIGURATION, getVpnInstanceToVpnIdIdentifier(vpnName),
 522                     DEFAULT_CALLBACK);
 523         } catch (Exception e) {
 524             LOG.error("Exception during clean up of VpnInstanceToVpnId for VPN {}", vpnName, e);
 525         }
 526     }
 527
 528     public static void removeVrfTableForVpn(DataBroker broker, String vpnName) {
 529         // Clean up FIB Entries Config DS
 530         try {
 531             delete(broker, LogicalDatastoreType.CONFIGURATION,
 532                     InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(vpnName)).build(),
 533                     DEFAULT_CALLBACK);
 534         } catch (Exception e) {
 535             LOG.error("Exception during clean up of VrfTable from FIB for VPN {}", vpnName, e);
 536         }
 537     }
 538
 539     public static void removeL3nexthopForVpnId(DataBroker broker, long vpnId) {
 540         try {
 541             // Clean up L3NextHop Operational DS
 542             delete(broker, LogicalDatastoreType.OPERATIONAL,
 543                     InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class, new VpnNexthopsKey(vpnId)).build(),
 544                     DEFAULT_CALLBACK);
 545         } catch (Exception e) {
 546             LOG.error("Exception during cleanup of L3NextHop for VPN ID {}", vpnId, e);
 547         }
 548     }
 549 }