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