2 * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
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
8 package org.opendaylight.vpnservice.interfacemgr;
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;
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;
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<>();
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");
85 public void onFailure(Throwable error) {
86 LOG.error("Error in Datastore write operation", error);
90 public InterfaceManager(final DataBroker db, final IdManager idmgr) {
91 super(Interface.class);
98 public void close() throws Exception {
99 if (listenerRegistration != null) {
101 listenerRegistration.close();
102 } catch (final Exception e) {
103 LOG.error("Error when cleaning up DataChangeListener.", e);
105 listenerRegistration = null;
107 LOG.info("Interface Manager Closed");
110 private void registerListener(final DataBroker db) {
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);
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);
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());
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();
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();
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);
159 ncId = nodeConn.getId();
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);
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
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));
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);
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);
205 if(interf.getType() != null) {
206 ifaceBuilder.setType(interf.getType());
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);
215 private Integer getIfIndex(String ifName) {
216 GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder()
217 .setPoolName(IfmConstants.IFM_IDPOOL_NAME).setIdKey(ifName)
219 //TODO: Proper error handling once IdManager code is complete
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) {
227 /* This currently returns null, so let us get it from IdManager DS
228 * TODO: Start-delete-me
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();
249 //TODO: End-delete-me
250 LOG.debug("Unable to get valid ifIndex for interface {}", ifName);
251 return IfmConstants.DEFAULT_IFINDEX;
254 private OperStatus getOperStatus(NodeConnector nodeConn) {
255 LOG.trace("nodeConn is {}", nodeConn);
256 if(nodeConn == null) {
257 return OperStatus.Down;
259 return OperStatus.Up;
263 private org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey getStateInterfaceKeyFromName(
265 return new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(name);
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();
276 Optional<NodeConnector> nc = read(LogicalDatastoreType.OPERATIONAL, ncIdentifier);
278 NodeConnector nodeConn = nc.get();
279 LOG.trace("nodeConnector: {}",nodeConn);
285 private NodeConnectorId getNodeConnectorIdFromInterface(Interface interf) {
286 return interf.getAugmentation(BaseIds.class).getOfPortId();
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);
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());
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();
318 Optional<Node> dpn = read(LogicalDatastoreType.OPERATIONAL, ncIdentifier);
319 if(dpn.isPresent()) {
320 Node node = dpn.get();
321 LOG.trace("node: {}",node);
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);
336 * Alternative is to get from interf and update map irrespective if NCID changed or not.
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);
351 private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
352 InstanceIdentifier<T> path) {
354 ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
356 Optional<T> result = Optional.absent();
358 result = tx.read(datastoreType, path).get();
359 } catch (Exception e) {
360 throw new RuntimeException(e);
366 private InstanceIdentifier<Interface> getWildCardPath() {
367 return InstanceIdentifier.create(Interfaces.class).child(Interface.class);
371 protected void remove(InstanceIdentifier<Interface> identifier, Interface del) {
372 LOG.trace("remove - key: " + identifier + ", value=" + del );
373 delInterface(identifier, del);
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);
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);
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);
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);
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);
411 void processPortUpdate(NodeConnector oldPort, NodeConnector update) {
412 //TODO: Currently nothing to do here.
413 LOG.trace("ifMap: {}, dpnMap: {}", mapNcToInterfaceName, dbDpnEndpoints);
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);
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);
441 private Interface getInterfaceByIfName(String ifName) {
442 InstanceIdentifier<Interface> id = buildId(ifName);
443 Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
444 if(port.isPresent()) {
450 Long getPortForInterface(String ifName) {
451 Interface iface = getInterfaceByIfName(ifName);
452 return getPortNumForInterface(iface);
455 long getDpnForInterface(String ifName) {
456 Interface iface = getInterfaceByIfName(ifName);
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);
467 String getEndpointIpForDpn(long dpnId) {
468 //TODO: This should be MDSAL Util function
469 NodeId dpnNodeId = IfmUtil.buildDpnNodeId(dpnId);
470 return dbDpnEndpoints.get(dpnNodeId);
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);
500 public List<InstructionInfo> getInterfaceEgressActions(String ifName) {
501 Interface iface = getInterfaceByIfName(ifName);
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,
510 /*TODO: Refer getInterfaceIngressRules on how to get interface details
518 private NodeId getNodeIdFromNodeConnectorId(NodeConnectorId ncId) {
519 return new NodeId(ncId.getValue().substring(0,ncId.getValue().lastIndexOf(":")));
522 private Long getPortNumForInterface(Interface iface) {
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());