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 com.google.common.base.Optional;
  11 import java.math.BigInteger;
  12 import java.util.List;
  13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  14 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  15 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  16 import org.opendaylight.genius.interfacemanager.IfmConstants;
  17 import org.opendaylight.genius.interfacemanager.IfmUtil;
  18 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeInterfaceInfo;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeRefInfo;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.IfIndexesInterfaceMap;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.InterfaceChildInfo;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.TunnelInstanceInterfaceMap;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceKey;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntryKey;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntry;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntryBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntryKey;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntry;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntryBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntryKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntry;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntryBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntryKey;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.tunnel.instance._interface.map.TunnelInstanceInterface;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.tunnel.instance._interface.map.TunnelInstanceInterfaceBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.tunnel.instance._interface.map.TunnelInstanceInterfaceKey;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
  49 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  50 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53
  54 public class InterfaceMetaUtils {
  55     private static final Logger LOG = LoggerFactory.getLogger(InterfaceMetaUtils.class);
  56     public static InstanceIdentifier<BridgeRefEntry> getBridgeRefEntryIdentifier(BridgeRefEntryKey bridgeRefEntryKey) {
  57         InstanceIdentifier.InstanceIdentifierBuilder<BridgeRefEntry> bridgeRefEntryInstanceIdentifierBuilder =
  58                 InstanceIdentifier.builder(BridgeRefInfo.class)
  59                         .child(BridgeRefEntry.class, bridgeRefEntryKey);
  60         return bridgeRefEntryInstanceIdentifierBuilder.build();
  61     }
  62
  63     public static BridgeRefEntry getBridgeRefEntryFromOperDS(InstanceIdentifier<BridgeRefEntry> dpnBridgeEntryIid,
  64                                                              DataBroker dataBroker) {
  65         Optional<BridgeRefEntry> bridgeRefEntryOptional =
  66                 IfmUtil.read(LogicalDatastoreType.OPERATIONAL, dpnBridgeEntryIid, dataBroker);
  67         if (!bridgeRefEntryOptional.isPresent()) {
  68             return null;
  69         }
  70         return bridgeRefEntryOptional.get();
  71     }
  72
  73     public static OvsdbBridgeRef getBridgeRefEntryFromOperDS(BigInteger dpId,
  74                                                              DataBroker dataBroker) {
  75         BridgeRefEntryKey bridgeRefEntryKey = new BridgeRefEntryKey(dpId);
  76         InstanceIdentifier<BridgeRefEntry> bridgeRefEntryIid =
  77                 InterfaceMetaUtils.getBridgeRefEntryIdentifier(bridgeRefEntryKey);
  78         BridgeRefEntry bridgeRefEntry = getBridgeRefEntryFromOperDS(bridgeRefEntryIid, dataBroker);
  79         if(bridgeRefEntry == null){
  80             // bridge ref entry will be null if the bridge is disconnected from controller.
  81             // In that case, fetch bridge reference from bridge interface entry config DS
  82             BridgeEntry bridgeEntry = getBridgeEntryFromConfigDS(dpId, dataBroker);
  83             if(bridgeEntry == null){
  84                 return null;
  85             }
  86             return  bridgeEntry.getBridgeReference();
  87         }
  88         return bridgeRefEntry.getBridgeReference();
  89     }
  90
  91     public static BridgeRefEntry getBridgeReferenceForInterface(Interface interfaceInfo,
  92                                                                 DataBroker dataBroker) {
  93         ParentRefs parentRefs = interfaceInfo.getAugmentation(ParentRefs.class);
  94         BigInteger dpn = parentRefs.getDatapathNodeIdentifier();
  95         BridgeRefEntryKey BridgeRefEntryKey = new BridgeRefEntryKey(dpn);
  96         InstanceIdentifier<BridgeRefEntry> dpnBridgeEntryIid = getBridgeRefEntryIdentifier(BridgeRefEntryKey);
  97         BridgeRefEntry bridgeRefEntry = getBridgeRefEntryFromOperDS(dpnBridgeEntryIid, dataBroker);
  98         return bridgeRefEntry;
  99     }
 100
 101     public static boolean bridgeExists(BridgeRefEntry bridgeRefEntry,
 102                                        DataBroker dataBroker) {
 103         if (bridgeRefEntry != null && bridgeRefEntry.getBridgeReference() != null) {
 104             InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid =
 105                     (InstanceIdentifier<OvsdbBridgeAugmentation>) bridgeRefEntry.getBridgeReference().getValue();
 106             Optional<OvsdbBridgeAugmentation> bridgeNodeOptional =
 107                     IfmUtil.read(LogicalDatastoreType.OPERATIONAL, bridgeIid, dataBroker);
 108             if (bridgeNodeOptional.isPresent()) {
 109                 return true;
 110             }
 111         }
 112         return false;
 113     }
 114     public static InstanceIdentifier<BridgeEntry> getBridgeEntryIdentifier(BridgeEntryKey bridgeEntryKey) {
 115         InstanceIdentifier.InstanceIdentifierBuilder<BridgeEntry> bridgeEntryIdBuilder =
 116                 InstanceIdentifier.builder(BridgeInterfaceInfo.class).child(BridgeEntry.class, bridgeEntryKey);
 117         return bridgeEntryIdBuilder.build();
 118     }
 119
 120     public static BridgeEntry getBridgeEntryFromConfigDS(BigInteger dpnId,
 121                                                          DataBroker dataBroker) {
 122         BridgeEntryKey bridgeEntryKey = new BridgeEntryKey(dpnId);
 123         InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier =
 124                 InterfaceMetaUtils.getBridgeEntryIdentifier(bridgeEntryKey);
 125         LOG.debug("Trying to retrieve bridge entry from config for Id: {}", bridgeEntryInstanceIdentifier);
 126         return getBridgeEntryFromConfigDS(bridgeEntryInstanceIdentifier,
 127                 dataBroker);
 128     }
 129
 130     public static BridgeEntry getBridgeEntryFromConfigDS(InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier,
 131                                                          DataBroker dataBroker) {
 132         Optional<BridgeEntry> bridgeEntryOptional =
 133                 IfmUtil.read(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier, dataBroker);
 134         if (!bridgeEntryOptional.isPresent()) {
 135             return null;
 136         }
 137         return bridgeEntryOptional.get();
 138     }
 139
 140     public static InstanceIdentifier<BridgeInterfaceEntry> getBridgeInterfaceEntryIdentifier(BridgeEntryKey bridgeEntryKey,
 141                                                                                              BridgeInterfaceEntryKey bridgeInterfaceEntryKey) {
 142         return InstanceIdentifier.builder(BridgeInterfaceInfo.class)
 143                 .child(BridgeEntry.class, bridgeEntryKey)
 144                 .child(BridgeInterfaceEntry.class, bridgeInterfaceEntryKey).build();
 145
 146     }
 147
 148     public static void createBridgeInterfaceEntryInConfigDS(BigInteger dpId,
 149                                                             String childInterface,
 150                                                             WriteTransaction t) {
 151         BridgeEntryKey bridgeEntryKey = new BridgeEntryKey(dpId);
 152         BridgeInterfaceEntryKey bridgeInterfaceEntryKey = new BridgeInterfaceEntryKey(childInterface);
 153         InstanceIdentifier<BridgeInterfaceEntry> bridgeInterfaceEntryIid =
 154                 InterfaceMetaUtils.getBridgeInterfaceEntryIdentifier(bridgeEntryKey, bridgeInterfaceEntryKey);
 155         BridgeInterfaceEntryBuilder entryBuilder = new BridgeInterfaceEntryBuilder().setKey(bridgeInterfaceEntryKey)
 156                 .setInterfaceName(childInterface);
 157         t.put(LogicalDatastoreType.CONFIGURATION, bridgeInterfaceEntryIid, entryBuilder.build(), true);
 158     }
 159
 160     public static InstanceIdentifier<InterfaceParentEntry> getInterfaceParentEntryIdentifier(
 161             InterfaceParentEntryKey interfaceParentEntryKey) {
 162         InstanceIdentifier.InstanceIdentifierBuilder<InterfaceParentEntry> intfIdBuilder =
 163                 InstanceIdentifier.builder(InterfaceChildInfo.class)
 164                         .child(InterfaceParentEntry.class, interfaceParentEntryKey);
 165         return intfIdBuilder.build();
 166     }
 167
 168     public static InstanceIdentifier<InterfaceChildEntry> getInterfaceChildEntryIdentifier(
 169             InterfaceParentEntryKey interfaceParentEntryKey, InterfaceChildEntryKey interfaceChildEntryKey) {
 170         InstanceIdentifier.InstanceIdentifierBuilder<InterfaceChildEntry> intfIdBuilder =
 171                 InstanceIdentifier.builder(InterfaceChildInfo.class)
 172                         .child(InterfaceParentEntry.class, interfaceParentEntryKey)
 173                         .child(InterfaceChildEntry.class, interfaceChildEntryKey);
 174         return intfIdBuilder.build();
 175     }
 176
 177     public static InterfaceParentEntry getInterfaceParentEntryFromConfigDS(
 178             String interfaceName, DataBroker dataBroker) {
 179         InterfaceParentEntryKey interfaceParentEntryKey = new InterfaceParentEntryKey(interfaceName);
 180         InterfaceParentEntry interfaceParentEntry =
 181                 InterfaceMetaUtils.getInterfaceParentEntryFromConfigDS(interfaceParentEntryKey, dataBroker);
 182         return interfaceParentEntry;
 183     }
 184
 185     public static InterfaceParentEntry getInterfaceParentEntryFromConfigDS(
 186             InterfaceParentEntryKey interfaceParentEntryKey, DataBroker dataBroker) {
 187         InstanceIdentifier<InterfaceParentEntry> intfParentIid =
 188                 getInterfaceParentEntryIdentifier(interfaceParentEntryKey);
 189
 190         return getInterfaceParentEntryFromConfigDS(intfParentIid, dataBroker);
 191     }
 192
 193     public static InterfaceParentEntry getInterfaceParentEntryFromConfigDS(
 194             InstanceIdentifier<InterfaceParentEntry> intfId, DataBroker dataBroker) {
 195         Optional<InterfaceParentEntry> interfaceParentEntryOptional =
 196                 IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfId, dataBroker);
 197         if (!interfaceParentEntryOptional.isPresent()) {
 198             return null;
 199         }
 200         return interfaceParentEntryOptional.get();
 201     }
 202
 203     public static InterfaceChildEntry getInterfaceChildEntryFromConfigDS(InterfaceParentEntryKey interfaceParentEntryKey,
 204                                                                          InterfaceChildEntryKey interfaceChildEntryKey,
 205                                                                          DataBroker dataBroker) {
 206         InstanceIdentifier<InterfaceChildEntry> intfChildIid =
 207                 getInterfaceChildEntryIdentifier(interfaceParentEntryKey, interfaceChildEntryKey);
 208
 209         return getInterfaceChildEntryFromConfigDS(intfChildIid, dataBroker);
 210     }
 211
 212     public static InterfaceChildEntry getInterfaceChildEntryFromConfigDS(
 213             InstanceIdentifier<InterfaceChildEntry> intfChildIid, DataBroker dataBroker) {
 214         Optional<InterfaceChildEntry> interfaceChildEntryOptional =
 215                 IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfChildIid, dataBroker);
 216         if (!interfaceChildEntryOptional.isPresent()) {
 217             return null;
 218         }
 219         return interfaceChildEntryOptional.get();
 220     }
 221
 222     public static void createLportTagInterfaceMap(WriteTransaction t, String infName, Integer ifIndex) {
 223         LOG.debug("creating lport tag to interface map for {}",infName);
 224         InstanceIdentifier<IfIndexInterface> id = InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class, new IfIndexInterfaceKey(ifIndex)).build();
 225         IfIndexInterface ifIndexInterface = new IfIndexInterfaceBuilder().setIfIndex(ifIndex).setKey(new IfIndexInterfaceKey(ifIndex)).setInterfaceName(infName).build();
 226         t.put(LogicalDatastoreType.OPERATIONAL, id, ifIndexInterface, true);
 227     }
 228
 229     public static void removeLportTagInterfaceMap(IdManagerService idManager, WriteTransaction t, String infName) {
 230         // workaround to get the id to remove from lport tag interface map
 231         Integer ifIndex = IfmUtil.allocateId(idManager, IfmConstants.IFM_IDPOOL_NAME, infName);
 232         IfmUtil.releaseId(idManager, IfmConstants.IFM_IDPOOL_NAME, infName);
 233         LOG.debug("removing lport tag to interface map for {}",infName);
 234         InstanceIdentifier<IfIndexInterface> id = InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class, new IfIndexInterfaceKey(ifIndex)).build();
 235         t.delete(LogicalDatastoreType.OPERATIONAL, id);
 236     }
 237
 238     public static void addBridgeRefToBridgeInterfaceEntry(BigInteger dpId, OvsdbBridgeRef ovsdbBridgeRef, WriteTransaction t){
 239         BridgeEntryKey bridgeEntryKey = new BridgeEntryKey(dpId);
 240         InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier = getBridgeEntryIdentifier(bridgeEntryKey);
 241
 242         BridgeEntryBuilder bridgeEntryBuilder = new BridgeEntryBuilder().setKey(bridgeEntryKey).setBridgeReference(ovsdbBridgeRef);
 243         t.merge(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier, bridgeEntryBuilder.build(), true);
 244     }
 245
 246     public static void createBridgeRefEntry(BigInteger dpnId, InstanceIdentifier<?> bridgeIid,
 247                                             WriteTransaction tx){
 248         LOG.debug("Creating bridge ref entry for dpn: {} bridge: {}",
 249                 dpnId, bridgeIid);
 250         BridgeRefEntryKey bridgeRefEntryKey = new BridgeRefEntryKey(dpnId);
 251         InstanceIdentifier<BridgeRefEntry> bridgeEntryId =
 252                 InterfaceMetaUtils.getBridgeRefEntryIdentifier(bridgeRefEntryKey);
 253         BridgeRefEntryBuilder tunnelDpnBridgeEntryBuilder =
 254                 new BridgeRefEntryBuilder().setKey(bridgeRefEntryKey).setDpid(dpnId)
 255                         .setBridgeReference(new OvsdbBridgeRef(bridgeIid));
 256         tx.put(LogicalDatastoreType.OPERATIONAL, bridgeEntryId, tunnelDpnBridgeEntryBuilder.build(), true);
 257     }
 258     public static void deleteBridgeRefEntry(BigInteger dpnId,
 259                                             WriteTransaction tx) {
 260         LOG.debug("Deleting bridge ref entry for dpn: {}",
 261                 dpnId);
 262         BridgeRefEntryKey bridgeRefEntryKey = new BridgeRefEntryKey(dpnId);
 263         InstanceIdentifier<BridgeRefEntry> bridgeEntryId =
 264                 InterfaceMetaUtils.getBridgeRefEntryIdentifier(bridgeRefEntryKey);
 265         tx.delete(LogicalDatastoreType.OPERATIONAL, bridgeEntryId);
 266     }
 267
 268     public static void createTunnelToInterfaceMap(String tunnelInstanceId,
 269                                                   String infName,
 270                                                   WriteTransaction transaction) {
 271         LOG.debug("creating tunnel instance identifier to interface map for {}",infName);
 272         InstanceIdentifier<TunnelInstanceInterface> id = InstanceIdentifier.builder(TunnelInstanceInterfaceMap.class).
 273                 child(TunnelInstanceInterface.class, new TunnelInstanceInterfaceKey(tunnelInstanceId)).build();
 274         TunnelInstanceInterface tunnelInstanceInterface = new TunnelInstanceInterfaceBuilder().
 275                 setTunnelInstanceIdentifier(tunnelInstanceId).setKey(new TunnelInstanceInterfaceKey(tunnelInstanceId)).setInterfaceName(infName).build();
 276         transaction.put(LogicalDatastoreType.OPERATIONAL, id, tunnelInstanceInterface, true);
 277
 278     }
 279
 280     public static void createTunnelToInterfaceMap(String infName,InstanceIdentifier<Node> nodeId,
 281                                                   WriteTransaction transaction,
 282                                                   IfTunnel ifTunnel){
 283         InstanceIdentifier<Tunnels> tunnelsInstanceIdentifier = org.opendaylight.genius.interfacemanager.renderer.hwvtep.utilities.SouthboundUtils.
 284                 createTunnelsInstanceIdentifier(nodeId,
 285                         ifTunnel.getTunnelSource(), ifTunnel.getTunnelDestination());
 286         createTunnelToInterfaceMap(tunnelsInstanceIdentifier.toString(), infName, transaction);
 287     }
 288
 289     public static void removeTunnelToInterfaceMap(InstanceIdentifier<Node> nodeId,
 290                                                   WriteTransaction transaction,
 291                                                   IfTunnel ifTunnel){
 292         InstanceIdentifier<Tunnels> tunnelsInstanceIdentifier = org.opendaylight.genius.interfacemanager.renderer.hwvtep.utilities.SouthboundUtils.
 293                 createTunnelsInstanceIdentifier(nodeId,
 294                         ifTunnel.getTunnelSource(), ifTunnel.getTunnelDestination());
 295         transaction.delete(LogicalDatastoreType.OPERATIONAL, tunnelsInstanceIdentifier);
 296     }
 297
 298     public static String getInterfaceForTunnelInstanceIdentifier(String tunnelInstanceId,
 299                                                                  DataBroker dataBroker) {
 300         InstanceIdentifier<TunnelInstanceInterface> id = InstanceIdentifier.builder(TunnelInstanceInterfaceMap.class).
 301                 child(TunnelInstanceInterface.class, new TunnelInstanceInterfaceKey(tunnelInstanceId)).build();
 302         Optional<TunnelInstanceInterface> tunnelInstanceInterfaceOptional = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, dataBroker);
 303         if(tunnelInstanceInterfaceOptional.isPresent()){
 304             return tunnelInstanceInterfaceOptional.get().getInterfaceName();
 305         }
 306         return null;
 307     }
 308
 309     public static void deleteBridgeInterfaceEntry(BridgeEntryKey bridgeEntryKey, List<BridgeInterfaceEntry> bridgeInterfaceEntries,
 310                                                   InstanceIdentifier<BridgeEntry> bridgeEntryIid,
 311                                                   WriteTransaction transaction, String interfaceName){
 312         BridgeInterfaceEntryKey bridgeInterfaceEntryKey =
 313                 new BridgeInterfaceEntryKey(interfaceName);
 314         InstanceIdentifier<BridgeInterfaceEntry> bridgeInterfaceEntryIid =
 315                 InterfaceMetaUtils.getBridgeInterfaceEntryIdentifier(bridgeEntryKey,
 316                         bridgeInterfaceEntryKey);
 317         transaction.delete(LogicalDatastoreType.CONFIGURATION, bridgeInterfaceEntryIid);
 318
 319         if (bridgeInterfaceEntries.size() <= 1) {
 320             transaction.delete(LogicalDatastoreType.CONFIGURATION, bridgeEntryIid);
 321         }
 322     }
 323 }