package org.opendaylight.vpnservice.interfacemgr.interfaces;
import java.util.List;
-import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
+import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
public interface IInterfaceManager {
public long getDpnForInterface(String ifName);
public String getEndpointIpForDpn(long dpnId);
public List<MatchInfo> getInterfaceIngressRule(String ifName);
- public List<InstructionInfo> getInterfaceEgressActions(String ifName);
+ public List<ActionInfo> getInterfaceEgressActions(String ifName);
}
\ No newline at end of file
*/
package org.opendaylight.vpnservice.interfacemgr;
+
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;
return id;
}
- private InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> buildStateInterfaceId(String interfaceName) {
+ 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)
+ 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 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);
long portNo = this.getPortNumForInterface(iface).longValue();
matches.add(new MatchInfo(MatchFieldType.in_port, new long[] {dpn, portNo}));
- if(ifType.getClass().isInstance(L2vlan.class)) {
+ 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().longValue();
+ if (vlanVid != 0) {
+ matches.add(new MatchInfo(MatchFieldType.vlan_vid,
+ new long[] {vlanVid}));
+ LOG.trace("L2Vlan: {}",vlanIface);
+ }
+ } else if (ifType.isInstance(L3tunnel.class)) {
//TODO: Handle different tunnel types
IfL3tunnel ifL3Tunnel = iface.getAugmentation(IfL3tunnel.class);
Class<? extends TunnelTypeBase> tunnType = ifL3Tunnel.getTunnelType();
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);
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.isInstance(L2vlan.class)) {
+ IfL2vlan vlanIface = iface.getAugmentation(IfL2vlan.class);
+ long vlanVid = vlanIface.getVlanId();
+ LOG.trace("L2Vlan: {}",vlanIface);
+ 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.isInstance(L3tunnel.class)) {
+ //TODO: Handle different tunnel types
+ IfL3tunnel ifL3Tunnel = iface.getAugmentation(IfL3tunnel.class);
+ Class<? extends TunnelTypeBase> tunnType = ifL3Tunnel.getTunnelType();
+ LOG.trace("L3Tunnel: {}",ifL3Tunnel);
+ //TODO: check switch_type and configure accordingly
+ listActionInfo.add(new ActionInfo(ActionType.output, new String[] { Long.toString(portNo)}));
+
+ } else if (ifType.isInstance(StackedVlan.class)) {
+ IfStackedVlan ifStackedVlan = iface.getAugmentation(IfStackedVlan.class);
+ LOG.trace("StackedVlan: {}",ifStackedVlan);
+ // TBD
+ } else if (ifType.isInstance(Mpls.class)) {
+ IfMpls ifMpls = iface.getAugmentation(IfMpls.class);
+ LOG.trace("Mpls: {}",ifMpls);
+ // TBD
+ }
+ }
+ return listActionInfo;
- return instructions;
}
private NodeId getNodeIdFromNodeConnectorId(NodeConnectorId ncId) {
package org.opendaylight.vpnservice.interfacemgr;
import java.util.concurrent.ExecutionException;
-
import java.math.BigInteger;
import java.util.List;
import java.util.concurrent.Future;
+import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
+import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
}
@Override
- public List<InstructionInfo> getInterfaceEgressActions(String ifName) {
+ public List<ActionInfo> getInterfaceEgressActions(String ifName) {
return interfaceManager.getInterfaceEgressActions(ifName);
}
}
<artifactId>interfacemgr-api</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.vpnservice</groupId>
+ <artifactId>idmanager-api</artifactId>
+ <version>0.0.1-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.vpnservice</groupId>
+ <artifactId>idmanager-impl</artifactId>
+ <version>0.0.1-SNAPSHOT</version>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>nexthopmgr-api</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>mdsalutil-api</artifactId>
+ <version>${project.version}</version>
+ </dependency>
<!-- Testing Dependencies -->
<dependency>
<required-capabilities>
<capability>urn:opendaylight:params:xml:ns:yang:nexthopmgr:impl?module=nexthopmgr-impl&revision=2015-03-25</capability>
<capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding?module=opendaylight-md-sal-binding&revision=2013-10-28</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:mdsalutil:api?module=odl-mdsalutil&revision=2015-04-10</capability>
+ <capability>urn:opendaylight:vpnservice:interfacemgr?module=odl-interface&revision=2015-03-31</capability>
</required-capabilities>
<configuration>
<type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
<name>binding-osgi-broker</name>
</broker>
+ <mdsalutil>
+ <type xmlns:mdsalutil="urn:opendaylight:params:xml:ns:yang:mdsalutil:api">mdsalutil:odl-mdsalutil</type>
+ <name>mdsalutil-service</name>
+ </mdsalutil>
+ <odlinterface>
+ <type xmlns:odlif="urn:opendaylight:vpnservice:interfacemgr">odlif:odl-interface</type>
+ <name>interfacemgr-service</name>
+ </odlinterface>
</module>
</modules>
</data>
package org.opendaylight.vpnservice.nexthopmgr;
-import com.google.common.base.Optional;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
import java.util.concurrent.Future;
+
+import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.FutureCallback;
+
+//import org.opendaylight.controller.netconf.confignetconfconnector.mapping.rpc.Rpcs;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
-
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstance1;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.*;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.*;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.tunnelnexthops.*;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.vpnnexthops.*;
+import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
+import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
+import org.opendaylight.vpnservice.mdsalutil.ActionType;
+import org.opendaylight.vpnservice.mdsalutil.BucketInfo;
+import org.opendaylight.vpnservice.mdsalutil.GroupEntity;
+import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
+import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.idmanager.IdManager;
+
+import java.util.concurrent.ExecutionException;
+
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class NexthopManager implements L3nexthopService, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(NexthopManager.class);
private final DataBroker broker;
+ private IMdsalApiManager mdsalManager;
+ private IInterfaceManager interfaceManager;
+ private IdManager idManager;
private static final FutureCallback<Void> DEFAULT_CALLBACK =
new FutureCallback<Void>() {
* @param db - dataBroker reference
*/
public NexthopManager(final DataBroker db) {
- // create nexhhop ID pool
- // getIdManager.createIdPool("nextHopGroupIdPool", 10000, 100000);
broker = db;
+ createNexthopPointerPool();
}
-
@Override
public void close() throws Exception {
LOG.info("NextHop Manager Closed");
}
+ public void setInterfaceManager(IInterfaceManager ifManager) {
+ this.interfaceManager = ifManager;
+ }
- public void createLocalNextHop(String ifName, String vpnName, String ipAddress)
- {
- String nhKey = new String("nexthop." + vpnName + ipAddress);
- int groupId = 1;//getIdManager().getUniqueId("nextHopGroupIdPool", nhKey);
+ public void setMdsalManager(IMdsalApiManager mdsalManager) {
+ this.mdsalManager = mdsalManager;
+ }
- long vpnId = getVpnId(vpnName);
- VpnNexthop nexthop = getVpnNexthop(vpnId, ipAddress);
- if (nexthop == null) {
+ public void setIdManager(IdManager idManager) {
+ this.idManager = idManager;
+ }
- /* List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
- List<ActionInfo> listActionInfo = interfacemgr.getEgressGroupActions(ifName);
- BucketInfo bucket = new BucketInfo(listActionInfo);
- // MAC re-write??
- listBucketInfo.add(bucket);
- GroupEntity groupEntity = MDSALUtil.buildGroupEntity
- (dpId, groupId, IPAddress, GroupTypes.GroupIndirect, listBucketInfo);
- getMdsalApiManager().installGroup(groupEntity, objTransaction???);
- */
+ private void createNexthopPointerPool() {
+ CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
+ .setPoolName("nextHopPointerPool")
+ .setIdStart(1L)
+ .setPoolSize(new BigInteger("65535"))
+ .build();
+ //TODO: Error handling
+ Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+// try {
+// LOG.info("Result2: {}",result.get());
+// } catch (InterruptedException | ExecutionException e) {
+// // TODO Auto-generated catch block
+// LOG.error("Error in result.get");
+// }
- //update MD-SAL DS
- addVpnNexthopToDS(vpnId, ipAddress, groupId);
- } else {
- //check update
- }
}
+
private long getVpnId(String vpnName) {
InstanceIdentifierBuilder<VpnInstance> idBuilder = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName));
InstanceIdentifier<VpnInstance1> idx = id.augmentation(VpnInstance1.class);
Optional<VpnInstance1> vpn = read(LogicalDatastoreType.CONFIGURATION, idx);
- if (vpn.isPresent()) return vpn.get().getVpnId();
- else return 0;
+ if (vpn.isPresent()) {
+ return vpn.get().getVpnId();
+ } else {
+ return 0;
+ }
}
private long getDpnId(String ifName) {
- return 1;
+ String[] fields = ifName.split(":");
+ long dpn = Integer.parseInt(fields[1]);
+ return dpn;
}
- public void createRemoteNextHop(String ifName, String ipAddress)
- {
+ private int createNextHopPointer(String nexthopKey) {
+ GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder()
+ .setPoolName("nextHopPointerPool").setIdKey(nexthopKey)
+ .build();
+ //TODO: Proper error handling once IdManager code is complete
+ try {
+ Future<RpcResult<GetUniqueIdOutput>> result = idManager.getUniqueId(getIdInput);
+ RpcResult<GetUniqueIdOutput> rpcResult = result.get();
+ return rpcResult.getResult().getIdValue().intValue();
+ } catch (NullPointerException | InterruptedException | ExecutionException e) {
+ LOG.trace("",e);
+ }
+ return 0;
+ }
+
+ public void createLocalNextHop(String ifName, String vpnName, String ipAddress, String macAddress) {
+ String nhKey = new String("nexthop." + vpnName + ipAddress);
+ int groupId = createNextHopPointer(nhKey);
+
+ long vpnId = getVpnId(vpnName);
+ long dpnId = interfaceManager.getDpnForInterface(ifName);
+ VpnNexthop nexthop = getVpnNexthop(vpnId, ipAddress);
+ if (nexthop == null) {
+ List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
+ List<ActionInfo> listActionInfo = interfaceManager.getInterfaceEgressActions(ifName);
+ BucketInfo bucket = new BucketInfo(listActionInfo);
+ // MAC re-write
+ if (macAddress != null) {
+ listActionInfo.add(new ActionInfo(ActionType.set_field_eth_dest, new String[]{macAddress}));
+ } else {
+ //FIXME: Log message here.
+ }
+ listBucketInfo.add(bucket);
+ GroupEntity groupEntity = MDSALUtil.buildGroupEntity(
+ dpnId, groupId, ipAddress, GroupTypes.GroupIndirect, listBucketInfo);
+
+ // install Group
+ mdsalManager.installGroup(groupEntity);
+
+ //update MD-SAL DS
+ addVpnNexthopToDS(vpnId, ipAddress, groupId);
+ } else {
+ //check update
+ }
+ }
+
+ public void createRemoteNextHop(String ifName, String ofPortId, String ipAddress) {
String nhKey = new String("nexthop." + ifName + ipAddress);
- int groupId = 1;//getIdManager().getUniqueId("nextHopGroupIdPool", nhKey);
+ int groupId = createNextHopPointer(nhKey);
- long dpnId = getDpnId(ifName);
+ long dpnId = getDpnId(ofPortId);
TunnelNexthop nexthop = getTunnelNexthop(dpnId, ipAddress);
if (nexthop == null) {
- /* List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
- List<ActionInfo> listActionInfo = interfacemgr.getEgressGroupActions(ifName);
+ List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
+ List<ActionInfo> listActionInfo = interfaceManager.getInterfaceEgressActions(ifName);
BucketInfo bucket = new BucketInfo(listActionInfo);
- // MAC re-write??
+ // MAC re-write??
listBucketInfo.add(bucket);
- GroupEntity groupEntity = MDSALUtil.buildGroupEntity
- (dpId, groupId, IPAddress, GroupTypes.GroupIndirect, listBucketInfo);
- getMdsalApiManager().installGroup(groupEntity, objTransaction???);
- */
+ GroupEntity groupEntity = MDSALUtil.buildGroupEntity(
+ dpnId, groupId, ipAddress, GroupTypes.GroupIndirect, listBucketInfo);
+ mdsalManager.installGroup(groupEntity);
//update MD-SAL DS
addTunnelNexthopToDS(dpnId, ipAddress, groupId);
}
}
- private void addVpnNexthopToDS(long vpnId, String ipPrefix, long egressPointer){
-
+ private void addVpnNexthopToDS(long vpnId, String ipPrefix, long egressPointer) {
InstanceIdentifierBuilder<VpnNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
.child(VpnNexthops.class, new VpnNexthopsKey(vpnId));
}
- private void addTunnelNexthopToDS(long dpnId, String ipPrefix, long egressPointer){
+ private void addTunnelNexthopToDS(long dpnId, String ipPrefix, long egressPointer) {
InstanceIdentifierBuilder<TunnelNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
.child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId));
Optional<TunnelNexthops> nexthops = read(LogicalDatastoreType.CONFIGURATION, id);
if (!nexthops.isPresent()) {
// create a new node
- TunnelNexthops node = new TunnelNexthopsBuilder().setKey(new TunnelNexthopsKey(dpnId)).setDpnId(dpnId).build();
+ TunnelNexthops node = new TunnelNexthopsBuilder()
+ .setKey(new TunnelNexthopsKey(dpnId))
+ .setDpnId(dpnId)
+ .build();
asyncWrite(LogicalDatastoreType.OPERATIONAL, id, node, DEFAULT_CALLBACK);
}
private VpnNexthop getVpnNexthop(long vpnId, String ipAddress) {
- InstanceIdentifierBuilder<VpnNexthop> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
- .child(VpnNexthops.class, new VpnNexthopsKey(vpnId))
- .child(VpnNexthop.class, new VpnNexthopKey(ipAddress));
- InstanceIdentifier<VpnNexthop> id = idBuilder.build();
- Optional<VpnNexthop> nextHop = read(LogicalDatastoreType.CONFIGURATION, id);
-
- if(nextHop.isPresent()) return nextHop.get();
- else return null;
+ // check if vpn node is there
+ InstanceIdentifierBuilder<VpnNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
+ .child(VpnNexthops.class, new VpnNexthopsKey(vpnId));
+ InstanceIdentifier<VpnNexthops> id = idBuilder.build();
+ Optional<VpnNexthops> vpnNexthops = read(LogicalDatastoreType.CONFIGURATION, id);
+ if (!vpnNexthops.isPresent()) {
+
+ // get nexthops list for vpn
+ List<VpnNexthop> nexthops = vpnNexthops.get().getVpnNexthop();
+ for (VpnNexthop nexthop : nexthops) {
+ if (nexthop.getIpAddress().equals(ipAddress)) {
+ // return nexthop
+ return nexthop;
+ }
+ }
+ }
+ //return null if not found
+ return null;
}
private TunnelNexthop getTunnelNexthop(long dpnId, String ipAddress) {
- InstanceIdentifierBuilder<TunnelNexthop> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
- .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId))
- .child(TunnelNexthop.class, new TunnelNexthopKey(ipAddress));
- InstanceIdentifier<TunnelNexthop> id = idBuilder.build();
- Optional<TunnelNexthop> nextHop = read(LogicalDatastoreType.CONFIGURATION, id);
+
+ InstanceIdentifierBuilder<TunnelNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
+ .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId));
- if(nextHop.isPresent()) return nextHop.get();
- else return null;
+ // check if vpn node is there
+ InstanceIdentifier<TunnelNexthops> id = idBuilder.build();
+ Optional<TunnelNexthops> dpnNexthops = read(LogicalDatastoreType.CONFIGURATION, id);
+ if (!dpnNexthops.isPresent()) {
+ List<TunnelNexthop> nexthops = dpnNexthops.get().getTunnelNexthop();
+ for (TunnelNexthop nexthop : nexthops) {
+ if (nexthop.getIpAddress().equals(ipAddress)) {
+ return nexthop;
+ }
+ }
+ }
+ return null;
}
public long getNextHopPointer(long dpnId, long vpnId, String prefixIp, String nextHopIp) {
- String endpointIp = "10.10.10.1";//interfaceManager.getLocalEndpointIp(dpnId);
+ String endpointIp = interfaceManager.getEndpointIpForDpn(dpnId);
if (nextHopIp.equals(endpointIp)) {
VpnNexthop vpnNextHop = getVpnNexthop(vpnId, prefixIp);
return vpnNextHop.getEgressPointer();
}
}
- public void removeRemoteNextHop(String ifname, String IpAddress)
- {
- String nhKey = new String("nexthop" + ifname + IpAddress);
- int groupId = 1;//getIdManager().getUniqueId(L3Constants.L3NEXTHOP_GROUPID_POOL, nhKey);
+ private void removeTunnelNexthopFromDS(long dpnId, String ipPrefix) {
-/* if (getNextHop(groupId) != Null){
- List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
- List<ActionInfo> listActionInfo = null;//nextHop.getActions({output to port});
- BucketInfo bucket = new BucketInfo(listActionInfo);
- listBucketInfo.add(bucket);
- //GroupEntity groupEntity = MDSALUtil.buildGroupEntity
- (dpId, groupId, IPAddress, GroupTypes.GroupIndirect, listBucketInfo);
- //getMdsalApiManager().removeGroup(groupEntity, objTransaction???);
+ InstanceIdentifierBuilder<TunnelNexthop> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
+ .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId))
+ .child(TunnelNexthop.class, new TunnelNexthopKey(ipPrefix));
+ InstanceIdentifier<TunnelNexthop> id = idBuilder.build();
+ // remove from DS
+ delete(LogicalDatastoreType.OPERATIONAL, id);
+ }
+
+ private void removeVpnNexthopFromDS(long vpnId, String ipPrefix) {
+
+ InstanceIdentifierBuilder<VpnNexthop> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
+ .child(VpnNexthops.class, new VpnNexthopsKey(vpnId))
+ .child(VpnNexthop.class, new VpnNexthopKey(ipPrefix));
+ InstanceIdentifier<VpnNexthop> id = idBuilder.build();
+ // remove from DS
+ delete(LogicalDatastoreType.OPERATIONAL, id);
+ }
+
+
+ public void removeLocalNextHop(String vpnName, String ipAddress) {
+ long vpnId = getVpnId(vpnName);
+
+ VpnNexthop nh = getVpnNexthop(vpnId, ipAddress);
+ if (nh != null) {
+ // how to inform and remove dependent FIB entries??
+ // we need to do it before the group is removed
+
+ // remove Group ...
+
//update MD-SAL DS
- removeNextHopFromDS(dpId, vpn, ipAddress);
- }else{
- //check update
- }*/
+ removeVpnNexthopFromDS(vpnId, ipAddress);
+ } else {
+ //throw error
+ }
+
+ }
+
+ public void removeRemoteNextHop(long dpnId, String ipAddress) {
+
+ TunnelNexthop nh = getTunnelNexthop(dpnId, ipAddress);
+ if (nh != null) {
+ // how to inform and remove dependent FIB entries??
+ // we need to do it before the group is removed
+
+ // remove Group ...
+ //update MD-SAL DS
+ removeTunnelNexthopFromDS(dpnId, ipAddress);
+ } else {
+ //throw error
+ }
+
+ }
+
+ @Override
+ public Future<RpcResult<GetEgressPointerOutput>> getEgressPointer(
+ GetEgressPointerInput input) {
+ long egressGroupId =
+ getNextHopPointer(input.getDpnId(), input.getVpnId(), input.getIpPrefix(), input.getNexthopIp());
+
+ GetEgressPointerOutputBuilder output = new GetEgressPointerOutputBuilder();
+ output.setEgressPointer(egressGroupId);
+
+ RpcResult<GetEgressPointerOutput> result = null;
+ //Rpcs.<GetEgressPointerOutput> getRpcResult(false, output.build());
+ return Futures.immediateFuture(result);
}
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
}
- @Override
- public Future<RpcResult<GetEgressPointerOutput>> getEgressPointer(
- GetEgressPointerInput input) {
- long egressGroupId =
- getNextHopPointer(input.getDpnId(), input.getVpnId(), input.getIpPrefix(), input.getNexthopIp());
-
- GetEgressPointerOutputBuilder output = new GetEgressPointerOutputBuilder();
- output.setEgressPointer(egressGroupId);
-
- /*RpcResult<GetEgressPointerOutput> result = Rpcs.<GetEgressPointerOutput> getRpcResult(false, output.build());
- return Futures.immediateFuture(result);*/
- return null;
+ private <T extends DataObject> void delete(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ tx.delete(datastoreType, path);
+ Futures.addCallback(tx.submit(), DEFAULT_CALLBACK);
}
}
\ No newline at end of file
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
import org.opendaylight.vpnservice.nexthopmgr.NexthopManager;
+import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
+import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.idmanager.IdManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private VpnInterfaceChangeListener vpnIfListener;
private OdlInterfaceChangeListener odlIfListener;
private NexthopManager nhManager;
+ private IMdsalApiManager mdsalManager;
+ private IInterfaceManager interfaceManager;
+ private IdManager idManager;
@Override
public void onSessionInitiated(ProviderContext session) {
final DataBroker dbx = session.getSALService(DataBroker.class);
nhManager = new NexthopManager(dbx);
vpnIfListener = new VpnInterfaceChangeListener(dbx, nhManager);
- odlIfListener = new OdlInterfaceChangeListener(dbx, nhManager);
+ odlIfListener = new OdlInterfaceChangeListener(dbx, nhManager, interfaceManager);
+ idManager = new IdManager(dbx);
+ nhManager.setMdsalManager(mdsalManager);
+ nhManager.setInterfaceManager(interfaceManager);
+ nhManager.setIdManager(idManager);
LOG.info("NexthopmgrProvider Session Initiated");
}
+ public void setMdsalManager(IMdsalApiManager mdsalManager) {
+ this.mdsalManager = mdsalManager;
+ }
+
+ public void setInterfaceManager(IInterfaceManager interfaceManager) {
+ this.interfaceManager = interfaceManager;
+ }
+
@Override
public void close() throws Exception {
vpnIfListener.close();
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
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.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.BaseIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.L3tunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfL3tunnel;
-
+import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
import org.opendaylight.vpnservice.nexthopmgr.AbstractDataChangeListener;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private ListenerRegistration<DataChangeListener> listenerRegistration;
private final DataBroker broker;
private NexthopManager nexthopManager;
+ private IInterfaceManager interfaceManager;
+
- public OdlInterfaceChangeListener(final DataBroker db, NexthopManager nhm) {
+ public OdlInterfaceChangeListener(final DataBroker db, NexthopManager nhm, IInterfaceManager ifManager) {
super(Interface.class);
broker = db;
nexthopManager = nhm;
+ interfaceManager = ifManager;
registerListener(db);
}
throw new IllegalStateException("Nexthop Manager registration Listener failed.", e);
}
}
-
+
@Override
-
- protected void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
+ protected void add(InstanceIdentifier<Interface> identifier, Interface intrf) {
LOG.info("key: " + identifier + ", value=" + intrf );
if (intrf.getType().equals(L3tunnel.class)) {
- IfL3tunnel intfData = intrf.getAugmentation(IfL3tunnel.class);
+ IfL3tunnel intfData = intrf.getAugmentation(IfL3tunnel.class);
String gwIp = intfData.getGatewayIp().toString();
String remoteIp = intfData.getRemoteIp().toString();
if (gwIp != null) {
remoteIp = gwIp;
}
- nexthopManager.createRemoteNextHop(intrf.getName(), remoteIp);
+ NodeConnectorId ofPort = intrf.getAugmentation(BaseIds.class).getOfPortId();
+ nexthopManager.createRemoteNextHop(intrf.getName(), ofPort.toString(), remoteIp);
}
}
-
+
private InstanceIdentifier<Interface> getWildCardPath() {
return InstanceIdentifier.create(Interfaces.class).child(Interface.class);
}
protected void remove(InstanceIdentifier<Interface> identifier,
Interface intrf) {
if (intrf.getType().equals(L3tunnel.class)) {
+ long dpnId = interfaceManager.getDpnForInterface(intrf.getName());
IfL3tunnel intfData = intrf.getAugmentation(IfL3tunnel.class);
String gwIp = intfData.getGatewayIp().toString();
String remoteIp = intfData.getRemoteIp().toString();
if (gwIp != null) {
remoteIp = gwIp;
}
- nexthopManager.removeRemoteNextHop(intrf.getName(), remoteIp);
+ nexthopManager.removeRemoteNextHop(dpnId, remoteIp);
}
}
package org.opendaylight.vpnservice.nexthopmgr;
import java.util.List;
-import java.util.ArrayList;
-
import com.google.common.base.Optional;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
-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.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.vpnservice.nexthopmgr.AbstractDataChangeListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class VpnInterfaceChangeListener extends AbstractDataChangeListener<VpnInterface> implements AutoCloseable {
+public class VpnInterfaceChangeListener extends AbstractDataChangeListener<Adjacencies> implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(VpnInterfaceChangeListener.class);
private ListenerRegistration<DataChangeListener> listenerRegistration;
private NexthopManager nexthopManager;
public VpnInterfaceChangeListener(final DataBroker db, NexthopManager nhm) {
- super(VpnInterface.class);
+ super(Adjacencies.class);
broker = db;
nexthopManager = nhm;
registerListener(db);
}
@Override
- protected void add(InstanceIdentifier<VpnInterface> identifier,
- VpnInterface vpnIf) {
- LOG.info("key: " + identifier + ", value=" + vpnIf );
-
- String vpnName = vpnIf.getVpnInstanceName();
- final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
- String interfaceName = key.getName();
- InstanceIdentifierBuilder<Interface> idBuilder =
- InstanceIdentifier.builder(Interfaces.class).child(Interface.class, new InterfaceKey(interfaceName));
- InstanceIdentifier<Interface> id = idBuilder.build();
- Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
- if (port.isPresent()) {
- //Interface interf = port.get();
-
- //Read NextHops
- InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = read(LogicalDatastoreType.CONFIGURATION, path);
-
- if (adjacencies.isPresent()) {
- List<Adjacency> nextHops = adjacencies.get().getAdjacency();
- List<Adjacency> value = new ArrayList<>();
-
- if (!nextHops.isEmpty()) {
- LOG.info("NextHops are " + nextHops);
- for (Adjacency nextHop : nextHops) {
- nexthopManager.createLocalNextHop(interfaceName, vpnName, nextHop.getIpAddress());
- }
- }
- }
+ protected void add(InstanceIdentifier<Adjacencies> identifier,
+ Adjacencies adjs) {
+
+ InstanceIdentifier<VpnInterface> vpnIfId = identifier.firstIdentifierOf(VpnInterface.class);
+ Optional<VpnInterface> vpnIf = read(LogicalDatastoreType.CONFIGURATION, vpnIfId);
+ VpnInterface vpnIfData = vpnIf.get();
+
+ List<Adjacency> adjList = adjs.getAdjacency();
+ for (Adjacency adjacency : adjList) {
+ nexthopManager.createLocalNextHop(
+ vpnIfData.getName(),
+ vpnIfData.getVpnInstanceName(),
+ adjacency.getIpAddress(),
+ adjacency.getMacAddress());
}
+ }
+
+
+ @Override
+ protected void remove(InstanceIdentifier<Adjacencies> identifier,
+ Adjacencies adjs) {
+ InstanceIdentifier<VpnInterface> vpnIfId = identifier.firstIdentifierOf(VpnInterface.class);
+ Optional<VpnInterface> vpnIf = read(LogicalDatastoreType.CONFIGURATION, vpnIfId);
+ VpnInterface vpnIfData = vpnIf.get();
+
+ List<Adjacency> adjList = adjs.getAdjacency();
+ for (Adjacency adjacency : adjList) {
+ nexthopManager.removeLocalNextHop(vpnIfData.getVpnInstanceName(), adjacency.getIpAddress());
+ }
+
+ }
+ @Override
+ protected void update(InstanceIdentifier<Adjacencies> identifier,
+ Adjacencies original, Adjacencies update) {
+ // TODO Auto-generated method stub
}
+
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
return result;
}
- private InstanceIdentifier<VpnInterface> getWildCardPath() {
- return InstanceIdentifier.create(VpnInterfaces.class).child(VpnInterface.class);
+ private InstanceIdentifier<Adjacencies> getWildCardPath() {
+ return InstanceIdentifier.create(VpnInterfaces.class).child(VpnInterface.class).augmentation(Adjacencies.class);
}
- @Override
- protected void remove(InstanceIdentifier<VpnInterface> identifier,
- VpnInterface del) {
- // TODO Auto-generated method stub
- }
-
- @Override
- protected void update(InstanceIdentifier<VpnInterface> identifier,
- VpnInterface original, VpnInterface update) {
- // TODO Auto-generated method stub
-
- }
}
\ No newline at end of file
@Override
public java.lang.AutoCloseable createInstance() {
NexthopmgrProvider provider = new NexthopmgrProvider();
+ provider.setMdsalManager(getMdsalutilDependency());
+ provider.setInterfaceManager(getOdlinterfaceDependency());
+
getBrokerDependency().registerProvider(provider);
return provider;
}
import config { prefix config; revision-date 2013-04-05; }
import opendaylight-md-sal-binding { prefix md-sal-binding; revision-date 2013-10-28;}
+ import odl-mdsalutil { prefix odl-mdsal; revision-date 2015-04-10;}
+ import odl-interface {prefix odlif; revision-date 2015-03-31;}
description
"Service definition for nexthopmgr project";
}
}
}
+ container mdsalutil {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity odl-mdsal:odl-mdsalutil;
+ }
+ }
+ }
+ container odlinterface {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity odlif:odl-interface;
+ }
+ }
+ }
}
}
}
Code Review / vpnservice.git / commitdiff