X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=fibmanager%2Ffibmanager-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fvpnservice%2Ffibmanager%2FFibManager.java;h=e38c84deeec6a11e59bab4d32b18506aa5dfc933;hb=f488b0d2307f0a46e5ad3cd138351309606e1d00;hp=a134addb65e802e3d17aa9811b9c3c753e5130d9;hpb=cc530f909d6f2feeb6e97eb45778e437d55bd48b;p=vpnservice.git diff --git a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java index a134addb..e38c84de 100644 --- a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java +++ b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java @@ -7,13 +7,26 @@ */ package org.opendaylight.vpnservice.fibmanager; +import com.google.common.base.Optional; import com.google.common.base.Preconditions; -import com.google.common.util.concurrent.Futures; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import com.google.common.util.concurrent.FutureCallback; -import org.opendaylight.vpnservice.AbstractDataChangeListener; +import com.google.common.util.concurrent.Futures; +import java.math.BigInteger; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +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.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.vpnmanager.api.IVpnManager; +import org.opendaylight.vpnservice.AbstractDataChangeListener; import org.opendaylight.vpnservice.mdsalutil.ActionInfo; import org.opendaylight.vpnservice.mdsalutil.ActionType; import org.opendaylight.vpnservice.mdsalutil.FlowEntity; @@ -28,34 +41,22 @@ import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager; 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.opendaylight.l3vpn.rev130911.VpnInstance1; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.FibEntries; import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTables; import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTablesKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.vrfentries.VrfEntry; import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.GetEgressPointerInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.GetEgressPointerOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.L3nexthopService; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.RemoveLocalNextHopInputBuilder; 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.vpnservice.fibmanager.rev150330.FibEntries; import org.opendaylight.yangtools.yang.binding.RpcService; import org.opendaylight.yangtools.yang.common.RpcResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.google.common.base.Optional; - -import java.math.BigInteger; -import java.net.InetAddress; -import java.net.UnknownHostException; -import java.util.ArrayList; -import java.util.List; -import java.util.Set; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; public class FibManager extends AbstractDataChangeListener implements AutoCloseable{ private static final Logger LOG = LoggerFactory.getLogger(FibManager.class); @@ -64,9 +65,10 @@ public class FibManager extends AbstractDataChangeListener implements private final DataBroker broker; private final L3nexthopService l3nexthopService; private IMdsalApiManager mdsalManager; + private IVpnManager vpnmanager; - private static final short L3_FIB_TABLE = 20; - private static final short L3_LFIB_TABLE = 21; + private static final short L3_FIB_TABLE = 21; + private static final short L3_LFIB_TABLE = 20; private static final BigInteger COOKIE_VM_LFIB_TABLE = new BigInteger("8000002", 16); private static final BigInteger COOKIE_VM_FIB_TABLE = new BigInteger("8000003", 16); private static final int DEFAULT_FIB_FLOW_PRIORITY = 10; @@ -108,9 +110,13 @@ public class FibManager extends AbstractDataChangeListener implements this.mdsalManager = mdsalManager; } + public void setVpnmanager(IVpnManager vpnmanager) { + this.vpnmanager = vpnmanager; + } + private void registerListener(final DataBroker db) { try { - listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, + listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, getWildCardPath(), FibManager.this, DataChangeScope.SUBTREE); } catch (final Exception e) { LOG.error("FibManager DataChange listener registration fail!", e); @@ -118,13 +124,6 @@ public class FibManager extends AbstractDataChangeListener implements } } - @Override - protected void add(final InstanceIdentifier identifier, - final VrfEntry vrfEntry) { - LOG.trace("key: " + identifier + ", value=" + vrfEntry ); - createFibEntries(identifier, vrfEntry); - } - private Optional read(LogicalDatastoreType datastoreType, InstanceIdentifier path) { @@ -144,21 +143,29 @@ public class FibManager extends AbstractDataChangeListener implements return InstanceIdentifier.create(FibEntries.class).child(VrfTables.class).child(VrfEntry.class); } + private void asyncWrite(LogicalDatastoreType datastoreType, + InstanceIdentifier path, T data, FutureCallback callback) { + WriteTransaction tx = broker.newWriteOnlyTransaction(); + tx.put(datastoreType, path, data, true); + Futures.addCallback(tx.submit(), callback); + } + @Override - protected void remove(InstanceIdentifier identifier, VrfEntry del) { - LOG.trace("key: " + identifier + ", value=" + del ); + protected void add(final InstanceIdentifier identifier, + final VrfEntry vrfEntry) { + LOG.trace("key: " + identifier + ", value=" + vrfEntry ); + createFibEntries(identifier, vrfEntry); } @Override - protected void update(InstanceIdentifier identifier, VrfEntry original, VrfEntry update) { - LOG.trace("key: " + identifier + ", original=" + original + ", update=" + update ); + protected void remove(InstanceIdentifier identifier, VrfEntry vrfEntry) { + LOG.trace("key: " + identifier + ", value=" + vrfEntry); + deleteFibEntries(identifier, vrfEntry); } - private void asyncWrite(LogicalDatastoreType datastoreType, - InstanceIdentifier path, T data, FutureCallback callback) { - WriteTransaction tx = broker.newWriteOnlyTransaction(); - tx.put(datastoreType, path, data, true); - Futures.addCallback(tx.submit(), callback); + @Override + protected void update(InstanceIdentifier identifier, VrfEntry original, VrfEntry update) { + LOG.trace("key: " + identifier + ", original=" + original + ", update=" + update ); } private void createFibEntries(final InstanceIdentifier identifier, @@ -169,34 +176,18 @@ public class FibManager extends AbstractDataChangeListener implements Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher()); Preconditions.checkNotNull(vpnId, "Vpn Instance not available!"); - List dpns = getDpnsByVpn(vpnId); - for (Long dpId : dpns) { + Collection dpns = vpnmanager.getDpnsForVpn(vpnId); + for (BigInteger dpId : dpns) { addRouteInternal(dpId, vpnId, vrfTableKey, vrfEntry); } } - /* - * - */ - private void addRouteInternal(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey, - final VrfEntry vrfEntry) { + private void addRouteInternal(final BigInteger dpId, final long vpnId, final VrfTablesKey vrfTableKey, + final VrfEntry vrfEntry) { String rd = vrfTableKey.getRouteDistinguisher(); - LOG.info("adding route " + vrfEntry.getDestPrefix() + " " + rd); + LOG.debug("adding route " + vrfEntry.getDestPrefix() + " " + rd); - String values[] = vrfEntry.getDestPrefix().split("/"); - LOG.info(String.format("Adding route to DPN. ip %s masklen %s", values[0], values[1])); - String ipAddress = values[0]; - int prefix = Integer.parseInt(values[1]); - InetAddress destAddress = null; - try { - destAddress = InetAddress.getByName(ipAddress); - } catch (UnknownHostException e) { - LOG.error(String.format("UnknowHostException in addRoute." - + "Failed to add Route for ipPrefix %s", vrfEntry.getDestPrefix())); - return; - } - - GetEgressPointerOutput adjacency = resolveAdjacency(dpId, vpnId, vrfTableKey, vrfEntry); + GetEgressPointerOutput adjacency = resolveAdjacency(dpId, vpnId, vrfEntry); long groupId = -1; boolean isLocalRoute = false; if(adjacency != null) { @@ -204,40 +195,64 @@ public class FibManager extends AbstractDataChangeListener implements isLocalRoute = adjacency.isLocalDestination(); } if(groupId == -1) { - LOG.error(String.format("Could not get nexthop group id for nexthop: %s in vpn %s", - vrfEntry.getNextHopAddress(), rd)); - LOG.warn(String.format("Failed to add Route: %s in vpn: %s", - vrfEntry.getDestPrefix(), rd)); + LOG.error("Could not get nexthop group id for nexthop: {} in vpn {}", + vrfEntry.getNextHopAddress(), rd); + LOG.warn("Failed to add Route: {} in vpn: {}", + vrfEntry.getDestPrefix(), rd); return; } - makeConnectedRoute(dpId, destAddress, prefix, vpnId, rd, groupId, NwConstants.ADD_FLOW); + makeConnectedRoute(dpId, vpnId, vrfEntry, rd, groupId, NwConstants.ADD_FLOW); if (isLocalRoute) { makeLFibTableEntry(dpId, vrfEntry.getLabel(), groupId, vrfEntry.getNextHopAddress(), NwConstants.ADD_FLOW); } - LOG.info( - "Successfully added fib entry for " + destAddress.getHostAddress() + " vpnId " + vpnId); + LOG.debug( + "Successfully added fib entry for " + vrfEntry.getDestPrefix() + " vpnId " + vpnId); } - public void deleteRoute(InetAddress destPrefix, int prefixLength, int vpnId, String rd) { - LOG.info("deleting route "+destPrefix.getHostAddress()+ " "+vpnId); - - List dpnIds = getDpnsByVpn(vpnId); + private void deleteFibEntries(final InstanceIdentifier identifier, + final VrfEntry vrfEntry) { + final VrfTablesKey vrfTableKey = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class); + Preconditions.checkNotNull(vrfTableKey, "VrfTablesKey cannot be null or empty!"); + Preconditions.checkNotNull(vrfEntry, "VrfEntry cannot be null or empty!"); - for (long dpnId : dpnIds) { - makeConnectedRoute(dpnId, destPrefix, prefixLength, vpnId, rd, 0/*groupId*/, NwConstants.DEL_FLOW); + Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher()); + Preconditions.checkNotNull(vpnId, "Vpn Instance not available!"); + Collection dpns = vpnmanager.getDpnsForVpn(vpnId); + for (BigInteger dpId : dpns) { + deleteRoute(dpId, vpnId, vrfTableKey, vrfEntry); } - LOG.info("Successfully delete fib entry for "+destPrefix.getHostAddress()+ " vpnId "+vpnId); } - public void deleteRoute(InetAddress destPrefix, int prefixLength, int vpnId, String rd, long dpId) { - LOG.info("deleting route "+destPrefix.getHostAddress()+ " "+vpnId); + public void deleteRoute(final BigInteger dpId, final long vpnId, final VrfTablesKey vrfTableKey, + final VrfEntry vrfEntry) { + LOG.debug("deleting route "+ vrfEntry.getDestPrefix() + " "+vpnId); + String rd = vrfTableKey.getRouteDistinguisher(); + GetEgressPointerOutput adjacency = resolveAdjacency(dpId, vpnId, vrfEntry); + long groupId = -1; + boolean isLocalRoute = false; + if(adjacency != null) { + groupId = adjacency.getEgressPointer(); + isLocalRoute = adjacency.isLocalDestination(); + } + if(groupId == -1) { + LOG.error("Could not get nexthop group id for nexthop: {} in vpn {}", + vrfEntry.getNextHopAddress(), rd); + LOG.warn("Failed to add Route: {} in vpn: {}", + vrfEntry.getDestPrefix(), rd); + return; + } - makeConnectedRoute(dpId, destPrefix, prefixLength, vpnId, rd, 0/*groupId*/, NwConstants.DEL_FLOW); + makeConnectedRoute(dpId, vpnId, vrfEntry, rd, groupId, NwConstants.DEL_FLOW); - LOG.info("Successfully delete fib entry for "+destPrefix.getHostAddress()+ " vpnId "+vpnId); + if (isLocalRoute) { + makeLFibTableEntry(dpId, vrfEntry.getLabel(), groupId, vrfEntry.getNextHopAddress(), NwConstants.DEL_FLOW); + deleteLocalAdjacency(dpId, vpnId, vrfEntry); + } + + LOG.debug("Successfully delete fib entry for "+ vrfEntry.getDestPrefix() + " vpnId "+vpnId); } private long getIpAddress(byte[] rawIpAddress) { @@ -245,8 +260,20 @@ public class FibManager extends AbstractDataChangeListener implements + ((rawIpAddress[2] & 0xFF) << (1 * 8)) + (rawIpAddress[3] & 0xFF)) & 0xffffffffL; } - private void makeConnectedRoute(long dpId, InetAddress destPrefix, int prefixLength, long vpnId, - String rd, long groupId, int addOrRemove) { + private void makeConnectedRoute(BigInteger dpId, long vpnId, VrfEntry vrfEntry, String rd, + long groupId, int addOrRemove) { + LOG.trace("makeConnectedRoute: vrfEntry {}",vrfEntry); + String values[] = vrfEntry.getDestPrefix().split("/"); + String ipAddress = values[0]; + int prefixLength = (values.length == 1) ? 32 : Integer.parseInt(values[1]); + LOG.debug("Adding route to DPN. ip {} masklen {}", ipAddress, prefixLength); + InetAddress destPrefix = null; + try { + destPrefix = InetAddress.getByName(ipAddress); + } catch (UnknownHostException e) { + LOG.error("UnknowHostException in addRoute. Failed to add Route for ipPrefix {}", vrfEntry.getDestPrefix()); + return; + } List matches = new ArrayList(); @@ -265,6 +292,8 @@ public class FibManager extends AbstractDataChangeListener implements List actionsInfos = new ArrayList(); if(addOrRemove == NwConstants.ADD_FLOW) { + actionsInfos.add(new ActionInfo(ActionType.push_mpls, new String[] { null })); + actionsInfos.add(new ActionInfo(ActionType.set_field_mpls_label, new String[] { Long.toString(vrfEntry.getLabel())})); actionsInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId)})); instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos)); } @@ -285,7 +314,7 @@ public class FibManager extends AbstractDataChangeListener implements } } - private void makeLFibTableEntry(long dpId, long label, long groupId, + private void makeLFibTableEntry(BigInteger dpId, long label, long groupId, String nextHop, int addOrRemove) { List matches = new ArrayList(); matches.add(new MatchInfo(MatchFieldType.eth_type, @@ -294,7 +323,6 @@ public class FibManager extends AbstractDataChangeListener implements List instructions = new ArrayList(); List actionsInfos = new ArrayList(); - actionsInfos.add(new ActionInfo(ActionType.pop_mpls, new String[]{Long.toString(label)})); actionsInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId) })); instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos)); @@ -311,26 +339,76 @@ public class FibManager extends AbstractDataChangeListener implements } else { mdsalManager.removeFlow(flowEntity); } - LOG.info("LFIB Entry for dpID {} : label : {} grpup {} modified successfully {}",dpId, label, groupId ); + LOG.debug("LFIB Entry for dpID {} : label : {} group {} modified successfully {}",dpId, label, groupId ); + } + + private void deleteLocalAdjacency(final BigInteger dpId, final long vpnId, final VrfEntry vrfEntry) { + LOG.trace("deleteLocalAdjacency called with dpid {}, vpnId{}, VrfEntry {}",dpId, vpnId, vrfEntry);; + try { + Future> result = + l3nexthopService.removeLocalNextHop(new RemoveLocalNextHopInputBuilder().setDpnId(dpId) + .setIpPrefix(vrfEntry.getDestPrefix()) + .setNexthopIp(vrfEntry.getNextHopAddress()) + .setVpnId(vpnId) + .build()); + RpcResult rpcResult = result.get(); + if (rpcResult.isSuccessful()) { + LOG.debug("Local Next hop for {} on dpn {} successfully deleted", vrfEntry.getDestPrefix(), dpId); + } else { + LOG.error("Local Next hop for {} on dpn {} not deleted", vrfEntry.getDestPrefix(), dpId); + } + } catch (NullPointerException | InterruptedException | ExecutionException e) { + LOG.trace("", e); + } + } + + public void populateFibOnNewDpn(BigInteger dpnId, long vpnId, String rd) { + LOG.trace("New dpn {} for vpn {} : populateFibOnNewDpn", dpnId, rd); + InstanceIdentifier id = buildVrfId(rd); + Optional vrfTable = read(LogicalDatastoreType.OPERATIONAL, id); + if(vrfTable.isPresent()) { + for(VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) { + addRouteInternal(dpnId, vpnId, vrfTable.get().getKey(), vrfEntry); + } + } } - private String getFlowRef(long dpnId, short tableId, long label, String nextHop) { + public void cleanUpDpnForVpn(BigInteger dpnId, long vpnId, String rd) { + LOG.trace("Remove dpn {} for vpn {} : cleanUpDpnForVpn", dpnId, rd); + InstanceIdentifier id = buildVrfId(rd); + Optional vrfTable = read(LogicalDatastoreType.OPERATIONAL, id); + if(vrfTable.isPresent()) { + for(VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) { + deleteRoute(dpnId, vpnId, vrfTable.get().getKey(), vrfEntry); + } + } + } + + public static InstanceIdentifier buildVrfId(String rd) { + InstanceIdentifierBuilder idBuilder = + InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)); + InstanceIdentifier id = idBuilder.build(); + return id; + } + + private String getFlowRef(BigInteger dpnId, short tableId, long label, String nextHop) { return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR) .append(tableId).append(NwConstants.FLOWID_SEPARATOR) .append(label).append(NwConstants.FLOWID_SEPARATOR) .append(nextHop).toString(); } - private String getFlowRef(long dpnId, short tableId, String rd, InetAddress destPrefix) { + private String getFlowRef(BigInteger dpnId, short tableId, String rd, InetAddress destPrefix) { return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR) .append(tableId).append(NwConstants.FLOWID_SEPARATOR) .append(rd).append(NwConstants.FLOWID_SEPARATOR) .append(destPrefix.getHostAddress()).toString(); } - private GetEgressPointerOutput resolveAdjacency(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey, + protected GetEgressPointerOutput resolveAdjacency(final BigInteger dpId, final long vpnId, final VrfEntry vrfEntry) { GetEgressPointerOutput adjacency = null; + LOG.trace("resolveAdjacency called with dpid {}, vpnId{}, VrfEntry {}",dpId, vpnId, vrfEntry);; try { Future> result = l3nexthopService.getEgressPointer(new GetEgressPointerInputBuilder().setDpnId(dpId) @@ -350,12 +428,7 @@ public class FibManager extends AbstractDataChangeListener implements return adjacency; } - private List getDpnsByVpn(long vpnId) { - // TODO: get list of dpns from vpnmanager, for all dpns List - return new ArrayList<>(); - } - - private Long getVpnId(String rd) { + protected Long getVpnId(String rd) { Long vpnId = null; InstanceIdentifier id = InstanceIdentifier.create(VpnInstances.class); Optional vpnInstances = read(LogicalDatastoreType.OPERATIONAL, id); @@ -373,4 +446,42 @@ public class FibManager extends AbstractDataChangeListener implements } return vpnId; } + + public void processNodeAdd(BigInteger dpnId) { + LOG.debug("Received notification to install TableMiss entries for dpn {} ", dpnId); + makeTableMissFlow(dpnId, NwConstants.ADD_FLOW); + } + + private void makeTableMissFlow(BigInteger dpnId, int addOrRemove) { + final BigInteger COOKIE_TABLE_MISS = new BigInteger("1030000", 16); + // Instruction to punt to controller + List instructions = new ArrayList(); + List actionsInfos = new ArrayList(); + actionsInfos.add(new ActionInfo(ActionType.punt_to_controller, new String[] {})); + instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos)); + List matches = new ArrayList(); + FlowEntity flowEntityLfib = MDSALUtil.buildFlowEntity(dpnId, L3_LFIB_TABLE, + getFlowRef(dpnId, L3_LFIB_TABLE, NwConstants.TABLE_MISS_FLOW), + NwConstants.TABLE_MISS_PRIORITY, "Table Miss", 0, 0, COOKIE_TABLE_MISS, matches, instructions); + + FlowEntity flowEntityFib = MDSALUtil.buildFlowEntity(dpnId,L3_FIB_TABLE, getFlowRef(dpnId, L3_FIB_TABLE, NwConstants.TABLE_MISS_FLOW), + NwConstants.TABLE_MISS_PRIORITY, "FIB Table Miss Flow", 0, 0, COOKIE_VM_FIB_TABLE, + matches, instructions); + + if (addOrRemove == NwConstants.ADD_FLOW) { + LOG.debug("Invoking MDSAL to install Table Miss Entries"); + mdsalManager.installFlow(flowEntityLfib); + mdsalManager.installFlow(flowEntityFib); + } else { + mdsalManager.removeFlow(flowEntityLfib); + mdsalManager.removeFlow(flowEntityFib); + + } + } + + private String getFlowRef(BigInteger dpnId, short tableId, int tableMiss) { + return new StringBuffer().append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR) + .append(tableId).append(NwConstants.FLOWID_SEPARATOR).append(tableMiss) + .append(FLOWID_PREFIX).toString(); + } }