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