import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.idmanager.IdManager;
import org.opendaylight.vpnservice.AbstractDataChangeListener;
import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
-import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
-import org.opendaylight.vpnservice.mdsalutil.InstructionType;
+import org.opendaylight.vpnservice.mdsalutil.ActionType;
import org.opendaylight.vpnservice.mdsalutil.MatchFieldType;
import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.Pools;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPool;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPoolKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.id.pool.GeneratedIds;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.BaseIds;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfL2vlan;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfL3tunnel;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfMpls;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfStackedVlan;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.L3tunnel;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.Mpls;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.StackedVlan;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.TunnelTypeBase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.*;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
public class InterfaceManager extends AbstractDataChangeListener<Interface> implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceManager.class);
private ListenerRegistration<DataChangeListener> listenerRegistration;
return id;
}
- private InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> buildStateInterfaceId(String interfaceName) {
- //TODO Make this generic and move to AbstractDataChangeListener or Utils.
- InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> idBuilder =
- InstanceIdentifier.builder(InterfacesState.class)
- .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class,
- new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(interfaceName));
- InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id = idBuilder.build();
- return id;
- }
private void addInterface(final InstanceIdentifier<Interface> identifier,
final Interface interf) {
ncId = nodeConn.getId();
}
mapNcToInterfaceName.put(ncId, interf.getName());
- if(interf.getType().getClass().isInstance(L3tunnel.class)) {
+ if(interf.getType().isAssignableFrom(Tunnel.class)) {
NodeId nodeId = getNodeIdFromNodeConnectorId(ncId);
- IfL3tunnel l3Tunnel = interf.getAugmentation(IfL3tunnel.class);
- dbDpnEndpoints.put(nodeId, l3Tunnel.getLocalIp().getIpv4Address().getValue());
+ IfTunnel tunnel = interf.getAugmentation(IfTunnel.class);
+ dbDpnEndpoints.put(nodeId, tunnel.getTunnelSource().getIpv4Address().getValue());
LOG.trace("dbDpnEndpoints: {}",dbDpnEndpoints);
}
}
* if-index = interface-id
*/
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id =
- buildStateInterfaceId(interf.getName());
+ IfmUtil.buildStateInterfaceId(interf.getName());
Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> stateIf =
read(LogicalDatastoreType.OPERATIONAL, id);
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface stateIface;
ifaceBuilder.setOperStatus(getOperStatus(nodeConn));
ifaceBuilder.setIfIndex(getIfIndex(ifName)).setName(ifName).setType(interf.getType());
- ifaceBuilder.setKey(getStateInterfaceKeyFromName(ifName));
+ ifaceBuilder.setKey(IfmUtil.getStateInterfaceKeyFromName(ifName));
stateIface = ifaceBuilder.build();
LOG.trace("Adding stateIface {} and id {} to OPERATIONAL DS", stateIface, id);
asyncWrite(LogicalDatastoreType.OPERATIONAL, id, stateIface, DEFAULT_CALLBACK);
* TODO: Start-delete-me
*/
- InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
- InstanceIdentifier.builder(Pools.class).child(IdPool.class, new IdPoolKey("interfaces"));
- InstanceIdentifier<IdPool> id = idBuilder.build();
- Optional<IdPool> globalPool = read(LogicalDatastoreType.OPERATIONAL, id);
+ InstanceIdentifier<IdPool> id = IfmUtil.getPoolId(IfmConstants.IFM_IDPOOL_NAME);
+ Optional<IdPool> globalPool = read(LogicalDatastoreType.OPERATIONAL, id );
Long newIdValue = null;
if (globalPool.isPresent()) {
IdPool pool = globalPool.get();
}
}
- private org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey getStateInterfaceKeyFromName(
- String name) {
- return new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(name);
- }
-
private NodeConnector getNodeConnectorFromDataStore(Interface interf) {
NodeConnectorId ncId = interf.getAugmentation(BaseIds.class).getOfPortId();
//TODO: Replace with MDSAL Util method
private void delInterface(final InstanceIdentifier<Interface> identifier,
final Interface delInterface) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id =
- buildStateInterfaceId(delInterface.getName());
+ IfmUtil.buildStateInterfaceId(delInterface.getName());
Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> stateIf =
read(LogicalDatastoreType.OPERATIONAL, id);
if(stateIf.isPresent()) {
NodeConnectorId ncId = getNodeConnectorIdFromInterface(delInterface);
if(ncId != null) {
mapNcToInterfaceName.remove(ncId);
- if(delInterface.getType().getClass().isInstance(L3tunnel.class)) {
- Node node = getNodeFromDataStore(delInterface);
- if((node != null) &&(node.getNodeConnector().isEmpty())) {
- dbDpnEndpoints.remove(node.getId());
- }
+ if(delInterface.getType().isAssignableFrom(Tunnel.class)) {
+ NodeId nodeId = getNodeIdFromNodeConnectorId(ncId);
+ dbDpnEndpoints.remove(nodeId);
+ LOG.trace("dbDpnEndpoints: {}",dbDpnEndpoints);
}
}
}
if(nc != null) {
// Name doesn't change. Is it present in update?
mapNcToInterfaceName.put(nc.getId(), original.getName());
- if(interf.getType().getClass().isInstance(L3tunnel.class)) {
+ if(interf.getType().isAssignableFrom(Tunnel.class)) {
NodeId nodeId = getNodeIdFromNodeConnectorId(nc.getId());
- IfL3tunnel l3Tunnel = interf.getAugmentation(IfL3tunnel.class);
- dbDpnEndpoints.put(nodeId, l3Tunnel.getLocalIp().getIpv4Address().getValue());
+ IfTunnel tunnel = interf.getAugmentation(IfTunnel.class);
+ dbDpnEndpoints.put(nodeId, tunnel.getTunnelSource().getIpv4Address().getValue());
LOG.trace("dbEndpoints: {}",dbDpnEndpoints);
}
}
updateInterface(identifier, original, update);
}
- private <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
+ protected <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.put(datastoreType, path, data, true);
- Futures.addCallback(tx.submit(), callback);
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ tx.put(datastoreType, path, data, true);
+ Futures.addCallback(tx.submit(), callback);
}
- private <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
+ protected <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.merge(datastoreType, path, data, true);
- Futures.addCallback(tx.submit(), callback);
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ tx.merge(datastoreType, path, data, true);
+ Futures.addCallback(tx.submit(), callback);
}
- private <T extends DataObject> void asyncRemove(LogicalDatastoreType datastoreType,
+ protected <T extends DataObject> void asyncRemove(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, FutureCallback<Void> callback) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.delete(datastoreType, path);
- Futures.addCallback(tx.submit(), callback);
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ tx.delete(datastoreType, path);
+ Futures.addCallback(tx.submit(), callback);
}
void processPortAdd(NodeConnector port) {
NodeConnectorId portId = port.getId();
FlowCapableNodeConnector ofPort = port.getAugmentation(FlowCapableNodeConnector.class);
- LOG.debug("PortAdd: PortId { "+portId.getValue()+"} PortName {"+ofPort.getName()+"}");
+ LOG.debug("PortAdd: PortId { " + portId.getValue() + "} PortName {" + ofPort.getName() + "}");
String ifName = this.mapNcToInterfaceName.get(portId);
setInterfaceOperStatus(ifName, OperStatus.Up);
}
void processPortUpdate(NodeConnector oldPort, NodeConnector update) {
//TODO: Currently nothing to do here.
- LOG.trace("ifMap: {}, dpnMap: {}", mapNcToInterfaceName, dbDpnEndpoints);
}
void processPortDelete(NodeConnector port) {
private void setInterfaceOperStatus(String ifName, OperStatus opStatus) {
if (ifName != null) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id =
- buildStateInterfaceId(ifName);
+ IfmUtil.buildStateInterfaceId(ifName);
Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> stateIf =
read(LogicalDatastoreType.OPERATIONAL, id);
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface stateIface;
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder ifaceBuilder =
new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder();
if (stateIf.isPresent()) {
- stateIface = ifaceBuilder.setOperStatus(opStatus).build();
+ stateIface = ifaceBuilder.setOperStatus(opStatus).setKey(IfmUtil.getStateInterfaceKeyFromName(ifName)).build();
LOG.trace("Setting OperStatus for {} to {} in OPERATIONAL DS", ifName, opStatus);
asyncUpdate(LogicalDatastoreType.OPERATIONAL, id, stateIface, DEFAULT_CALLBACK);
}
return getPortNumForInterface(iface);
}
- long getDpnForInterface(String ifName) {
- Interface iface = getInterfaceByIfName(ifName);
+ Long getPortForInterface(Interface intrf) {
try {
- NodeConnector port = getNodeConnectorFromDataStore(iface);
- //TODO: This should be an MDSAL Util method
- return Long.parseLong(IfmUtil.getDpnFromNodeConnectorId(port.getId()));
+ NodeConnector port = getNodeConnectorFromDataStore(intrf);
+ NodeConnectorId id = null;
+ if(port == null) {
+ id = getNodeConnectorIdFromInterface(intrf);
+ } else {
+ id = port.getId();
+ }
+ String portNo = IfmUtil.getPortNoFromNodeConnectorId(id);
+ return Long.parseLong(portNo);
} catch (NullPointerException e) {
- LOG.error("OFPort for Interface {} not found", ifName);
+ LOG.error("Port for Interface {} not found", intrf.getName(), e);
}
return 0L;
}
- String getEndpointIpForDpn(long dpnId) {
+ public BigInteger getDpnForInterface(Interface intrf) {
+ try {
+ NodeConnector port = getNodeConnectorFromDataStore(intrf);
+ NodeConnectorId id = null;
+ if(port == null) {
+ id = getNodeConnectorIdFromInterface(intrf);
+ } else {
+ id = port.getId();
+ }
+ //TODO: This should be an MDSAL Util method
+ return new BigInteger(IfmUtil.getDpnFromNodeConnectorId(id));
+ } catch (NullPointerException e) {
+ LOG.error("dpn for Interface {} not found", intrf.getName(), e);
+ }
+ return BigInteger.ZERO;
+ }
+
+ BigInteger getDpnForInterface(String ifName) {
+ Interface iface = getInterfaceByIfName(ifName);
+ if(iface != null) {
+ return getDpnForInterface(iface);
+ }
+ LOG.error("Interface {} doesn't exist", ifName);
+ return BigInteger.ZERO;
+ }
+
+ String getEndpointIpForDpn(BigInteger dpnId) {
//TODO: This should be MDSAL Util function
NodeId dpnNodeId = IfmUtil.buildDpnNodeId(dpnId);
return dbDpnEndpoints.get(dpnNodeId);
}
- List<MatchInfo> getInterfaceIngressRule(String ifName){
+ List<MatchInfo> getInterfaceIngressRule(String ifName) {
Interface iface = getInterfaceByIfName(ifName);
List<MatchInfo> matches = new ArrayList<MatchInfo>();
Class<? extends InterfaceType> ifType = iface.getType();
- long dpn = this.getDpnForInterface(ifName);
+ BigInteger dpn = this.getDpnForInterface(ifName);
long portNo = this.getPortNumForInterface(iface).longValue();
- matches.add(new MatchInfo(MatchFieldType.in_port, new long[] {dpn, portNo}));
- if(ifType.getClass().isInstance(L2vlan.class)) {
+ matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[] {dpn, BigInteger.valueOf(portNo)}));
+
+ if (ifType.isInstance(L2vlan.class)) {
IfL2vlan vlanIface = iface.getAugmentation(IfL2vlan.class);
- matches.add(new MatchInfo(MatchFieldType.vlan_vid,
- new long[] {vlanIface.getVlanId().longValue()}));
- LOG.trace("L2Vlan: {}",vlanIface);
- } else if (ifType.getClass().isInstance(L3tunnel.class)) {
+ long vlanVid = vlanIface.getVlanId().getValue().longValue();
+ if (vlanVid != 0) {
+ matches.add(new MatchInfo(MatchFieldType.vlan_vid,
+ new long[] {vlanVid}));
+ LOG.trace("L2Vlan: {}",vlanIface);
+ }
+ } else if (ifType.isInstance(Tunnel.class)) {
//TODO: Handle different tunnel types
- IfL3tunnel ifL3Tunnel = iface.getAugmentation(IfL3tunnel.class);
- Class<? extends TunnelTypeBase> tunnType = ifL3Tunnel.getTunnelType();
- LOG.trace("L3Tunnel: {}",ifL3Tunnel);
- } else if (ifType.getClass().isInstance(StackedVlan.class)) {
+ IfTunnel ifTunnel = iface.getAugmentation(IfTunnel.class);
+ Class<? extends TunnelTypeBase> tunnType = ifTunnel.getTunnelInterfaceType();
+ LOG.trace("L3Tunnel: {}",ifTunnel);
+ } else if (ifType.isAssignableFrom(StackedVlan.class)) {
IfStackedVlan ifStackedVlan = iface.getAugmentation(IfStackedVlan.class);
LOG.trace("StackedVlan: {}",ifStackedVlan);
- } else if (ifType.getClass().isInstance(Mpls.class)) {
+ } else if (ifType.isAssignableFrom(Mpls.class)) {
IfMpls ifMpls = iface.getAugmentation(IfMpls.class);
LOG.trace("Mpls: {}",ifMpls);
}
return matches;
}
- public List<InstructionInfo> getInterfaceEgressActions(String ifName) {
+ public List<ActionInfo> getInterfaceEgressActions(String ifName) {
Interface iface = getInterfaceByIfName(ifName);
- List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
- List<ActionInfo> actionInfos = new ArrayList<ActionInfo>();
+ List<ActionInfo> listActionInfo = new ArrayList<ActionInfo>();
Class<? extends InterfaceType> ifType = iface.getType();
- long dpn = this.getDpnForInterface(ifName);
+ BigInteger dpn = this.getDpnForInterface(ifName);
long portNo = this.getPortNumForInterface(iface).longValue();
- instructions.add(new InstructionInfo(InstructionType.apply_actions,
- actionInfos));
- /*TODO: Refer getInterfaceIngressRules on how to get interface details
- for different types
- */
-
+ if (iface.isEnabled()) {
+
+ if(ifType.isAssignableFrom(L2vlan.class)) {
+ IfL2vlan vlanIface = iface.getAugmentation(IfL2vlan.class);
+ LOG.trace("L2Vlan: {}",vlanIface);
+ long vlanVid = (vlanIface == null) ? 0 : vlanIface.getVlanId().getValue().longValue();
+ if (vlanVid != 0) {
+ listActionInfo.add(new ActionInfo(ActionType.push_vlan, new String[] {}));
+ listActionInfo.add(new ActionInfo(ActionType.set_field_vlan_vid,
+ new String[] { Long.toString(vlanVid) }));
+ }
+ listActionInfo.add(new ActionInfo(ActionType.output, new String[] { Long.toString(portNo)}));
+
+ } else if (ifType.isAssignableFrom(Tunnel.class)) {
+ //TODO: Handle different tunnel types
+ IfTunnel ifTunnel = iface.getAugmentation(IfTunnel.class);
+ Class<? extends TunnelTypeBase> tunnType = ifTunnel.getTunnelInterfaceType();
+ LOG.trace("L3Tunnel: {}",ifTunnel);
+ //TODO: check switch_type and configure accordingly
+ listActionInfo.add(new ActionInfo(ActionType.output, new String[] { Long.toString(portNo)}));
+
+ } else if (ifType.isAssignableFrom(StackedVlan.class)) {
+ IfStackedVlan ifStackedVlan = iface.getAugmentation(IfStackedVlan.class);
+ LOG.trace("StackedVlan: {}",ifStackedVlan);
+ // TODO: TBD
+ } else if (ifType.isAssignableFrom(Mpls.class)) {
+ IfMpls ifMpls = iface.getAugmentation(IfMpls.class);
+ LOG.trace("Mpls: {}",ifMpls);
+ // TODO: TBD
+ }
+ }
+ return listActionInfo;
- return instructions;
}
private NodeId getNodeIdFromNodeConnectorId(NodeConnectorId ncId) {
} catch (Exception e) {
LOG.error("OFPort for Interface {} not found", iface.getName());
}
- return null;
+ return 0L;
}
}
Code Review / vpnservice.git / blobdiff