package org.opendaylight.fibmanager.api;
+import java.math.BigInteger;
+
public interface IFibManager {
- void populateFibOnNewDpn(long dpnId, long vpnId, String rd);
- void cleanUpDpnForVpn(long dpnId, long vpnId, String rd);
+ void populateFibOnNewDpn(BigInteger dpnId, long vpnId, String rd);
+ void cleanUpDpnForVpn(BigInteger dpnId, long vpnId, String rd);
}
*/
package org.opendaylight.vpnservice.fibmanager;
+import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.FutureCallback;
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 com.google.common.util.concurrent.FutureCallback;
-
+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.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
import org.opendaylight.vpnservice.mdsalutil.ActionType;
import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
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.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.Collection;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
public class FibManager extends AbstractDataChangeListener<VrfEntry> implements AutoCloseable{
private static final Logger LOG = LoggerFactory.getLogger(FibManager.class);
Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher());
Preconditions.checkNotNull(vpnId, "Vpn Instance not available!");
- Collection<Long> dpns = vpnmanager.getDpnsForVpn(vpnId);
- for (Long dpId : dpns) {
+ Collection<BigInteger> 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,
+ private void addRouteInternal(final BigInteger dpId, final long vpnId, final VrfTablesKey vrfTableKey,
final VrfEntry vrfEntry) {
String rd = vrfTableKey.getRouteDistinguisher();
LOG.debug("adding route " + vrfEntry.getDestPrefix() + " " + rd);
Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher());
Preconditions.checkNotNull(vpnId, "Vpn Instance not available!");
- Collection<Long> dpns = vpnmanager.getDpnsForVpn(vpnId);
- for (Long dpId : dpns) {
+ Collection<BigInteger> dpns = vpnmanager.getDpnsForVpn(vpnId);
+ for (BigInteger dpId : dpns) {
deleteRoute(dpId, vpnId, vrfTableKey, vrfEntry);
}
}
- public void deleteRoute(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey,
+ 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();
+ ((rawIpAddress[2] & 0xFF) << (1 * 8)) + (rawIpAddress[3] & 0xFF)) & 0xffffffffL;
}
- private void makeConnectedRoute(long dpId, long vpnId, VrfEntry vrfEntry, String rd,
+ 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("/");
}
}
- private void makeLFibTableEntry(long dpId, long label, long groupId,
+ private void makeLFibTableEntry(BigInteger dpId, long label, long groupId,
String nextHop, int addOrRemove) {
List<MatchInfo> matches = new ArrayList<MatchInfo>();
matches.add(new MatchInfo(MatchFieldType.eth_type,
LOG.debug("LFIB Entry for dpID {} : label : {} group {} modified successfully {}",dpId, label, groupId );
}
- private void deleteLocalAdjacency(final long dpId, final long vpnId, final VrfEntry vrfEntry) {
+ 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<RpcResult<Void>> result =
}
}
- public void populateFibOnNewDpn(long dpnId, long vpnId, String rd) {
+ public void populateFibOnNewDpn(BigInteger dpnId, long vpnId, String rd) {
LOG.trace("New dpn {} for vpn {} : populateFibOnNewDpn", dpnId, rd);
InstanceIdentifier<VrfTables> id = buildVrfId(rd);
Optional<VrfTables> vrfTable = read(LogicalDatastoreType.CONFIGURATION, id);
}
}
- public void cleanUpDpnForVpn(long dpnId, long vpnId, String rd) {
+ public void cleanUpDpnForVpn(BigInteger dpnId, long vpnId, String rd) {
LOG.trace("Remove dpn {} for vpn {} : cleanUpDpnForVpn", dpnId, rd);
InstanceIdentifier<VrfTables> id = buildVrfId(rd);
Optional<VrfTables> vrfTable = read(LogicalDatastoreType.CONFIGURATION, id);
return id;
}
- private String getFlowRef(long dpnId, short tableId, long label, String nextHop) {
+ 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();
}
- protected GetEgressPointerOutput resolveAdjacency(final long dpId, final long vpnId,
+ 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);;
return vpnId;
}
- public void processNodeAdd(long dpnId) {
+ public void processNodeAdd(BigInteger dpnId) {
LOG.debug("Received notification to install TableMiss entries for dpn {} ", dpnId);
makeTableMissFlow(dpnId, NwConstants.ADD_FLOW);
}
- private void makeTableMissFlow(long dpnId, int addOrRemove) {
+ private void makeTableMissFlow(BigInteger dpnId, int addOrRemove) {
final BigInteger COOKIE_TABLE_MISS = new BigInteger("1030000", 16);
// Instruction to punt to controller
List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
}
}
- private String getFlowRef(long dpnId, short tableId, int tableMiss) {
+ 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();
*/
package org.opendaylight.vpnservice.fibmanager;
+import java.math.BigInteger;
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 void populateFibOnNewDpn(long dpnId, long vpnId, String rd) {
+ public void populateFibOnNewDpn(BigInteger dpnId, long vpnId, String rd) {
fibManager.populateFibOnNewDpn(dpnId, vpnId, rd);
}
@Override
- public void cleanUpDpnForVpn(long dpnId, long vpnId, String rd) {
+ public void cleanUpDpnForVpn(BigInteger dpnId, long vpnId, String rd) {
fibManager.cleanUpDpnForVpn(dpnId, vpnId, rd);
}
}
package org.opendaylight.vpnservice.fibmanager;
+import java.math.BigInteger;
+
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
protected void add(InstanceIdentifier<FlowCapableNode> identifier, FlowCapableNode node) {
LOG.trace("FlowCapableNode Added: key: " + identifier + ", value=" + node );
NodeKey nodeKey = identifier.firstKeyOf(Node.class, NodeKey.class);
- long dpnId = MDSALUtil.getDpnIdFromNodeName(nodeKey.getId());
+ BigInteger dpnId = MDSALUtil.getDpnIdFromNodeName(nodeKey.getId());
fibManager.processNodeAdd(dpnId);
}
*/
package org.opendaylight.vpnservice.fibmanager.test;
+import java.math.BigInteger;
+
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
-
import static org.junit.Assert.*;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
-
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.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
MockDataChangedEvent dataChangeEvent;
FibManager fibmgr;
- Long EgressPointer = 11L;
+ private static final Long EgressPointer = 11L;
VrfEntry vrfEntry;
InstanceIdentifier<VrfEntry> identifier;
VrfEntryBuilder vrfbuilder;
- String rd = "routeDis";
- String prefix = "0.1.2.3";
- String nexthop = "1.1.1.1";
- int label = 10;
- List<Long> Dpns;
+ private static final String rd = "routeDis";
+ private static final String prefix = "0.1.2.3";
+ private static final String nexthop = "1.1.1.1";
+ private static final int label = 10;
+ List<BigInteger> Dpns;
+ private static final long vpnId = 101L;
private void SetupMocks() {
- Dpns = new ArrayList<Long>();
- Dpns.add(100000L);
+ Dpns = new ArrayList<BigInteger>();
+ Dpns.add(BigInteger.valueOf(100000L));
identifier = buildVrfEntryId(rd, prefix);
vrfEntry = buildVrfEntry(rd, prefix, nexthop, label);
fibmgr.setMdsalManager(mdsalManager);
dataChangeEvent = new MockDataChangedEvent();
vrfbuilder = new VrfEntryBuilder();
fibmgr = new FibManager(dataBroker, l3nexthopService) {
- protected GetEgressPointerOutput resolveAdjacency(final long dpId, final long vpnId,
+ protected GetEgressPointerOutput resolveAdjacency(final BigInteger dpId, final long vpnId,
final VrfEntry vrfEntry) {
return adjacency;
}
protected Long getVpnId(String rd) {
- return 101L;
+ return vpnId;
}
};
SetupMocks();
package org.opendaylight.vpnservice.interfacemgr.interfaces;
+import java.math.BigInteger;
+
import java.util.List;
import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
public interface IInterfaceManager {
public Long getPortForInterface(String ifName);
- public long getDpnForInterface(String ifName);
- public String getEndpointIpForDpn(long dpnId);
+ public BigInteger getDpnForInterface(String ifName);
+ public String getEndpointIpForDpn(BigInteger dpnId);
public List<MatchInfo> getInterfaceIngressRule(String ifName);
public List<ActionInfo> getInterfaceEgressActions(String ifName);
*/
package org.opendaylight.vpnservice.interfacemgr;
+import java.math.BigInteger;
+
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;
}
- public static NodeId buildDpnNodeId(long dpnId) {
+ public static NodeId buildDpnNodeId(BigInteger dpnId) {
return new NodeId(IfmConstants.OF_URI_PREFIX + dpnId);
}
*/
package org.opendaylight.vpnservice.interfacemgr;
+import java.math.BigInteger;
+
import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
return getPortNumForInterface(iface);
}
- long getDpnForInterface(String ifName) {
+ BigInteger getDpnForInterface(String ifName) {
Interface iface = getInterfaceByIfName(ifName);
try {
NodeConnector port = getNodeConnectorFromDataStore(iface);
//TODO: This should be an MDSAL Util method
- return Long.parseLong(IfmUtil.getDpnFromNodeConnectorId(port.getId()));
+ return new BigInteger(IfmUtil.getDpnFromNodeConnectorId(port.getId()));
} catch (NullPointerException e) {
LOG.error("dpn for Interface {} not found", ifName);
}
- return 0L;
+ return BigInteger.ZERO;
}
- String getEndpointIpForDpn(long dpnId) {
+ String getEndpointIpForDpn(BigInteger dpnId) {
//TODO: This should be MDSAL Util function
NodeId dpnNodeId = IfmUtil.buildDpnNodeId(dpnId);
return dbDpnEndpoints.get(dpnNodeId);
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}));
+ matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[] {dpn, BigInteger.valueOf(portNo)}));
if (ifType.isInstance(L2vlan.class)) {
IfL2vlan vlanIface = iface.getAugmentation(IfL2vlan.class);
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();
if (iface.isEnabled()) {
}
@Override
- public long getDpnForInterface(String ifName) {
+ public BigInteger getDpnForInterface(String ifName) {
return interfaceManager.getDpnForInterface(ifName);
}
@Override
- public String getEndpointIpForDpn(long dpnId) {
+ public String getEndpointIpForDpn(BigInteger dpnId) {
return interfaceManager.getEndpointIpForDpn(dpnId);
}
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.when;
+import java.math.BigInteger;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
@Test
public void testDpnConversions() {
- String NodeId = IfmUtil.buildDpnNodeId(101L).getValue();
+ String NodeId = IfmUtil.buildDpnNodeId(BigInteger.valueOf(101)).getValue();
assertEquals("openflow:101", NodeId);
when(ncId.getValue()).thenReturn("openflow:101:11");
assertEquals("101",IfmUtil.getDpnFromNodeConnectorId(ncId));
*/
package org.opendaylight.vpnservice.mdsalutil;
+import java.math.BigInteger;
+
public class AbstractSwitchEntity {
private static final long serialVersionUID = 1L;
- private long m_lDpnId;
-
+ private BigInteger m_dpnId;
- public AbstractSwitchEntity(long lDpnId) {
- m_lDpnId = lDpnId;
+ public AbstractSwitchEntity(BigInteger dpnId) {
+ m_dpnId = dpnId;
}
@Override
public String toString() {
- return "AbstractSwitchEntity [m_lDpnId=" + m_lDpnId + " ]";
+ return "AbstractSwitchEntity [m_lDpnId=" + m_dpnId + " ]";
}
- public long getDpnId() {
- return m_lDpnId;
+ public BigInteger getDpnId() {
+ return m_dpnId;
}
- public void setDpnId(long lDpnId) {
- m_lDpnId = lDpnId;
+ public void setDpnId(BigInteger dpnId) {
+ m_dpnId = dpnId;
}
}
private transient FlowBuilder m_flowBuilder;
- public FlowEntity(long lDpnId) {
- super(lDpnId);
+ public FlowEntity(BigInteger dpnId) {
+ super(dpnId);
}
@Override
*/
package org.opendaylight.vpnservice.mdsalutil;
-import java.util.List;
+import java.math.BigInteger;
+import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
private transient GroupBuilder m_groupBuilder;
- public GroupEntity(long lDpnId) {
- super(lDpnId);
+ public GroupEntity(BigInteger dpnId) {
+ super(dpnId);
}
@Override
new ArrayList<Instruction>()).build();
private static final Match EMPTY_Matches = new MatchBuilder().build();
- public static FlowEntity buildFlowEntity(long dpnId, short tableId, String flowId, int priority, String flowName,
+ public static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, String flowId, int priority, String flowName,
int idleTimeOut, int hardTimeOut, BigInteger cookie, List<MatchInfo> listMatchInfo,
List<InstructionInfo> listInstructionInfo) {
.setCookie(new FlowCookie(cookie)).build();
}
- public static GroupEntity buildGroupEntity(long dpnId, long groupId, String groupName, GroupTypes groupType,
+ public static GroupEntity buildGroupEntity(BigInteger dpnId, long groupId, String groupName, GroupTypes groupType,
List<BucketInfo> listBucketInfo) {
GroupEntity groupEntity = new GroupEntity(dpnId);
return groupEntity;
}
- public static TransmitPacketInput getPacketOutDefault(List<ActionInfo> actionInfos, byte[] payload, long dpnId) {
+ public static TransmitPacketInput getPacketOutDefault(List<ActionInfo> actionInfos, byte[] payload, BigInteger dpnId) {
return new TransmitPacketInputBuilder()
.setAction(buildActions(actionInfos))
.setPayload(payload)
}
// TODO: Check the port const
- public static NodeConnectorRef getDefaultNodeConnRef(long nDpId) {
+ public static NodeConnectorRef getDefaultNodeConnRef(BigInteger nDpId) {
return getNodeConnRef(NODE_PREFIX + SEPARATOR + nDpId, "0xfffffffd");
}
- public static NodeConnectorRef getNodeConnRef(long nDpId, String port) {
+ public static NodeConnectorRef getNodeConnRef(BigInteger nDpId, String port) {
return getNodeConnRef(NODE_PREFIX + SEPARATOR + nDpId, port);
}
return nodeConnectorRef;
}
- public static long getDpnIdFromNodeName(NodeId nodeId) {
+ public static BigInteger getDpnIdFromNodeName(NodeId nodeId) {
return getDpnIdFromNodeName(nodeId.getValue());
}
- public static long getDpnIdFromNodeName(String sMdsalNodeName) {
+ public static BigInteger getDpnIdFromNodeName(String sMdsalNodeName) {
String sDpId = sMdsalNodeName.substring(sMdsalNodeName.lastIndexOf(":") + 1);
- return Long.parseLong(sDpId);
+ return new BigInteger(sDpId);
}
public static long getOfPortNumberFromPortName(NodeConnectorId nodeConnectorId) {
String sPortNumber = sMdsalPortName.substring(sMdsalPortName.lastIndexOf(":") + 1);
return Long.parseLong(sPortNumber);
}
+
+ public static TransmitPacketInput getPacketOut(List<ActionInfo> actionInfos, byte[] payload, BigInteger dpnId,
+ NodeConnectorRef nodeConnRef) {
+ // TODO Auto-generated method stub
+ return null;
+ }
}
*/
package org.opendaylight.vpnservice.mdsalutil.interfaces;
+import java.math.BigInteger;
import java.util.List;
import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
public void removeGroup(GroupEntity groupEntity);
- public void sendPacketOut(long lDpnId, int groupId, byte[] payload);
+ public void sendPacketOut(BigInteger dpnId, int groupId, byte[] payload);
- public void sendPacketOutWithActions(long lDpnId, long groupId, byte[] payload, List<ActionInfo> actionInfos);
+ public void sendPacketOutWithActions(BigInteger dpnId, long groupId, byte[] payload, List<ActionInfo> actionInfos);
- public void sendARPPacketOutWithActions(long dpid, byte[] payload, List<ActionInfo> action_info);
+ public void sendARPPacketOutWithActions(BigInteger dpnId, byte[] payload, List<ActionInfo> action_info);
}
installGroup(groupEntity);
}
- public void sendPacketOut(long lDpnId, int groupId, byte[] payload) {
+ public void sendPacketOut(BigInteger dpnId, int groupId, byte[] payload) {
List<ActionInfo> actionInfos = new ArrayList<ActionInfo>();
actionInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId) }));
- sendPacketOutWithActions(lDpnId, groupId, payload, actionInfos);
+ sendPacketOutWithActions(dpnId, groupId, payload, actionInfos);
}
- public void sendPacketOutWithActions(long lDpnId, long groupId, byte[] payload, List<ActionInfo> actionInfos) {
+ public void sendPacketOutWithActions(BigInteger dpnId, long groupId, byte[] payload, List<ActionInfo> actionInfos) {
- m_packetProcessingService.transmitPacket(MDSALUtil.getPacketOut(actionInfos, payload, lDpnId,
- getNodeConnRef("openflow:" + lDpnId, "0xfffffffd")));
+ m_packetProcessingService.transmitPacket(MDSALUtil.getPacketOut(actionInfos, payload, dpnId,
+ getNodeConnRef("openflow:" + dpnId, "0xfffffffd")));
}
- public void sendARPPacketOutWithActions(long lDpnId, byte[] payload, List<ActionInfo> actions) {
- m_packetProcessingService.transmitPacket(MDSALUtil.getPacketOut(actions, payload, lDpnId,
- getNodeConnRef("openflow:" + lDpnId, "0xfffffffd")));
+ public void sendARPPacketOutWithActions(BigInteger dpnId, byte[] payload, List<ActionInfo> actions) {
+ m_packetProcessingService.transmitPacket(MDSALUtil.getPacketOut(actions, payload, dpnId,
+ getNodeConnRef("openflow:" + dpnId, "0xfffffffd")));
}
public InstanceIdentifier<Node> nodeToInstanceId(Node node) {
return _nodeConnectorRef;
}
- private Node buildDpnNode(long lDpnId) {
- NodeId nodeId = new NodeId("openflow:" + lDpnId);
+ private Node buildDpnNode(BigInteger dpnId) {
+ NodeId nodeId = new NodeId("openflow:" + dpnId);
Node nodeDpn = new NodeBuilder().setId(nodeId).setKey(new NodeKey(nodeId)).build();
return nodeDpn;
*/
package org.opendaylight.vpnservice.mdsalutil.internal;
-import java.util.List;
+import java.math.BigInteger;
+import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareConsumer;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ConsumerContext;
@Override
- public void sendPacketOut(long lDpnId, int groupId, byte[] payload) {
- mdSalMgr.sendPacketOut(lDpnId, groupId, payload);
+ public void sendPacketOut(BigInteger dpnId, int groupId, byte[] payload) {
+ mdSalMgr.sendPacketOut(dpnId, groupId, payload);
}
@Override
- public void sendPacketOutWithActions(long lDpnId, long groupId,
+ public void sendPacketOutWithActions(BigInteger dpnId, long groupId,
byte[] payload, List<ActionInfo> actionInfos) {
- mdSalMgr.sendPacketOutWithActions(lDpnId, groupId, payload, actionInfos);
+ mdSalMgr.sendPacketOutWithActions(dpnId, groupId, payload, actionInfos);
}
@Override
- public void sendARPPacketOutWithActions(long dpid, byte[] payload,
+ public void sendARPPacketOutWithActions(BigInteger dpnId, byte[] payload,
List<ActionInfo> action_info) {
- mdSalMgr.sendARPPacketOutWithActions(dpid, payload, action_info);
+ mdSalMgr.sendARPPacketOutWithActions(dpnId, payload, action_info);
}
}
MDSALManager mdSalMgr = null ;
MockFlowForwarder flowFwder = null ;
MockGroupForwarder grpFwder = null ;
+ private static final String Nodeid = "openflow:1";
@Before
public void setUp() throws Exception {
@Test
public void testInstallGroup() {
// Install Group 1
- String Nodeid = "1";
String inport = "2" ;
int vlanid = 100 ;
GroupEntity grpEntity1 = createGroupEntity(Nodeid, inport, vlanid) ;
assertEquals(1, grpFwder.getDataChgCount());
// Install Group 2
- Nodeid = "1";
inport = "3" ;
vlanid = 100 ;
GroupEntity grpEntity2 = createGroupEntity(Nodeid, inport, vlanid) ;
@Test
public void testRemoveGroup() {
- String Nodeid = "1";
String inport = "2" ;
int vlanid = 100 ;
GroupEntity grpEntity = createGroupEntity(Nodeid, inport, vlanid) ;
public FlowEntity createFlowEntity(String dpnId, String tableId) {
- long dpId;
+ BigInteger dpId;
int SERVICE_ID = 0;
FlowEntity terminatingServiceTableFlowEntity = null;
new String[] {}));
try {
- dpId = Long.parseLong(dpnId.split(":")[1]);
+ dpId = new BigInteger(dpnId.split(":")[1]);
List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
BigInteger COOKIE = new BigInteger("9000000", 16);
listBucketInfo.add(new BucketInfo(listActionInfo));
String groupName = "Test Group";
- groupEntity = MDSALUtil.buildGroupEntity(Long.valueOf(Nodeid), id, groupName, GroupTypes.GroupIndirect,
+ BigInteger dpnId = new BigInteger(Nodeid.split(":")[1]);
+ groupEntity = MDSALUtil.buildGroupEntity(dpnId, id, groupName, GroupTypes.GroupIndirect,
listBucketInfo);
return groupEntity;
private static long getUniqueValue(String nodeId, String inport) {
- Long nodeIdL = Long.valueOf(nodeId);
+ Long nodeIdL = Long.valueOf(nodeId.split(":")[1]);
Long inportL = Long.valueOf(inport);
long sd_set;
sd_set = nodeIdL * 10 + inportL;
module l3nexthop {
- namespace "urn:opendaylight:vpnservice:l3nexthop";
- prefix l3nexthop;
-
- revision "2015-04-09" {
- description "L3 NextHop module";
- }
+ namespace "urn:opendaylight:vpnservice:l3nexthop";
+ prefix l3nexthop;
- container l3nexthop {
- config false;
- list vpnNexthops{
- key "vpnId";
- leaf vpnId {type uint32;}
- list vpnNexthop{
- key "IpAddress";
- leaf IpAddress {type string;}
- leaf egressPointer {type uint32;}
- }
- }
- list tunnelNexthops{
- key "dpnId";
- leaf dpnId {type uint32;}
- list tunnelNexthop{
- key "IpAddress";
- leaf IpAddress {type string;}
- leaf egressPointer {type uint32;}
- }
- }
- }
-
- rpc getEgressPointer {
- description "returns egress pointer, an OF Group Id";
- input {
- leaf dpnId {type uint32;}
- leaf vpnId { type uint32;} /* optional */
- leaf ipPrefix {type string;}
- leaf nexthopIp {type string;}
- }
- output {
- leaf egressPointer {type uint32;}
- leaf localDestination {type boolean;}
- }
- }
+ revision "2015-04-09" {
+ description "L3 NextHop module";
+ }
- rpc removeLocalNextHop {
- description "remove a local next hop";
- input {
- leaf dpnId {type uint32;}
- leaf vpnId { type uint32;} /* optional */
- leaf ipPrefix {type string;}
- leaf nexthopIp {type string;}
- }
- }
+ container l3nexthop {
+ config false;
+ list vpnNexthops{
+ key "vpnId";
+ leaf vpnId {type uint32;}
+ list vpnNexthop{
+ key "IpAddress";
+ leaf IpAddress {type string;}
+ leaf egressPointer {type uint32;}
+ }
+ }
+ list tunnelNexthops{
+ key "dpnId";
+ leaf dpnId {type uint64;}
+ list tunnelNexthop{
+ key "IpAddress";
+ leaf IpAddress {type string;}
+ leaf egressPointer {type uint32;}
+ }
+ }
+ }
+
+ rpc getEgressPointer {
+ description "returns egress pointer, an OF Group Id";
+ input {
+ leaf dpnId {type uint64;}
+ leaf vpnId { type uint32;} /* optional */
+ leaf ipPrefix {type string;}
+ leaf nexthopIp {type string;}
+ }
+ output {
+ leaf egressPointer {type uint32;}
+ leaf localDestination {type boolean;}
+ }
+ }
+
+ rpc removeLocalNextHop {
+ description "remove a local next hop";
+ input {
+ leaf dpnId {type uint64;}
+ leaf vpnId { type uint32;} /* optional */
+ leaf ipPrefix {type string;}
+ leaf nexthopIp {type string;}
+ }
+ }
}
\ No newline at end of file
}
}
- 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;
}
int groupId = createNextHopPointer(nhKey);
long vpnId = getVpnId(vpnName);
- long dpnId = interfaceManager.getDpnForInterface(ifName);
+ BigInteger dpnId = interfaceManager.getDpnForInterface(ifName);
VpnNexthop nexthop = getVpnNexthop(vpnId, ipAddress, 0);
LOG.trace("nexthop: {}", nexthop);
if (nexthop == null) {
String nhKey = new String("nexthop." + ifName + ipAddress);
int groupId = createNextHopPointer(nhKey);
- long dpnId = getDpnId(ofPortId);
+ BigInteger dpnId = getDpnId(ofPortId);
TunnelNexthop nexthop = getTunnelNexthop(dpnId, ipAddress);
if (nexthop == null) {
List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
}
}
- private void makeRemoteFlow(long dpId, String ifName, int addOrRemoveFlow) {
+ private void makeRemoteFlow(BigInteger dpnId, String ifName, int addOrRemoveFlow) {
long portNo = 0;
String flowName = ifName;
- String flowRef = getTunnelInterfaceFlowRef(dpId, LPORT_INGRESS_TABLE, ifName);
+ String flowRef = getTunnelInterfaceFlowRef(dpnId, LPORT_INGRESS_TABLE, ifName);
List<MatchInfo> matches = new ArrayList<MatchInfo>();
List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
if (NwConstants.ADD_FLOW == addOrRemoveFlow) {
portNo = interfaceManager.getPortForInterface(ifName);
- matches.add(new MatchInfo(MatchFieldType.in_port, new long[] {
- dpId, portNo }));
+ matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[] {
+ dpnId, BigInteger.valueOf(portNo) }));
mkInstructions.add(new InstructionInfo(InstructionType.goto_table, new long[] {LFIB_TABLE}));
}
BigInteger COOKIE_VM_INGRESS_TABLE = new BigInteger("8000001", 16);
- FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, LPORT_INGRESS_TABLE, flowRef,
+ FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpnId, LPORT_INGRESS_TABLE, flowRef,
DEFAULT_FLOW_PRIORITY, flowName, 0, 0, COOKIE_VM_INGRESS_TABLE, matches, mkInstructions);
if (NwConstants.ADD_FLOW == addOrRemoveFlow) {
}
}
- private String getTunnelInterfaceFlowRef(long dpId, short tableId, String ifName) {
- return new StringBuilder().append(dpId).append(tableId).append(ifName).toString();
+ 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) {
}
- private void addTunnelNexthopToDS(long dpnId, String ipPrefix, long egressPointer) {
+ private void addTunnelNexthopToDS(BigInteger dpnId, String ipPrefix, long egressPointer) {
InstanceIdentifierBuilder<TunnelNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
.child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId));
return null;
}
- private TunnelNexthop getTunnelNexthop(long dpnId, String ipAddress) {
+ private TunnelNexthop getTunnelNexthop(BigInteger dpnId, String ipAddress) {
InstanceIdentifierBuilder<TunnelNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
.child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId));
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, 0);
}
}
- private void removeTunnelNexthopFromDS(long dpnId, String ipPrefix) {
+ private void removeTunnelNexthopFromDS(BigInteger dpnId, String ipPrefix) {
InstanceIdentifierBuilder<TunnelNexthop> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
.child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId))
}
- public void removeLocalNextHop(Long dpId, Long vpnId, String ipAddress) {
+ public void removeLocalNextHop(BigInteger dpnId, Long vpnId, String 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(
- dpId, nh.getEgressPointer(), ipAddress, GroupTypes.GroupIndirect, null);
+ dpnId, nh.getEgressPointer(), ipAddress, GroupTypes.GroupIndirect, null);
// remove Group ...
mdsalManager.removeGroup(groupEntity);
//update MD-SAL DS
}
- public void removeRemoteNextHop(long dpnId, String ifName, String ipAddress) {
+ public void removeRemoteNextHop(BigInteger dpnId, String ifName, String ipAddress) {
TunnelNexthop nh = getTunnelNexthop(dpnId, ipAddress);
if (nh != null) {
package org.opendaylight.vpnservice.nexthopmgr;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
-
+import java.math.BigInteger;
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.InstanceIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
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.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.L3tunnel;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
Interface intrf) {
LOG.trace("Removing interface : key: " + identifier + ", value=" + intrf );
if (intrf.getType().equals(L3tunnel.class)) {
- long dpnId = interfaceManager.getDpnForInterface(intrf.getName());
+ BigInteger dpnId = interfaceManager.getDpnForInterface(intrf.getName());
IfL3tunnel intfData = intrf.getAugmentation(IfL3tunnel.class);
IpAddress gatewayIp = intfData.getGatewayIp();
IpAddress remoteIp = (gatewayIp == null) ? intfData.getRemoteIp() : gatewayIp;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
+import java.math.BigInteger;
+
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.L3nexthop;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.VpnNexthopsKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
-
import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import java.lang.reflect.InvocationTargetException;
private final String ipAddress = "1.1.1.1";
private final String macAddress = "11:22:33:44:55:66";
private final int groupId = 5000;
- private final long dpId = 1L;
+ private final BigInteger dpId = BigInteger.ONE;
private final long vpnId = 2L;
Map<InstanceIdentifier<?>, DataObject> written = new HashMap<>();
package org.opendaylight.vpnmanager.api;
-import java.util.Collection;
+import java.math.BigInteger;
+import java.util.Collection;
import org.opendaylight.fibmanager.api.IFibManager;
public interface IVpnManager {
- Collection<Long> getDpnsForVpn(long vpnId);
+ Collection<BigInteger> getDpnsForVpn(long vpnId);
void setFibService(IFibManager fibManager);
}
private IMdsalApiManager mdsalManager;
private IInterfaceManager interfaceManager;
private IdManagerService idManager;
- private Map<Long, Collection<Long>> vpnToDpnsDb;
- private Map<Long, Collection<String>> dpnToInterfaceDb;
+ private Map<Long, Collection<BigInteger>> vpnToDpnsDb;
+ private Map<BigInteger, Collection<String>> dpnToInterfaceDb;
private static final FutureCallback<Void> DEFAULT_CALLBACK =
new FutureCallback<Void>() {
//Get the rd of the vpn instance
String rd = getRouteDistinguisher(intf.getVpnInstanceName());
- long dpnId = interfaceManager.getDpnForInterface(intfName);
+ BigInteger dpnId = interfaceManager.getDpnForInterface(intfName);
String nextHopIp = interfaceManager.getEndpointIpForDpn(dpnId);
return rd;
}
- private synchronized void updateMappingDbs(long vpnId, long dpnId, String intfName, String rd) {
- Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
+ private synchronized void updateMappingDbs(long vpnId, BigInteger dpnId, String intfName, String rd) {
+ Collection<BigInteger> dpnIds = vpnToDpnsDb.get(vpnId);
if(dpnIds == null) {
dpnIds = new HashSet<>();
}
dpnToInterfaceDb.put(dpnId, intfNames);
}
- private synchronized void remoteFromMappingDbs(long vpnId, long dpnId, String inftName, String rd) {
+ private synchronized void remoteFromMappingDbs(long vpnId, BigInteger dpnId, String inftName, String rd) {
Collection<String> intfNames = dpnToInterfaceDb.get(dpnId);
if(intfNames == null) {
return;
dpnToInterfaceDb.put(dpnId, intfNames);
//TODO: Delay 'DPN' removal so that other services can cleanup the entries for this dpn
if(intfNames.isEmpty()) {
- Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
+ Collection<BigInteger> dpnIds = vpnToDpnsDb.get(vpnId);
if(dpnIds == null) {
return;
}
LOG.trace("Bind service on interface {} for VPN: {}", intf, vpnName);
long vpnId = getVpnId(vpnName);
- long dpId = interfaceManager.getDpnForInterface(intf.getName());
- if(dpId == 0L) {
+ BigInteger dpId = interfaceManager.getDpnForInterface(intf.getName());
+ if(dpId.equals(BigInteger.ZERO)) {
LOG.warn("DPN for interface {} not found. Bind service on this interface aborted.", intf.getName());
return;
} else {
mkInstructions.add(new InstructionInfo(InstructionType.goto_table, new long[] { gotoTableId }));
List<MatchInfo> matches = new ArrayList<MatchInfo>();
- matches.add(new MatchInfo(MatchFieldType.in_port, new long[] {
- dpId, portNo }));
+ matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[] {
+ dpId, BigInteger.valueOf(portNo) }));
FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, VpnConstants.LPORT_INGRESS_TABLE, flowRef,
priority, flowName, 0, 0, COOKIE_VM_INGRESS_TABLE, matches, mkInstructions);
mdsalManager.installFlow(flowEntity);
}
- private String getVpnInterfaceFlowRef(long dpId, short tableId,
+ private String getVpnInterfaceFlowRef(BigInteger dpId, short tableId,
long vpnId, long portNo) {
return new StringBuilder().append(dpId).append(tableId).append(vpnId).append(portNo).toString();
}
LOG.trace("Unbind service on interface {} for VPN: {}", intf, vpnName);
long vpnId = getVpnId(vpnName);
- long dpId = interfaceManager.getDpnForInterface(intf.getName());
- if(dpId == 0L) {
+ BigInteger dpId = interfaceManager.getDpnForInterface(intf.getName());
+ if(dpId.equals(BigInteger.ZERO)) {
LOG.warn("DPN for interface {} not found. Unbind service on this interface aborted.", intf.getName());
return;
} else {
int priority = VpnConstants.DEFAULT_FLOW_PRIORITY;
List<MatchInfo> matches = new ArrayList<MatchInfo>();
- matches.add(new MatchInfo(MatchFieldType.in_port, new long[] {
- dpId, portNo }));
+ matches.add(new MatchInfo(MatchFieldType.in_port, new BigInteger[] {
+ dpId, BigInteger.valueOf(portNo) }));
FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, VpnConstants.LPORT_INGRESS_TABLE, flowRef,
priority, flowName, 0, 0, null, matches, null);
tx.submit();
}
- synchronized Collection<Long> getDpnsForVpn(long vpnId) {
- Collection<Long> dpnIds = vpnToDpnsDb.get(vpnId);
+ synchronized Collection<BigInteger> getDpnsForVpn(long vpnId) {
+ Collection<BigInteger> dpnIds = vpnToDpnsDb.get(vpnId);
if(dpnIds != null) {
return ImmutableList.copyOf(dpnIds);
} else {
}
@Override
- public Collection<Long> getDpnsForVpn(long vpnId) {
+ public Collection<BigInteger> getDpnsForVpn(long vpnId) {
return vpnInterfaceManager.getDpnsForVpn(vpnId);
}