interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceMetaUtils.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.genius.interfacemanager.commons;
   9
  10 import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
  11
  12 import java.util.Collections;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Optional;
  16 import java.util.concurrent.ConcurrentHashMap;
  17 import java.util.concurrent.ConcurrentMap;
  18 import java.util.concurrent.ExecutionException;
  19 import javax.inject.Inject;
  20 import javax.inject.Singleton;
  21 import org.apache.aries.blueprint.annotation.service.Reference;
  22 import org.opendaylight.genius.infra.Datastore.Configuration;
  23 import org.opendaylight.genius.infra.Datastore.Operational;
  24 import org.opendaylight.genius.infra.TypedReadTransaction;
  25 import org.opendaylight.genius.infra.TypedWriteTransaction;
  26 import org.opendaylight.genius.interfacemanager.IfmConstants;
  27 import org.opendaylight.genius.interfacemanager.IfmUtil;
  28 import org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.BatchingUtils;
  29 import org.opendaylight.mdsal.binding.api.DataBroker;
  30 import org.opendaylight.mdsal.binding.api.ReadTransaction;
  31 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  32 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeInterfaceInfo;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeRefInfo;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.IfIndexesInterfaceMap;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.InterfaceChildInfo;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.TunnelInstanceInterfaceMap;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceKey;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntryKey;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntry;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntryBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntryKey;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntry;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntryBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntryKey;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntry;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntryBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntryKey;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.tunnel.instance._interface.map.TunnelInstanceInterface;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.tunnel.instance._interface.map.TunnelInstanceInterfaceBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.tunnel.instance._interface.map.TunnelInstanceInterfaceKey;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
  64 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  65 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  66 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  67 import org.opendaylight.yangtools.yang.common.Uint64;
  68 import org.slf4j.Logger;
  69 import org.slf4j.LoggerFactory;
  70
  71 @Singleton
  72 public final class InterfaceMetaUtils {
  73     private static final Logger LOG = LoggerFactory.getLogger(InterfaceMetaUtils.class);
  74
  75     private final DataBroker dataBroker;
  76     private final IdManagerService idManager;
  77     private final BatchingUtils batchingUtils;
  78     private final ConcurrentMap<Uint64, BridgeEntry> bridgeEntryMap = new ConcurrentHashMap<>();
  79     private final ConcurrentMap<Uint64, BridgeRefEntry> bridgeRefEntryMap = new ConcurrentHashMap<>();
  80
  81     @Inject
  82     public InterfaceMetaUtils(@Reference DataBroker dataBroker,
  83                               IdManagerService idManager,
  84                               BatchingUtils batchingUtils) {
  85         this.dataBroker = dataBroker;
  86         this.idManager = idManager;
  87         this.batchingUtils = batchingUtils;
  88     }
  89
  90     public static InstanceIdentifier<BridgeRefEntry> getBridgeRefEntryIdentifier(BridgeRefEntryKey bridgeRefEntryKey) {
  91         InstanceIdentifier.InstanceIdentifierBuilder<BridgeRefEntry> bridgeRefEntryInstanceIdentifierBuilder =
  92                 InstanceIdentifier.builder(BridgeRefInfo.class)
  93                         .child(BridgeRefEntry.class, bridgeRefEntryKey);
  94         return bridgeRefEntryInstanceIdentifierBuilder.build();
  95     }
  96
  97     public BridgeRefEntry getBridgeRefEntryFromOperationalDS(Uint64 dpId) {
  98         BridgeRefEntryKey bridgeRefEntryKey = new BridgeRefEntryKey(dpId);
  99         InstanceIdentifier<BridgeRefEntry> bridgeRefEntryIid = InterfaceMetaUtils
 100                 .getBridgeRefEntryIdentifier(bridgeRefEntryKey);
 101         BridgeRefEntry bridgeRefEntry = IfmUtil.read(LogicalDatastoreType.OPERATIONAL,
 102                 bridgeRefEntryIid, dataBroker).orElse(null);
 103         if (bridgeRefEntry != null) {
 104             addBridgeRefEntryToCache(dpId, bridgeRefEntry);
 105         }
 106         return bridgeRefEntry;
 107     }
 108
 109     public BridgeRefEntry getBridgeRefEntryFromOperDS(Uint64 dpId) {
 110         BridgeRefEntry bridgeRefEntry = getBridgeRefEntryFromCache(dpId);
 111         if (bridgeRefEntry != null) {
 112             return bridgeRefEntry;
 113         }
 114         BridgeRefEntryKey bridgeRefEntryKey = new BridgeRefEntryKey(dpId);
 115         InstanceIdentifier<BridgeRefEntry> bridgeRefEntryIid = InterfaceMetaUtils
 116                 .getBridgeRefEntryIdentifier(bridgeRefEntryKey);
 117         bridgeRefEntry = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, bridgeRefEntryIid, dataBroker).orElse(null);
 118         if (bridgeRefEntry != null) {
 119             addBridgeRefEntryToCache(dpId, bridgeRefEntry);
 120         }
 121         return bridgeRefEntry;
 122     }
 123
 124     public OvsdbBridgeRef getOvsdbBridgeRef(Uint64 dpId) {
 125
 126         BridgeRefEntry bridgeRefEntry = getBridgeRefEntryFromOperDS(dpId);
 127
 128         if (bridgeRefEntry == null) {
 129             // bridge ref entry will be null if the bridge is disconnected from controller.
 130             // In that case, fetch bridge reference from bridge interface entry config DS
 131             BridgeEntry bridgeEntry = getBridgeEntryFromConfigDS(dpId);
 132             if (bridgeEntry == null) {
 133                 return null;
 134             }
 135             return  bridgeEntry.getBridgeReference();
 136         }
 137         return bridgeRefEntry.getBridgeReference();
 138     }
 139
 140     public BridgeRefEntry getBridgeReferenceForInterface(Interface interfaceInfo) {
 141         ParentRefs parentRefs = interfaceInfo.augmentation(ParentRefs.class);
 142         Uint64 dpn = parentRefs.getDatapathNodeIdentifier();
 143         return getBridgeRefEntryFromOperDS(dpn);
 144     }
 145
 146     public boolean bridgeExists(BridgeRefEntry bridgeRefEntry) {
 147         if (bridgeRefEntry != null && bridgeRefEntry.getBridgeReference() != null) {
 148             InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid =
 149                     (InstanceIdentifier<OvsdbBridgeAugmentation>) bridgeRefEntry.getBridgeReference().getValue();
 150             return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, bridgeIid, dataBroker).isPresent();
 151         }
 152         return false;
 153     }
 154
 155     public static InstanceIdentifier<BridgeEntry> getBridgeEntryIdentifier(BridgeEntryKey bridgeEntryKey) {
 156         InstanceIdentifier.InstanceIdentifierBuilder<BridgeEntry> bridgeEntryIdBuilder =
 157                 InstanceIdentifier.builder(BridgeInterfaceInfo.class).child(BridgeEntry.class, bridgeEntryKey);
 158         return bridgeEntryIdBuilder.build();
 159     }
 160
 161     public BridgeEntry getBridgeEntryFromConfigDS(Uint64 dpnId) {
 162         BridgeEntry bridgeEntry = getBridgeEntryFromCache(dpnId);
 163         if (bridgeEntry != null) {
 164             return bridgeEntry;
 165         }
 166         BridgeEntryKey bridgeEntryKey = new BridgeEntryKey(dpnId);
 167         InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier =
 168                 InterfaceMetaUtils.getBridgeEntryIdentifier(bridgeEntryKey);
 169         LOG.debug("Trying to retrieve bridge entry from config for Id: {}", bridgeEntryInstanceIdentifier);
 170         bridgeEntry = readBridgeEntryFromConfigDS(bridgeEntryInstanceIdentifier);
 171         if (bridgeEntry != null) {
 172             addBridgeEntryToCache(dpnId, bridgeEntry);
 173         }
 174         return bridgeEntry;
 175     }
 176
 177     public BridgeEntry getBridgeEntryFromConfigDS(InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier) {
 178         Uint64 dpnId = bridgeEntryInstanceIdentifier.firstKeyOf(BridgeEntry.class).getDpid();
 179         return getBridgeEntryFromConfigDS(dpnId);
 180     }
 181
 182     private BridgeEntry readBridgeEntryFromConfigDS(
 183             InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier) {
 184         return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier, dataBroker).orElse(null);
 185     }
 186
 187     public static InstanceIdentifier<BridgeInterfaceEntry> getBridgeInterfaceEntryIdentifier(
 188             BridgeEntryKey bridgeEntryKey, BridgeInterfaceEntryKey bridgeInterfaceEntryKey) {
 189         return InstanceIdentifier.builder(BridgeInterfaceInfo.class)
 190                 .child(BridgeEntry.class, bridgeEntryKey)
 191                 .child(BridgeInterfaceEntry.class, bridgeInterfaceEntryKey).build();
 192
 193     }
 194
 195     public void createBridgeInterfaceEntryInConfigDS(Uint64 dpId, String childInterface) {
 196         BridgeEntryKey bridgeEntryKey = new BridgeEntryKey(dpId);
 197         BridgeInterfaceEntryKey bridgeInterfaceEntryKey = new BridgeInterfaceEntryKey(childInterface);
 198         InstanceIdentifier<BridgeInterfaceEntry> bridgeInterfaceEntryIid =
 199                 InterfaceMetaUtils.getBridgeInterfaceEntryIdentifier(bridgeEntryKey, bridgeInterfaceEntryKey);
 200         BridgeInterfaceEntryBuilder entryBuilder = new BridgeInterfaceEntryBuilder().withKey(bridgeInterfaceEntryKey)
 201                 .setInterfaceName(childInterface);
 202         batchingUtils.write(bridgeInterfaceEntryIid, entryBuilder.build(), BatchingUtils.EntityType.DEFAULT_CONFIG);
 203     }
 204
 205     public static InstanceIdentifier<InterfaceParentEntry> getInterfaceParentEntryIdentifier(
 206             InterfaceParentEntryKey interfaceParentEntryKey) {
 207         InstanceIdentifier.InstanceIdentifierBuilder<InterfaceParentEntry> intfIdBuilder =
 208                 InstanceIdentifier.builder(InterfaceChildInfo.class)
 209                         .child(InterfaceParentEntry.class, interfaceParentEntryKey);
 210         return intfIdBuilder.build();
 211     }
 212
 213     public static InstanceIdentifier<InterfaceChildEntry> getInterfaceChildEntryIdentifier(
 214             InterfaceParentEntryKey interfaceParentEntryKey, InterfaceChildEntryKey interfaceChildEntryKey) {
 215         InstanceIdentifier.InstanceIdentifierBuilder<InterfaceChildEntry> intfIdBuilder =
 216                 InstanceIdentifier.builder(InterfaceChildInfo.class)
 217                         .child(InterfaceParentEntry.class, interfaceParentEntryKey)
 218                         .child(InterfaceChildEntry.class, interfaceChildEntryKey);
 219         return intfIdBuilder.build();
 220     }
 221
 222     @Deprecated
 223     public InterfaceParentEntry getInterfaceParentEntryFromConfigDS(String interfaceName) {
 224         InterfaceParentEntryKey interfaceParentEntryKey = new InterfaceParentEntryKey(interfaceName);
 225         InterfaceParentEntry interfaceParentEntry = getInterfaceParentEntryFromConfigDS(interfaceParentEntryKey);
 226         return interfaceParentEntry;
 227     }
 228
 229     public InterfaceParentEntry getInterfaceParentEntryFromConfigDS(ReadTransaction tx, String interfaceName)
 230             throws ExecutionException, InterruptedException {
 231         InterfaceParentEntryKey interfaceParentEntryKey = new InterfaceParentEntryKey(interfaceName);
 232         InterfaceParentEntry interfaceParentEntry = getInterfaceParentEntryFromConfigDS(tx, interfaceParentEntryKey);
 233         return interfaceParentEntry;
 234     }
 235
 236     @Deprecated
 237     public InterfaceParentEntry getInterfaceParentEntryFromConfigDS(InterfaceParentEntryKey interfaceParentEntryKey) {
 238         InstanceIdentifier<InterfaceParentEntry> intfParentIid =
 239                 getInterfaceParentEntryIdentifier(interfaceParentEntryKey);
 240
 241         return getInterfaceParentEntryFromConfigDS(intfParentIid);
 242     }
 243
 244     public InterfaceParentEntry getInterfaceParentEntryFromConfigDS(ReadTransaction tx,
 245             InterfaceParentEntryKey interfaceParentEntryKey) throws ExecutionException, InterruptedException {
 246         InstanceIdentifier<InterfaceParentEntry> intfParentIid =
 247                 getInterfaceParentEntryIdentifier(interfaceParentEntryKey);
 248
 249         return getInterfaceParentEntryFromConfigDS(tx, intfParentIid);
 250     }
 251
 252     public InterfaceParentEntry getInterfaceParentEntryFromConfigDS(InstanceIdentifier<InterfaceParentEntry> intfId) {
 253         return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfId, dataBroker).orElse(null);
 254     }
 255
 256     public InterfaceParentEntry getInterfaceParentEntryFromConfigDS(ReadTransaction tx,
 257             InstanceIdentifier<InterfaceParentEntry> intfId) throws ExecutionException, InterruptedException {
 258         return tx.read(LogicalDatastoreType.CONFIGURATION, intfId).get().orElse(null);
 259     }
 260
 261     public InterfaceChildEntry getInterfaceChildEntryFromConfigDS(
 262             InterfaceParentEntryKey interfaceParentEntryKey, InterfaceChildEntryKey interfaceChildEntryKey) {
 263         InstanceIdentifier<InterfaceChildEntry> intfChildIid =
 264                 getInterfaceChildEntryIdentifier(interfaceParentEntryKey, interfaceChildEntryKey);
 265
 266         return getInterfaceChildEntryFromConfigDS(intfChildIid);
 267     }
 268
 269     public InterfaceChildEntry getInterfaceChildEntryFromConfigDS(
 270             InstanceIdentifier<InterfaceChildEntry> intfChildIid) {
 271         return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfChildIid, dataBroker).orElse(null);
 272     }
 273
 274     public void createLportTagInterfaceMap(String infName, Integer ifIndex) {
 275         LOG.debug("creating lport tag to interface map for {} ifIndex {}",infName, ifIndex);
 276         InstanceIdentifier<IfIndexInterface> id = InstanceIdentifier.builder(IfIndexesInterfaceMap.class)
 277                 .child(IfIndexInterface.class, new IfIndexInterfaceKey(ifIndex)).build();
 278         IfIndexInterface ifIndexInterface = new IfIndexInterfaceBuilder().setIfIndex(ifIndex)
 279                 .withKey(new IfIndexInterfaceKey(ifIndex)).setInterfaceName(infName).build();
 280         batchingUtils.write(id, ifIndexInterface, BatchingUtils.EntityType.DEFAULT_OPERATIONAL);
 281     }
 282
 283     public int removeLportTagInterfaceMap(WriteTransaction tx, String infName) {
 284         // workaround to get the id to remove from lport tag interface map
 285         Integer ifIndex = IfmUtil.allocateId(idManager, IfmConstants.IFM_IDPOOL_NAME, infName);
 286         IfmUtil.releaseId(idManager, IfmConstants.IFM_IDPOOL_NAME, infName);
 287         LOG.debug("removing lport tag to interface map for {}",infName);
 288         InstanceIdentifier<IfIndexInterface> id = InstanceIdentifier.builder(IfIndexesInterfaceMap.class)
 289                 .child(IfIndexInterface.class, new IfIndexInterfaceKey(ifIndex)).build();
 290         tx.delete(LogicalDatastoreType.OPERATIONAL, id);
 291         return ifIndex;
 292     }
 293
 294     public int removeLportTagInterfaceMap(TypedWriteTransaction<Operational> tx, String infName) {
 295         // workaround to get the id to remove from lport tag interface map
 296         Integer ifIndex = IfmUtil.allocateId(idManager, IfmConstants.IFM_IDPOOL_NAME, infName);
 297         IfmUtil.releaseId(idManager, IfmConstants.IFM_IDPOOL_NAME, infName);
 298         LOG.debug("removing lport tag to interface map for {}",infName);
 299         InstanceIdentifier<IfIndexInterface> id = InstanceIdentifier.builder(IfIndexesInterfaceMap.class)
 300             .child(IfIndexInterface.class, new IfIndexInterfaceKey(ifIndex)).build();
 301         tx.delete(id);
 302         return ifIndex;
 303     }
 304
 305     public static void addBridgeRefToBridgeInterfaceEntry(Uint64 dpId, OvsdbBridgeRef ovsdbBridgeRef,
 306             TypedWriteTransaction<Configuration> tx) {
 307         BridgeEntryKey bridgeEntryKey = new BridgeEntryKey(dpId);
 308         InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier = getBridgeEntryIdentifier(bridgeEntryKey);
 309
 310         BridgeEntryBuilder bridgeEntryBuilder =
 311                 new BridgeEntryBuilder().withKey(bridgeEntryKey).setBridgeReference(ovsdbBridgeRef);
 312         tx.merge(bridgeEntryInstanceIdentifier, bridgeEntryBuilder.build(), CREATE_MISSING_PARENTS);
 313     }
 314
 315     public static void createBridgeRefEntry(Uint64 dpnId, InstanceIdentifier<?> bridgeIid,
 316                                             TypedWriteTransaction<Operational> tx) {
 317         LOG.debug("Creating bridge ref entry for dpn: {} bridge: {}",
 318                 dpnId, bridgeIid);
 319         BridgeRefEntryKey bridgeRefEntryKey = new BridgeRefEntryKey(dpnId);
 320         InstanceIdentifier<BridgeRefEntry> bridgeEntryId =
 321                 InterfaceMetaUtils.getBridgeRefEntryIdentifier(bridgeRefEntryKey);
 322         BridgeRefEntryBuilder tunnelDpnBridgeEntryBuilder =
 323                 new BridgeRefEntryBuilder().withKey(bridgeRefEntryKey).setDpid(dpnId)
 324                         .setBridgeReference(new OvsdbBridgeRef(bridgeIid));
 325         tx.put(bridgeEntryId, tunnelDpnBridgeEntryBuilder.build(), CREATE_MISSING_PARENTS);
 326     }
 327
 328     public static void deleteBridgeRefEntry(Uint64 dpnId, TypedWriteTransaction<Operational> tx) {
 329         LOG.debug("Deleting bridge ref entry for dpn: {}", dpnId);
 330         tx.delete(InterfaceMetaUtils.getBridgeRefEntryIdentifier(new BridgeRefEntryKey(dpnId)));
 331     }
 332
 333     public static void createTunnelToInterfaceMap(String tunnelInstanceId,
 334                                                   String infName,
 335                                                   TypedWriteTransaction<Operational> transaction) {
 336         LOG.debug("creating tunnel instance identifier to interface map for {}",infName);
 337         InstanceIdentifier<TunnelInstanceInterface> id = InstanceIdentifier.builder(TunnelInstanceInterfaceMap.class)
 338                 .child(TunnelInstanceInterface.class, new TunnelInstanceInterfaceKey(tunnelInstanceId)).build();
 339         TunnelInstanceInterface tunnelInstanceInterface = new TunnelInstanceInterfaceBuilder()
 340                 .setTunnelInstanceIdentifier(tunnelInstanceId).withKey(new TunnelInstanceInterfaceKey(tunnelInstanceId))
 341                 .setInterfaceName(infName).build();
 342         transaction.put(id, tunnelInstanceInterface, CREATE_MISSING_PARENTS);
 343
 344     }
 345
 346     public static void createTunnelToInterfaceMap(String infName,InstanceIdentifier<Node> nodeId,
 347                                                   TypedWriteTransaction<Operational> transaction,
 348                                                   IfTunnel ifTunnel) {
 349         InstanceIdentifier<Tunnels> tunnelsInstanceIdentifier = org.opendaylight.genius.interfacemanager.renderer
 350                 .hwvtep.utilities.SouthboundUtils.createTunnelsInstanceIdentifier(nodeId,
 351                         ifTunnel.getTunnelSource(), ifTunnel.getTunnelDestination());
 352         createTunnelToInterfaceMap(tunnelsInstanceIdentifier.toString(), infName, transaction);
 353     }
 354
 355     public static void removeTunnelToInterfaceMap(InstanceIdentifier<Node> nodeId,
 356                                                   TypedWriteTransaction<Operational> transaction,
 357                                                   IfTunnel ifTunnel) {
 358         InstanceIdentifier<Tunnels> tunnelsInstanceIdentifier = org.opendaylight.genius.interfacemanager.renderer
 359                 .hwvtep.utilities.SouthboundUtils.createTunnelsInstanceIdentifier(
 360                         nodeId, ifTunnel.getTunnelSource(), ifTunnel.getTunnelDestination());
 361         transaction.delete(tunnelsInstanceIdentifier);
 362     }
 363
 364     public static String getInterfaceForTunnelInstanceIdentifier(String tunnelInstanceId,
 365                                                                  TypedReadTransaction<Operational> tx)
 366         throws ExecutionException, InterruptedException {
 367         InstanceIdentifier<TunnelInstanceInterface> id = InstanceIdentifier.builder(TunnelInstanceInterfaceMap.class)
 368                 .child(TunnelInstanceInterface.class, new TunnelInstanceInterfaceKey(tunnelInstanceId)).build();
 369         return tx.read(id).get().map(TunnelInstanceInterface::getInterfaceName).orElse(null);
 370     }
 371
 372     public void deleteBridgeInterfaceEntry(BridgeEntryKey bridgeEntryKey,
 373             List<BridgeInterfaceEntry> bridgeInterfaceEntries, InstanceIdentifier<BridgeEntry> bridgeEntryIid,
 374             String interfaceName) {
 375         BridgeInterfaceEntryKey bridgeInterfaceEntryKey =
 376                 new BridgeInterfaceEntryKey(interfaceName);
 377         InstanceIdentifier<BridgeInterfaceEntry> bridgeInterfaceEntryIid =
 378                 InterfaceMetaUtils.getBridgeInterfaceEntryIdentifier(bridgeEntryKey,
 379                         bridgeInterfaceEntryKey);
 380
 381         if (bridgeInterfaceEntries.size() <= 1) {
 382             LOG.debug("{} is last bridge-interface entry for DPN : {}", interfaceName, bridgeEntryKey.getDpid());
 383             batchingUtils.delete(bridgeEntryIid, BatchingUtils.EntityType.DEFAULT_CONFIG);
 384         } else {
 385             // No point deleting interface individually if bridge entry is being deleted
 386             // Note: Will this cause issue in listener code? Does it expect separate notifications for two?
 387             LOG.debug("deleting bridge-interface entry {} for DPN : {}", interfaceName, bridgeEntryKey.getDpid());
 388             batchingUtils.delete(bridgeInterfaceEntryIid, BatchingUtils.EntityType.DEFAULT_CONFIG);
 389         }
 390     }
 391
 392     public List<TerminationPoint> getTerminationPointsOnBridge(Uint64 dpnId) {
 393         BridgeRefEntry bridgeRefEntry = getBridgeRefEntryFromOperDS(dpnId);
 394         if (bridgeRefEntry == null || bridgeRefEntry.getBridgeReference() == null) {
 395             LOG.debug("BridgeRefEntry for DPNID {} not found", dpnId);
 396             return Collections.emptyList();
 397         }
 398         InstanceIdentifier<Node> nodeIid =
 399                         bridgeRefEntry.getBridgeReference().getValue().firstIdentifierOf(Node.class);
 400         Optional<Node> optNode =
 401             IfmUtil.read(LogicalDatastoreType.OPERATIONAL, nodeIid,  dataBroker);
 402         if (optNode.isPresent()) {
 403             return optNode.get().getTerminationPoint();
 404         }
 405         return Collections.emptyList();
 406     }
 407
 408     // Cache Util methods
 409
 410     // Start: BridgeEntryCache
 411     public void addBridgeEntryToCache(Uint64 dpnId, BridgeEntry bridgeEntry) {
 412         bridgeEntryMap.put(dpnId, bridgeEntry);
 413     }
 414
 415     public void addBridgeEntryToCache(BridgeEntry bridgeEntry) {
 416         addBridgeEntryToCache(bridgeEntry.key().getDpid(), bridgeEntry);
 417     }
 418
 419     public void removeFromBridgeEntryCache(Uint64 dpnId) {
 420         bridgeEntryMap.remove(dpnId);
 421     }
 422
 423     public void removeFromBridgeEntryCache(BridgeEntry bridgeEntry) {
 424         removeFromBridgeEntryCache(bridgeEntry.key().getDpid());
 425     }
 426
 427     public BridgeEntry getBridgeEntryFromCache(Uint64 dpnId) {
 428         return bridgeEntryMap.get(dpnId);
 429     }
 430     // End: Bridge Entry Cache
 431
 432     //Start: BridgeRefEntry Cache
 433     public void addBridgeRefEntryToCache(Uint64 dpnId, BridgeRefEntry bridgeRefEntry) {
 434         bridgeRefEntryMap.put(dpnId, bridgeRefEntry);
 435     }
 436
 437     public void addBridgeRefEntryToCache(BridgeRefEntry bridgeRefEntry) {
 438         addBridgeRefEntryToCache(bridgeRefEntry.key().getDpid(), bridgeRefEntry);
 439     }
 440
 441     public void removeFromBridgeRefEntryCache(Uint64 dpnId) {
 442         bridgeRefEntryMap.remove(dpnId);
 443     }
 444
 445     public void removeFromBridgeRefEntryCache(BridgeRefEntry bridgeRefEntry) {
 446         removeFromBridgeRefEntryCache(bridgeRefEntry.key().getDpid());
 447     }
 448
 449     public BridgeRefEntry getBridgeRefEntryFromCache(Uint64 dpnId) {
 450         return bridgeRefEntryMap.get(dpnId);
 451     }
 452
 453     public Map getBridgeRefEntryMap() {
 454         return Collections.unmodifiableMap(bridgeRefEntryMap);
 455     }
 456 }