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