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