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