interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfaceManager.java

   1 /*
   2  * Copyright (c) 2015 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.vpnservice.interfacemgr;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.util.concurrent.FutureCallback;
  12 import com.google.common.util.concurrent.Futures;
  13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  14 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  15 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  16 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  17 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.idmanager.IdManager;
  20 import org.opendaylight.vpnservice.AbstractDataChangeListener;
  21 import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
  22 import org.opendaylight.vpnservice.mdsalutil.ActionType;
  23 import org.opendaylight.vpnservice.mdsalutil.MatchFieldType;
  24 import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInput;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInputBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdOutput;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPool;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.id.pool.GeneratedIds;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.*;
  46 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  47 import org.opendaylight.yangtools.yang.binding.DataObject;
  48 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  49 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  50 import org.opendaylight.yangtools.yang.common.RpcResult;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53
  54 import java.math.BigInteger;
  55 import java.util.ArrayList;
  56 import java.util.List;
  57 import java.util.Map;
  58 import java.util.concurrent.ConcurrentHashMap;
  59 import java.util.concurrent.ExecutionException;
  60 import java.util.concurrent.Future;
  61
  62 public class InterfaceManager extends AbstractDataChangeListener<Interface> implements AutoCloseable {
  63     private static final Logger LOG = LoggerFactory.getLogger(InterfaceManager.class);
  64     private ListenerRegistration<DataChangeListener> listenerRegistration;
  65     private final DataBroker broker;
  66     private final IdManager idManager;
  67     private final Map<NodeConnectorId, String> mapNcToInterfaceName = new ConcurrentHashMap<>();
  68     private final Map<NodeId, String> dbDpnEndpoints = new ConcurrentHashMap<>();
  69
  70     private static final FutureCallback<Void> DEFAULT_CALLBACK =
  71                     new FutureCallback<Void>() {
  72                         public void onSuccess(Void result) {
  73                             LOG.debug("Success in Datastore write operation");
  74                         }
  75
  76                         public void onFailure(Throwable error) {
  77                             LOG.error("Error in Datastore write operation", error);
  78                         }
  79                     };
  80
  81     public InterfaceManager(final DataBroker db, final IdManager idmgr) {
  82         super(Interface.class);
  83         broker = db;
  84         idManager = idmgr;
  85         registerListener(db);
  86     }
  87
  88     @Override
  89     public void close() throws Exception {
  90         if (listenerRegistration != null) {
  91             try {
  92                 listenerRegistration.close();
  93             } catch (final Exception e) {
  94                 LOG.error("Error when cleaning up DataChangeListener.", e);
  95             }
  96             listenerRegistration = null;
  97         }
  98         LOG.info("Interface Manager Closed");
  99     }
 100
 101     private void registerListener(final DataBroker db) {
 102         try {
 103             listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
 104                     getWildCardPath(), InterfaceManager.this, DataChangeScope.SUBTREE);
 105         } catch (final Exception e) {
 106             LOG.error("InterfaceManager DataChange listener registration fail!", e);
 107             throw new IllegalStateException("InterfaceManager registration Listener failed.", e);
 108         }
 109     }
 110
 111     @Override
 112     protected void add(final InstanceIdentifier<Interface> identifier,
 113             final Interface imgrInterface) {
 114         LOG.trace("Adding interface key: " + identifier + ", value=" + imgrInterface );
 115         addInterface(identifier, imgrInterface);
 116     }
 117
 118     private InstanceIdentifier<Interface> buildId(final InstanceIdentifier<Interface> identifier) {
 119         //TODO Make this generic and move to AbstractDataChangeListener or Utils.
 120         final InterfaceKey key = identifier.firstKeyOf(Interface.class, InterfaceKey.class);
 121         return buildId(key.getName());
 122     }
 123
 124     private InstanceIdentifier<Interface> buildId(String interfaceName) {
 125         //TODO Make this generic and move to AbstractDataChangeListener or Utils.
 126         InstanceIdentifierBuilder<Interface> idBuilder =
 127                 InstanceIdentifier.builder(Interfaces.class).child(Interface.class, new InterfaceKey(interfaceName));
 128         InstanceIdentifier<Interface> id = idBuilder.build();
 129         return id;
 130     }
 131
 132
 133     private void addInterface(final InstanceIdentifier<Interface> identifier,
 134                               final Interface interf) {
 135         NodeConnector nodeConn = getNodeConnectorFromDataStore(interf);
 136         NodeConnectorId ncId = null;
 137         updateInterfaceState(identifier, interf, nodeConn);
 138         if (nodeConn == null) {
 139             ncId = getNodeConnectorIdFromInterface(interf);
 140         } else {
 141             ncId = nodeConn.getId();
 142         }
 143         mapNcToInterfaceName.put(ncId, interf.getName());
 144         if(interf.getType().isAssignableFrom(Tunnel.class)) {
 145             NodeId nodeId = getNodeIdFromNodeConnectorId(ncId);
 146             IfTunnel tunnel = interf.getAugmentation(IfTunnel.class);
 147             dbDpnEndpoints.put(nodeId, tunnel.getTunnelSource().getIpv4Address().getValue());
 148             LOG.trace("dbDpnEndpoints: {}",dbDpnEndpoints);
 149         }
 150     }
 151
 152     private void updateInterfaceState(InstanceIdentifier<Interface> identifier,
 153                     Interface interf, NodeConnector nodeConn) {
 154         /* Update InterfaceState
 155          * 1. Get interfaces-state Identifier
 156          * 2. Add interface to interfaces-state/interface
 157          * 3. Get interface-id from id manager
 158          * 4. Update interface-state with following:
 159          *    admin-status = set to enable value
 160          *    oper-status = Down [?]
 161          *    if-index = interface-id
 162         */
 163         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id =
 164                         IfmUtil.buildStateInterfaceId(interf.getName());
 165         Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> stateIf =
 166                         read(LogicalDatastoreType.OPERATIONAL, id);
 167         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface stateIface;
 168         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder ifaceBuilder =
 169                         new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder();
 170         if(!stateIf.isPresent()) {
 171             // TODO: Get interface-id from IdManager
 172             String ifName = interf.getName();
 173             ifaceBuilder.setAdminStatus((interf.isEnabled()) ?  org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus.Up :
 174                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus.Down);
 175             ifaceBuilder.setOperStatus(getOperStatus(nodeConn));
 176
 177             ifaceBuilder.setIfIndex(getIfIndex(ifName)).setName(ifName).setType(interf.getType());
 178             ifaceBuilder.setKey(IfmUtil.getStateInterfaceKeyFromName(ifName));
 179             stateIface = ifaceBuilder.build();
 180             LOG.trace("Adding stateIface {} and id {} to OPERATIONAL DS", stateIface, id);
 181             asyncWrite(LogicalDatastoreType.OPERATIONAL, id, stateIface, DEFAULT_CALLBACK);
 182         } else {
 183             if(interf.isEnabled() != null) {
 184                 ifaceBuilder.setAdminStatus((interf.isEnabled()) ?  org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus.Up :
 185                     org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus.Down);
 186             }
 187             if(interf.getType() != null) {
 188                 ifaceBuilder.setType(interf.getType());
 189             }
 190             ifaceBuilder.setOperStatus(getOperStatus(nodeConn));
 191             stateIface = ifaceBuilder.build();
 192             LOG.trace("updating OPERATIONAL data store with stateIface {} and id {}", stateIface, id);
 193             asyncUpdate(LogicalDatastoreType.OPERATIONAL, id, stateIface, DEFAULT_CALLBACK);
 194         }
 195     }
 196
 197     private Integer getIfIndex(String ifName) {
 198         GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder()
 199         .setPoolName(IfmConstants.IFM_IDPOOL_NAME).setIdKey(ifName)
 200         .build();
 201         //TODO: Proper error handling once IdManager code is complete
 202         try {
 203             Future<RpcResult<GetUniqueIdOutput>> result = idManager.getUniqueId(getIdInput);
 204             RpcResult<GetUniqueIdOutput> rpcResult = result.get();
 205             return rpcResult.getResult().getIdValue().intValue();
 206         } catch (NullPointerException | InterruptedException | ExecutionException e) {
 207             LOG.trace("",e);
 208         }
 209         /* This currently returns null, so let us get it from IdManager DS
 210          * TODO: Start-delete-me
 211          */
 212
 213         InstanceIdentifier<IdPool> id = IfmUtil.getPoolId(IfmConstants.IFM_IDPOOL_NAME);
 214         Optional<IdPool> globalPool = read(LogicalDatastoreType.OPERATIONAL, id );
 215         Long newIdValue = null;
 216         if (globalPool.isPresent()) {
 217             IdPool pool = globalPool.get();
 218             List<GeneratedIds> generatedIds = pool.getGeneratedIds();
 219             if ((generatedIds != null) && !generatedIds.isEmpty()) {
 220                 for (GeneratedIds gen_id : generatedIds) {
 221                     if (gen_id.getIdKey().equals(ifName)) {
 222                         newIdValue = gen_id.getIdValue();
 223                         LOG.debug("Id {} found for interface %s ", newIdValue, ifName);
 224                         return newIdValue.intValue();
 225                     }
 226                 }
 227             }
 228         }
 229         //TODO: End-delete-me
 230         LOG.debug("Unable to get valid ifIndex for interface {}", ifName);
 231         return IfmConstants.DEFAULT_IFINDEX;
 232     }
 233
 234     private OperStatus getOperStatus(NodeConnector nodeConn) {
 235         LOG.trace("nodeConn is {}", nodeConn);
 236         if(nodeConn == null) {
 237             return OperStatus.Down;
 238         }else {
 239             return OperStatus.Up;
 240         }
 241     }
 242
 243     private NodeConnector getNodeConnectorFromDataStore(Interface interf) {
 244         NodeConnectorId ncId = interf.getAugmentation(BaseIds.class).getOfPortId();
 245         //TODO: Replace with MDSAL Util method
 246         NodeId nodeId = getNodeIdFromNodeConnectorId(ncId);
 247         InstanceIdentifier<NodeConnector> ncIdentifier = InstanceIdentifier.builder(Nodes.class)
 248                         .child(Node.class, new NodeKey(nodeId))
 249                         .child(NodeConnector.class, new NodeConnectorKey(ncId)).build();
 250
 251         Optional<NodeConnector> nc = read(LogicalDatastoreType.OPERATIONAL, ncIdentifier);
 252         if(nc.isPresent()) {
 253             NodeConnector nodeConn = nc.get();
 254             LOG.trace("nodeConnector: {}",nodeConn);
 255             return nodeConn;
 256         }
 257         return null;
 258     }
 259
 260     private NodeConnectorId getNodeConnectorIdFromInterface(Interface interf) {
 261         return interf.getAugmentation(BaseIds.class).getOfPortId();
 262     }
 263
 264     private void delInterface(final InstanceIdentifier<Interface> identifier,
 265                               final Interface delInterface) {
 266         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id =
 267                         IfmUtil.buildStateInterfaceId(delInterface.getName());
 268         Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> stateIf =
 269                         read(LogicalDatastoreType.OPERATIONAL, id);
 270         if(stateIf.isPresent()) {
 271             LOG.trace("deleting interfaces:state OPERATIONAL data store with id {}", id);
 272             asyncRemove(LogicalDatastoreType.OPERATIONAL, id, DEFAULT_CALLBACK);
 273             NodeConnectorId ncId = getNodeConnectorIdFromInterface(delInterface);
 274             if(ncId != null) {
 275                 mapNcToInterfaceName.remove(ncId);
 276                 if(delInterface.getType().isAssignableFrom(Tunnel.class)) {
 277                     NodeId nodeId = getNodeIdFromNodeConnectorId(ncId);
 278                     dbDpnEndpoints.remove(nodeId);
 279                     LOG.trace("dbDpnEndpoints: {}",dbDpnEndpoints);
 280                 }
 281             }
 282         }
 283     }
 284
 285     private Node getNodeFromDataStore(Interface interf) {
 286         NodeConnectorId ncId = interf.getAugmentation(BaseIds.class).getOfPortId();
 287         //TODO: Replace with MDSAL Util method
 288         NodeId nodeId = getNodeIdFromNodeConnectorId(ncId);
 289         InstanceIdentifier<Node> ncIdentifier = InstanceIdentifier.builder(Nodes.class)
 290                         .child(Node.class, new NodeKey(nodeId)).build();
 291
 292         Optional<Node> dpn = read(LogicalDatastoreType.OPERATIONAL, ncIdentifier);
 293         if(dpn.isPresent()) {
 294             Node node = dpn.get();
 295             LOG.trace("node: {}",node);
 296             return node;
 297         }
 298         return null;
 299     }
 300
 301     private void updateInterface(final InstanceIdentifier<Interface> identifier,
 302                               final Interface original, final Interface update) {
 303         InstanceIdentifier<Interface> id = buildId(identifier);
 304         Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
 305         if(port.isPresent()) {
 306             Interface interf = port.get();
 307             NodeConnector nc = getNodeConnectorFromDataStore(update);
 308             updateInterfaceState(identifier, update, nc);
 309             /*
 310              * Alternative is to get from interf and update map irrespective if NCID changed or not.
 311              */
 312             if(nc != null) {
 313                 // Name doesn't change. Is it present in update?
 314                 mapNcToInterfaceName.put(nc.getId(), original.getName());
 315                 if(interf.getType().isAssignableFrom(Tunnel.class)) {
 316                     NodeId nodeId = getNodeIdFromNodeConnectorId(nc.getId());
 317                     IfTunnel tunnel = interf.getAugmentation(IfTunnel.class);
 318                     dbDpnEndpoints.put(nodeId, tunnel.getTunnelSource().getIpv4Address().getValue());
 319                     LOG.trace("dbEndpoints: {}",dbDpnEndpoints);
 320                 }
 321             }
 322         }
 323     }
 324
 325     private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
 326             InstanceIdentifier<T> path) {
 327
 328         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
 329
 330         Optional<T> result = Optional.absent();
 331         try {
 332             result = tx.read(datastoreType, path).get();
 333         } catch (Exception e) {
 334             throw new RuntimeException(e);
 335         }
 336
 337         return result;
 338     }
 339
 340     private InstanceIdentifier<Interface> getWildCardPath() {
 341         return InstanceIdentifier.create(Interfaces.class).child(Interface.class);
 342     }
 343
 344     @Override
 345     protected void remove(InstanceIdentifier<Interface> identifier, Interface del) {
 346         LOG.trace("remove - key: " + identifier + ", value=" + del );
 347         delInterface(identifier, del);
 348     }
 349
 350     @Override
 351     protected void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
 352         LOG.trace("update - key: " + identifier + ", original=" + original + ", update=" + update );
 353         updateInterface(identifier, original, update);
 354     }
 355
 356     protected <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
 357                     InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 358         WriteTransaction tx = broker.newWriteOnlyTransaction();
 359         tx.put(datastoreType, path, data, true);
 360         Futures.addCallback(tx.submit(), callback);
 361     }
 362
 363     protected <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
 364                     InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 365         WriteTransaction tx = broker.newWriteOnlyTransaction();
 366         tx.merge(datastoreType, path, data, true);
 367         Futures.addCallback(tx.submit(), callback);
 368     }
 369
 370     protected <T extends DataObject> void asyncRemove(LogicalDatastoreType datastoreType,
 371                     InstanceIdentifier<T> path, FutureCallback<Void> callback) {
 372         WriteTransaction tx = broker.newWriteOnlyTransaction();
 373         tx.delete(datastoreType, path);
 374         Futures.addCallback(tx.submit(), callback);
 375     }
 376
 377     void processPortAdd(NodeConnector port) {
 378         NodeConnectorId portId = port.getId();
 379         FlowCapableNodeConnector ofPort = port.getAugmentation(FlowCapableNodeConnector.class);
 380         LOG.debug("PortAdd: PortId { " + portId.getValue() + "} PortName {" + ofPort.getName() + "}");
 381         String ifName = this.mapNcToInterfaceName.get(portId);
 382         setInterfaceOperStatus(ifName, OperStatus.Up);
 383     }
 384
 385     void processPortUpdate(NodeConnector oldPort, NodeConnector update) {
 386         //TODO: Currently nothing to do here.
 387     }
 388
 389     void processPortDelete(NodeConnector port) {
 390         NodeConnectorId portId = port.getId();
 391         FlowCapableNodeConnector ofPort = port.getAugmentation(FlowCapableNodeConnector.class);
 392         LOG.debug("PortDelete: PortId { "+portId.getValue()+"} PortName {"+ofPort.getName()+"}");
 393         String ifName = this.mapNcToInterfaceName.get(portId);
 394         setInterfaceOperStatus(ifName, OperStatus.Down);
 395     }
 396
 397     private void setInterfaceOperStatus(String ifName, OperStatus opStatus) {
 398         if (ifName != null) {
 399             InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id =
 400                             IfmUtil.buildStateInterfaceId(ifName);
 401             Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> stateIf =
 402                             read(LogicalDatastoreType.OPERATIONAL, id);
 403             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface stateIface;
 404             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder ifaceBuilder =
 405                             new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder();
 406             if (stateIf.isPresent()) {
 407                 stateIface = ifaceBuilder.setOperStatus(opStatus).setKey(IfmUtil.getStateInterfaceKeyFromName(ifName)).build();
 408                 LOG.trace("Setting OperStatus for {} to {} in OPERATIONAL DS", ifName, opStatus);
 409                 asyncUpdate(LogicalDatastoreType.OPERATIONAL, id, stateIface, DEFAULT_CALLBACK);
 410             }
 411         }
 412     }
 413
 414     private Interface getInterfaceByIfName(String ifName) {
 415         InstanceIdentifier<Interface> id = buildId(ifName);
 416         Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
 417         if(port.isPresent()) {
 418             return port.get();
 419         }
 420         return null;
 421     }
 422
 423     Long getPortForInterface(String ifName) {
 424         Interface iface = getInterfaceByIfName(ifName);
 425         return getPortNumForInterface(iface);
 426     }
 427
 428     Long getPortForInterface(Interface intrf) {
 429         try {
 430             NodeConnector port = getNodeConnectorFromDataStore(intrf);
 431             NodeConnectorId id = null;
 432             if(port == null) {
 433                 id = getNodeConnectorIdFromInterface(intrf);
 434             } else {
 435                 id = port.getId();
 436             }
 437             String portNo = IfmUtil.getPortNoFromNodeConnectorId(id);
 438             return Long.parseLong(portNo);
 439         } catch (NullPointerException e) {
 440             LOG.error("Port for Interface {} not found", intrf.getName(), e);
 441         }
 442         return 0L;
 443     }
 444
 445     public BigInteger getDpnForInterface(Interface intrf) {
 446         try {
 447             NodeConnector port = getNodeConnectorFromDataStore(intrf);
 448             NodeConnectorId id = null;
 449             if(port == null) {
 450                 id = getNodeConnectorIdFromInterface(intrf);
 451             } else {
 452                 id = port.getId();
 453             }
 454             //TODO: This should be an MDSAL Util method
 455             return new BigInteger(IfmUtil.getDpnFromNodeConnectorId(id));
 456         } catch (NullPointerException e) {
 457             LOG.error("dpn for Interface {} not found", intrf.getName(), e);
 458         }
 459         return BigInteger.ZERO;
 460     }
 461
 462     BigInteger getDpnForInterface(String ifName) {
 463         Interface iface = getInterfaceByIfName(ifName);
 464         if(iface != null) {
 465             return getDpnForInterface(iface);
 466         }
 467         LOG.error("Interface {} doesn't exist", ifName);
 468         return BigInteger.ZERO;
 469     }
 470
 471     String getEndpointIpForDpn(BigInteger dpnId) {
 472         //TODO: This should be MDSAL Util function
 473         NodeId dpnNodeId = IfmUtil.buildDpnNodeId(dpnId);
 474         return dbDpnEndpoints.get(dpnNodeId);
 475     }
 476
 477     List<MatchInfo> getInterfaceIngressRule(String ifName) {
 478         Interface iface = getInterfaceByIfName(ifName);
 479         List<MatchInfo> matches = new ArrayList<MatchInfo>();
 480         Class<? extends InterfaceType> ifType = iface.getType();
 481         BigInteger dpn = this.getDpnForInterface(ifName);
 482         long portNo = this.getPortNumForInterface(iface).longValue();
 483         matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[] {dpn, BigInteger.valueOf(portNo)}));
 484
 485         if (ifType.isInstance(L2vlan.class)) {
 486             IfL2vlan vlanIface = iface.getAugmentation(IfL2vlan.class);
 487             long vlanVid = vlanIface.getVlanId().getValue().longValue();
 488             if (vlanVid != 0) {
 489                 matches.add(new MatchInfo(MatchFieldType.vlan_vid,
 490                             new long[] {vlanVid}));
 491                 LOG.trace("L2Vlan: {}",vlanIface);
 492             }
 493         } else if (ifType.isInstance(Tunnel.class)) {
 494             //TODO: Handle different tunnel types
 495             IfTunnel ifTunnel = iface.getAugmentation(IfTunnel.class);
 496             Class<? extends TunnelTypeBase> tunnType = ifTunnel.getTunnelInterfaceType();
 497             LOG.trace("L3Tunnel: {}",ifTunnel);
 498         } else if (ifType.isAssignableFrom(StackedVlan.class)) {
 499             IfStackedVlan ifStackedVlan = iface.getAugmentation(IfStackedVlan.class);
 500             LOG.trace("StackedVlan: {}",ifStackedVlan);
 501         } else if (ifType.isAssignableFrom(Mpls.class)) {
 502             IfMpls ifMpls = iface.getAugmentation(IfMpls.class);
 503             LOG.trace("Mpls: {}",ifMpls);
 504         }
 505         return matches;
 506     }
 507
 508     public List<ActionInfo> getInterfaceEgressActions(String ifName) {
 509         Interface iface = getInterfaceByIfName(ifName);
 510
 511         List<ActionInfo> listActionInfo = new ArrayList<ActionInfo>();
 512         Class<? extends InterfaceType> ifType = iface.getType();
 513         BigInteger dpn = this.getDpnForInterface(ifName);
 514         long portNo = this.getPortNumForInterface(iface).longValue();
 515         if (iface.isEnabled()) {
 516
 517             if(ifType.isAssignableFrom(L2vlan.class)) {
 518                 IfL2vlan vlanIface = iface.getAugmentation(IfL2vlan.class);
 519                 LOG.trace("L2Vlan: {}",vlanIface);
 520                 long vlanVid = (vlanIface == null) ? 0 : vlanIface.getVlanId().getValue().longValue();
 521                 if (vlanVid != 0) {
 522                     listActionInfo.add(new ActionInfo(ActionType.push_vlan, new String[] {}));
 523                     listActionInfo.add(new ActionInfo(ActionType.set_field_vlan_vid,
 524                             new String[] { Long.toString(vlanVid) }));
 525                 }
 526                 listActionInfo.add(new ActionInfo(ActionType.output, new String[] { Long.toString(portNo)}));
 527
 528             } else if (ifType.isAssignableFrom(Tunnel.class)) {
 529                 //TODO: Handle different tunnel types
 530                 IfTunnel ifTunnel = iface.getAugmentation(IfTunnel.class);
 531                 Class<? extends TunnelTypeBase> tunnType = ifTunnel.getTunnelInterfaceType();
 532                 LOG.trace("L3Tunnel: {}",ifTunnel);
 533                 //TODO: check switch_type and configure accordingly
 534                 listActionInfo.add(new ActionInfo(ActionType.output, new String[] { Long.toString(portNo)}));
 535
 536             } else if (ifType.isAssignableFrom(StackedVlan.class)) {
 537                 IfStackedVlan ifStackedVlan = iface.getAugmentation(IfStackedVlan.class);
 538                 LOG.trace("StackedVlan: {}",ifStackedVlan);
 539                 // TODO: TBD
 540             } else if (ifType.isAssignableFrom(Mpls.class)) {
 541                 IfMpls ifMpls = iface.getAugmentation(IfMpls.class);
 542                 LOG.trace("Mpls: {}",ifMpls);
 543                 // TODO: TBD
 544             }
 545         }
 546         return listActionInfo;
 547
 548     }
 549
 550     private NodeId getNodeIdFromNodeConnectorId(NodeConnectorId ncId) {
 551         return new NodeId(ncId.getValue().substring(0,ncId.getValue().lastIndexOf(":")));
 552     }
 553
 554     private Long getPortNumForInterface(Interface iface) {
 555         try {
 556             NodeConnector port = getNodeConnectorFromDataStore(iface);
 557             FlowCapableNodeConnector ofPort = port.getAugmentation(FlowCapableNodeConnector.class);
 558             return ofPort.getPortNumber().getUint32();
 559         } catch (Exception e) {
 560             LOG.error("OFPort for Interface {} not found", iface.getName());
 561         }
 562         return 0L;
 563     }
 564
 565 }