X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=nexthopmgr%2Fnexthopmgr-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fvpnservice%2Fnexthopmgr%2FNexthopManager.java;h=c0a99838a00997d7e5171bde6cf1e46dbb5d33ca;hb=b4b1b760287d5aa668c493b0a8f35e2ebae5ecd8;hp=546e60f8a91ee5970da596eb3d4cfdf3b9c1d66e;hpb=c5e5099f13dd1b3b53c168f2b461b902758f6d4c;p=vpnservice.git diff --git a/nexthopmgr/nexthopmgr-impl/src/main/java/org/opendaylight/vpnservice/nexthopmgr/NexthopManager.java b/nexthopmgr/nexthopmgr-impl/src/main/java/org/opendaylight/vpnservice/nexthopmgr/NexthopManager.java index 546e60f8..c0a99838 100644 --- a/nexthopmgr/nexthopmgr-impl/src/main/java/org/opendaylight/vpnservice/nexthopmgr/NexthopManager.java +++ b/nexthopmgr/nexthopmgr-impl/src/main/java/org/opendaylight/vpnservice/nexthopmgr/NexthopManager.java @@ -7,16 +7,20 @@ */ package org.opendaylight.vpnservice.nexthopmgr; +import org.opendaylight.vpnservice.mdsalutil.FlowEntity; +import org.opendaylight.vpnservice.mdsalutil.InstructionInfo; +import org.opendaylight.vpnservice.mdsalutil.InstructionType; +import org.opendaylight.vpnservice.mdsalutil.MatchFieldType; +import org.opendaylight.vpnservice.mdsalutil.MatchInfo; +import org.opendaylight.vpnservice.mdsalutil.NwConstants; 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.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.yangtools.yang.binding.DataObject; @@ -48,9 +52,7 @@ 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; @@ -60,11 +62,15 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { private IMdsalApiManager mdsalManager; private IInterfaceManager interfaceManager; private IdManager idManager; + private static final short LPORT_INGRESS_TABLE = 0; + private static final short LFIB_TABLE = 20; + private static final short FIB_TABLE = 21; + private static final short DEFAULT_FLOW_PRIORITY = 10; private static final FutureCallback DEFAULT_CALLBACK = new FutureCallback() { public void onSuccess(Void result) { - LOG.info("Success in Datastore write operation"); + LOG.debug("Success in Datastore write operation"); } public void onFailure(Throwable error) { LOG.error("Error in Datastore write operation", error); @@ -106,6 +112,7 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { .build(); //TODO: Error handling Future> result = idManager.createIdPool(createPool); + LOG.trace("NextHopPointerPool result : {}", result); // try { // LOG.info("Result2: {}",result.get()); // } catch (InterruptedException | ExecutionException e) { @@ -116,28 +123,30 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { } - private long getVpnId(String vpnName) { + protected long getVpnId(String vpnName) { InstanceIdentifierBuilder idBuilder = InstanceIdentifier.builder(VpnInstances.class) .child(VpnInstance.class, new VpnInstanceKey(vpnName)); InstanceIdentifier id = idBuilder.build(); InstanceIdentifier idx = id.augmentation(VpnInstance1.class); - Optional vpn = read(LogicalDatastoreType.CONFIGURATION, idx); + Optional vpn = read(LogicalDatastoreType.OPERATIONAL, idx); if (vpn.isPresent()) { + LOG.debug("VPN id returned: {}", vpn.get().getVpnId()); return vpn.get().getVpnId(); } else { - return 0; + return -1; } } - private long getDpnId(String ifName) { - String[] fields = ifName.split(":"); - long dpn = Integer.parseInt(fields[1]); + private BigInteger getDpnId(String ofPortId) { + String[] fields = ofPortId.split(":"); + BigInteger dpn = new BigInteger(fields[1]); + LOG.debug("DpnId: {}", dpn); return dpn; } - private int createNextHopPointer(String nexthopKey) { + protected int createNextHopPointer(String nexthopKey) { GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder() .setPoolName("nextHopPointerPool").setIdKey(nexthopKey) .build(); @@ -157,17 +166,20 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { int groupId = createNextHopPointer(nhKey); long vpnId = getVpnId(vpnName); - long dpnId = interfaceManager.getDpnForInterface(ifName); - VpnNexthop nexthop = getVpnNexthop(vpnId, ipAddress); + BigInteger dpnId = interfaceManager.getDpnForInterface(ifName); + VpnNexthop nexthop = getVpnNexthop(vpnId, ipAddress, 0); + LOG.trace("nexthop: {}", nexthop); if (nexthop == null) { List listBucketInfo = new ArrayList(); List 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})); + listActionInfo.add(0, new ActionInfo(ActionType.set_field_eth_dest, new String[]{macAddress})); + listActionInfo.add(0, new ActionInfo(ActionType.pop_mpls, new String[]{})); } else { //FIXME: Log message here. + LOG.debug("mac address for new local nexthop is null"); } listBucketInfo.add(bucket); GroupEntity groupEntity = MDSALUtil.buildGroupEntity( @@ -183,14 +195,13 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { } } - public void createRemoteNextHop(String ifName, String ofPortId, String ipAddress) { + public void createRemoteNextHop(String ifName, String ipAddress) { String nhKey = new String("nexthop." + ifName + ipAddress); int groupId = createNextHopPointer(nhKey); - long dpnId = getDpnId(ofPortId); + BigInteger dpnId = interfaceManager.getDpnForInterface(ifName); TunnelNexthop nexthop = getTunnelNexthop(dpnId, ipAddress); if (nexthop == null) { - List listBucketInfo = new ArrayList(); List listActionInfo = interfaceManager.getInterfaceEgressActions(ifName); BucketInfo bucket = new BucketInfo(listActionInfo); @@ -199,6 +210,7 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { GroupEntity groupEntity = MDSALUtil.buildGroupEntity( dpnId, groupId, ipAddress, GroupTypes.GroupIndirect, listBucketInfo); mdsalManager.installGroup(groupEntity); + //makeRemoteFlow(dpnId, ifName, NwConstants.ADD_FLOW); //update MD-SAL DS addTunnelNexthopToDS(dpnId, ipAddress, groupId); @@ -207,19 +219,39 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { } } - private void addVpnNexthopToDS(long vpnId, String ipPrefix, long egressPointer) { + private void makeRemoteFlow(BigInteger dpnId, String ifName, int addOrRemoveFlow) { + long portNo = 0; + String flowName = ifName; + String flowRef = getTunnelInterfaceFlowRef(dpnId, LPORT_INGRESS_TABLE, ifName); + List matches = new ArrayList(); + List mkInstructions = new ArrayList(); + if (NwConstants.ADD_FLOW == addOrRemoveFlow) { + portNo = interfaceManager.getPortForInterface(ifName); + matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[] { + dpnId, BigInteger.valueOf(portNo) })); + mkInstructions.add(new InstructionInfo(InstructionType.goto_table, new long[] {LFIB_TABLE})); + } - InstanceIdentifierBuilder idBuilder = InstanceIdentifier.builder(L3nexthop.class) - .child(VpnNexthops.class, new VpnNexthopsKey(vpnId)); + BigInteger COOKIE_VM_INGRESS_TABLE = new BigInteger("8000001", 16); + FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpnId, LPORT_INGRESS_TABLE, flowRef, + DEFAULT_FLOW_PRIORITY, flowName, 0, 0, COOKIE_VM_INGRESS_TABLE, matches, mkInstructions); - // check if vpn node is there or to be created - InstanceIdentifier id = idBuilder.build(); - Optional nexthops = read(LogicalDatastoreType.CONFIGURATION, id); - if (!nexthops.isPresent()) { - // create a new node - VpnNexthops node = new VpnNexthopsBuilder().setKey(new VpnNexthopsKey(vpnId)).setVpnId(vpnId).build(); - asyncWrite(LogicalDatastoreType.OPERATIONAL, id, node, DEFAULT_CALLBACK); + if (NwConstants.ADD_FLOW == addOrRemoveFlow) { + mdsalManager.installFlow(flowEntity); + } else { + mdsalManager.removeFlow(flowEntity); } + } + + private String getTunnelInterfaceFlowRef(BigInteger dpnId, short tableId, String ifName) { + return new StringBuilder().append(dpnId).append(tableId).append(ifName).toString(); + } + + protected void addVpnNexthopToDS(long vpnId, String ipPrefix, long egressPointer) { + + InstanceIdentifierBuilder idBuilder = InstanceIdentifier.builder( + L3nexthop.class) + .child(VpnNexthops.class, new VpnNexthopsKey(vpnId)); // Add nexthop to vpn node VpnNexthop nh = new VpnNexthopBuilder(). @@ -229,27 +261,15 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { InstanceIdentifier id1 = idBuilder .child(VpnNexthop.class, new VpnNexthopKey(ipPrefix)).build(); - - asyncWrite(LogicalDatastoreType.OPERATIONAL, id1, nh, DEFAULT_CALLBACK); + LOG.trace("Adding vpnnextHop {} to Operational DS", nh); + syncWrite(LogicalDatastoreType.OPERATIONAL, id1, nh, DEFAULT_CALLBACK); } - private void addTunnelNexthopToDS(long dpnId, String ipPrefix, long egressPointer) { + private void addTunnelNexthopToDS(BigInteger dpnId, String ipPrefix, long egressPointer) { InstanceIdentifierBuilder idBuilder = InstanceIdentifier.builder(L3nexthop.class) .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId)); - // check if dpn node is there or to be created - InstanceIdentifier id = idBuilder.build(); - Optional nexthops = read(LogicalDatastoreType.CONFIGURATION, id); - if (!nexthops.isPresent()) { - // create a new node - TunnelNexthops node = new TunnelNexthopsBuilder() - .setKey(new TunnelNexthopsKey(dpnId)) - .setDpnId(dpnId) - .build(); - asyncWrite(LogicalDatastoreType.OPERATIONAL, id, node, DEFAULT_CALLBACK); - } - // Add nexthop to dpn node TunnelNexthop nh = new TunnelNexthopBuilder(). setKey(new TunnelNexthopKey(ipPrefix)). @@ -258,45 +278,54 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { InstanceIdentifier id1 = idBuilder .child(TunnelNexthop.class, new TunnelNexthopKey(ipPrefix)).build(); - + LOG.trace("Adding tunnelnextHop {} to Operational DS for a dpn node", nh); asyncWrite(LogicalDatastoreType.OPERATIONAL, id1, nh, DEFAULT_CALLBACK); } - private VpnNexthop getVpnNexthop(long vpnId, String ipAddress) { + protected VpnNexthop getVpnNexthop(long vpnId, String ipAddress, int retryCount) { - // check if vpn node is there - InstanceIdentifierBuilder idBuilder = InstanceIdentifier.builder(L3nexthop.class) - .child(VpnNexthops.class, new VpnNexthopsKey(vpnId)); + // check if vpn node is there + InstanceIdentifierBuilder idBuilder = + InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class, new VpnNexthopsKey(vpnId)); InstanceIdentifier id = idBuilder.build(); - Optional vpnNexthops = read(LogicalDatastoreType.CONFIGURATION, id); - if (!vpnNexthops.isPresent()) { - - // get nexthops list for vpn - List nexthops = vpnNexthops.get().getVpnNexthop(); - for (VpnNexthop nexthop : nexthops) { - if (nexthop.getIpAddress().equals(ipAddress)) { - // return nexthop - return nexthop; + try { + for (int retry = 0; retry <= retryCount; retry++) { + Optional vpnNexthops = read(LogicalDatastoreType.OPERATIONAL, id); + if (vpnNexthops.isPresent()) { + + // get nexthops list for vpn + List nexthops = vpnNexthops.get().getVpnNexthop(); + for (VpnNexthop nexthop : nexthops) { + if (nexthop.getIpAddress().equals(ipAddress)) { + // return nexthop + LOG.trace("VpnNextHop : {}", nexthop); + return nexthop; + } + } } + Thread.sleep(100L); } + } catch (InterruptedException e) { + LOG.trace("", e); } - //return null if not found + // return null if not found return null; } - private TunnelNexthop getTunnelNexthop(long dpnId, String ipAddress) { + private TunnelNexthop getTunnelNexthop(BigInteger dpnId, String ipAddress) { InstanceIdentifierBuilder idBuilder = InstanceIdentifier.builder(L3nexthop.class) .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId)); // check if vpn node is there InstanceIdentifier id = idBuilder.build(); - Optional dpnNexthops = read(LogicalDatastoreType.CONFIGURATION, id); - if (!dpnNexthops.isPresent()) { + Optional dpnNexthops = read(LogicalDatastoreType.OPERATIONAL, id); + if (dpnNexthops.isPresent()) { List nexthops = dpnNexthops.get().getTunnelNexthop(); for (TunnelNexthop nexthop : nexthops) { if (nexthop.getIpAddress().equals(ipAddress)) { + LOG.trace("TunnelNextHop : {}",nexthop); return nexthop; } } @@ -304,24 +333,26 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { return null; } - public long getNextHopPointer(long dpnId, long vpnId, String prefixIp, String nextHopIp) { + public long getNextHopPointer(BigInteger dpnId, long vpnId, String prefixIp, String nextHopIp) { String endpointIp = interfaceManager.getEndpointIpForDpn(dpnId); if (nextHopIp.equals(endpointIp)) { - VpnNexthop vpnNextHop = getVpnNexthop(vpnId, prefixIp); + VpnNexthop vpnNextHop = getVpnNexthop(vpnId, prefixIp, 0); return vpnNextHop.getEgressPointer(); } else { TunnelNexthop tunnelNextHop = getTunnelNexthop(dpnId, nextHopIp); + LOG.trace("NExtHopPointer : {}", tunnelNextHop.getEgressPointer()); return tunnelNextHop.getEgressPointer(); } } - private void removeTunnelNexthopFromDS(long dpnId, String ipPrefix) { + private void removeTunnelNexthopFromDS(BigInteger dpnId, String ipPrefix) { InstanceIdentifierBuilder idBuilder = InstanceIdentifier.builder(L3nexthop.class) .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId)) .child(TunnelNexthop.class, new TunnelNexthopKey(ipPrefix)); InstanceIdentifier id = idBuilder.build(); // remove from DS + LOG.trace("Removing tunnel next hop from datastore : {}", id); delete(LogicalDatastoreType.OPERATIONAL, id); } @@ -332,30 +363,31 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { .child(VpnNexthop.class, new VpnNexthopKey(ipPrefix)); InstanceIdentifier id = idBuilder.build(); // remove from DS + LOG.trace("Removing vpn next hop from datastore : {}", id); delete(LogicalDatastoreType.OPERATIONAL, id); } - public void removeLocalNextHop(String vpnName, String ipAddress) { - - long vpnId = getVpnId(vpnName); + public void removeLocalNextHop(BigInteger dpnId, Long vpnId, String ipAddress) { - VpnNexthop nh = getVpnNexthop(vpnId, ipAddress); + VpnNexthop nh = getVpnNexthop(vpnId, ipAddress, 0); if (nh != null) { // how to inform and remove dependent FIB entries?? // we need to do it before the group is removed - + GroupEntity groupEntity = MDSALUtil.buildGroupEntity( + dpnId, nh.getEgressPointer(), ipAddress, GroupTypes.GroupIndirect, null); // remove Group ... - + mdsalManager.removeGroup(groupEntity); //update MD-SAL DS removeVpnNexthopFromDS(vpnId, ipAddress); } else { //throw error + LOG.error("removal of local next hop failed"); } } - public void removeRemoteNextHop(long dpnId, String ipAddress) { + public void removeRemoteNextHop(BigInteger dpnId, String ifName, String ipAddress) { TunnelNexthop nh = getTunnelNexthop(dpnId, ipAddress); if (nh != null) { @@ -363,10 +395,16 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { // we need to do it before the group is removed // remove Group ... + GroupEntity groupEntity = MDSALUtil.buildGroupEntity( + dpnId, nh.getEgressPointer(), ipAddress, GroupTypes.GroupIndirect, null); + // remove Group ... + mdsalManager.removeGroup(groupEntity); + //makeRemoteFlow(dpnId, ifName, NwConstants.DEL_FLOW); //update MD-SAL DS removeTunnelNexthopFromDS(dpnId, ipAddress); } else { //throw error + LOG.error("removal of remote next hop failed : dpnid : {}, ipaddress : {}", dpnId, ipAddress); } } @@ -374,11 +412,20 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { @Override public Future> getEgressPointer( GetEgressPointerInput input) { - long egressGroupId = - getNextHopPointer(input.getDpnId(), input.getVpnId(), input.getIpPrefix(), input.getNexthopIp()); GetEgressPointerOutputBuilder output = new GetEgressPointerOutputBuilder(); - output.setEgressPointer(egressGroupId); + + String endpointIp = interfaceManager.getEndpointIpForDpn(input.getDpnId()); + LOG.trace("getEgressPointer: input {}, endpointIp {}", input, endpointIp); + if (input.getNexthopIp() == null || input.getNexthopIp().equals(endpointIp)) { + VpnNexthop vpnNextHop = getVpnNexthop(input.getVpnId(), input.getIpPrefix(), 5); + output.setEgressPointer(vpnNextHop.getEgressPointer()); + output.setLocalDestination(true); + } else { + TunnelNexthop tunnelNextHop = getTunnelNexthop(input.getDpnId(), input.getNexthopIp()); + output.setEgressPointer(tunnelNextHop.getEgressPointer()); + output.setLocalDestination(false); + } RpcResultBuilder rpcResultBuilder = RpcResultBuilder.success(); rpcResultBuilder.withResult(output.build()); @@ -387,7 +434,7 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { } - private Optional read(LogicalDatastoreType datastoreType, + Optional read(LogicalDatastoreType datastoreType, InstanceIdentifier path) { ReadOnlyTransaction tx = broker.newReadOnlyTransaction(); @@ -405,10 +452,16 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { private void asyncWrite(LogicalDatastoreType datastoreType, InstanceIdentifier path, T data, FutureCallback callback) { WriteTransaction tx = broker.newWriteOnlyTransaction(); - tx.put(datastoreType, path, data, true); + tx.merge(datastoreType, path, data, true); Futures.addCallback(tx.submit(), callback); } + private void syncWrite(LogicalDatastoreType datastoreType, + InstanceIdentifier path, T data, FutureCallback callback) { + WriteTransaction tx = broker.newWriteOnlyTransaction(); + tx.merge(datastoreType, path, data, true); + tx.submit(); + } private void delete(LogicalDatastoreType datastoreType, InstanceIdentifier path) { WriteTransaction tx = broker.newWriteOnlyTransaction(); @@ -416,4 +469,20 @@ public class NexthopManager implements L3nexthopService, AutoCloseable { Futures.addCallback(tx.submit(), DEFAULT_CALLBACK); } + @Override + public Future> removeLocalNextHop(RemoveLocalNextHopInput input) { + VpnNexthop vpnNextHop = getVpnNexthop(input.getVpnId(), input.getIpPrefix(), 0); + RpcResultBuilder rpcResultBuilder; + LOG.debug("vpnnexthop is: {}", vpnNextHop); + try { + removeLocalNextHop(input.getDpnId(),input.getVpnId(), input.getIpPrefix()); + rpcResultBuilder = RpcResultBuilder.success(); + } + catch(Exception e){ + LOG.error("Removal of local next hop for vpnNextHop {} failed {}" ,vpnNextHop, e); + rpcResultBuilder = RpcResultBuilder.failed(); + } + return Futures.immediateFuture(rpcResultBuilder.build()); + } + }