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