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