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