Adding Encapsulation in VPLS and correcting bugs.
Change-Id: Idc0c1834ae2bbd0fdaf564fd65360cc0f018d18d
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java
index 90e3415..66edd13 100644
--- a/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java
@@ -19,6 +19,7 @@
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Maps;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.Sets;
import org.junit.After;
@@ -41,6 +42,7 @@
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.DefaultHost;
import org.onosproject.net.DeviceId;
+import org.onosproject.net.EncapsulationType;
import org.onosproject.net.Host;
import org.onosproject.net.HostId;
import org.onosproject.net.HostLocation;
@@ -48,9 +50,9 @@
import org.onosproject.net.host.HostService;
import org.onosproject.net.host.HostServiceAdapter;
import org.onosproject.net.provider.ProviderId;
-import org.onosproject.vpls.config.VplsConfigurationService;
import java.util.Collection;
+import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
@@ -61,81 +63,88 @@
* Tests the the {@link VplsNeighbourHandler} class.
*/
public class VplsNeighbourHandlerTest {
- private final ConnectPoint of1p1 =
- new ConnectPoint(DeviceId.deviceId("of:1"),
- PortNumber.portNumber(1));
- private final ConnectPoint of4p1 =
- new ConnectPoint(DeviceId.deviceId("of:4"),
- PortNumber.portNumber(1));
- private final ConnectPoint of3p1 =
- new ConnectPoint(DeviceId.deviceId("of:3"),
- PortNumber.portNumber(1));
- private final ConnectPoint of4p2 =
- new ConnectPoint(DeviceId.deviceId("of:4"),
- PortNumber.portNumber(2));
- private final ConnectPoint of2p1 =
- new ConnectPoint(DeviceId.deviceId("of:2"),
- PortNumber.portNumber(1));
- private final VlanId vlan100 = VlanId.vlanId("100");
- private final VlanId vlan200 = VlanId.vlanId("200");
- private final VlanId vlan300 = VlanId.vlanId("300");
+ private static final String IFACES_NOT_EXPECTED =
+ "The interfaces reached by the packet are not equal to the " +
+ "interfaces expected";
- private final Interface v100h1 =
- new Interface("v100h1", of1p1, null, null, vlan100);
- private final Interface v100h2 =
- new Interface("v100h2", of4p1, null, null, vlan100);
- private final Interface v200h1 =
- new Interface("v200h1", of4p2, null, null, vlan200);
- private final Interface v300h1 =
- new Interface("v300h1", of3p1, null, null, vlan300);
- private final Interface v200h2 =
- new Interface("v200h2", of2p1, null, null, vlan200);
+ private static final DeviceId DID1 = getDeviceId(1);
+ private static final DeviceId DID2 = getDeviceId(2);
+ private static final DeviceId DID3 = getDeviceId(3);
+ private static final DeviceId DID4 = getDeviceId(4);
- private final MacAddress mac1 = MacAddress.valueOf("00:00:00:00:00:01");
- private final MacAddress mac2 = MacAddress.valueOf("00:00:00:00:00:02");
- private final MacAddress mac3 = MacAddress.valueOf("00:00:00:00:00:03");
- private final MacAddress mac4 = MacAddress.valueOf("00:00:00:00:00:04");
- private final MacAddress mac5 = MacAddress.valueOf("00:00:00:00:00:05");
+ private static final PortNumber P1 = PortNumber.portNumber(1);
+ private static final PortNumber P2 = PortNumber.portNumber(2);
- private final ProviderId pid = new ProviderId("of", "foo");
+ private static final ConnectPoint OF1P1 = new ConnectPoint(DID1, P1);
+ private static final ConnectPoint OF2P1 = new ConnectPoint(DID2, P1);
+ private static final ConnectPoint OF3P1 = new ConnectPoint(DID3, P1);
+ private static final ConnectPoint OF4P1 = new ConnectPoint(DID4, P1);
+ private static final ConnectPoint OF4P2 = new ConnectPoint(DID4, P2);
- private final Host v100host1 = makeHost(mac1, vlan100, of1p1);
- private final Host v100host2 = makeHost(mac2, vlan100, of4p1);
- private final Host v200host1 = makeHost(mac3, vlan200, of4p2);
- private final Host v300host1 = makeHost(mac4, vlan300, of3p1);
- private final Host v200host2 = makeHost(mac5, vlan200, of2p1);
+ private static final String VPLS1 = "vpls1";
+ private static final String VPLS2 = "vpls2";
- private final Set<Host> availableHosts = ImmutableSet.of(v100host1,
- v100host2,
- v200host1,
- v300host1,
- v200host2);
+ private static final VlanId VLAN100 = VlanId.vlanId("100");
+ private static final VlanId VLAN200 = VlanId.vlanId("200");
+ private static final VlanId VLAN300 = VlanId.vlanId("300");
- private final Set<Interface> avaliableInterfaces =
- ImmutableSet.of(v100h1, v100h2, v200h1, v200h2, v300h1);
+ private static final Interface V100H1 =
+ new Interface("v100h1", OF1P1, null, null, VLAN100);
+ private static final Interface V100H2 =
+ new Interface("v100h2", OF4P1, null, null, VLAN100);
+ private static final Interface V200H1 =
+ new Interface("v200h1", OF4P2, null, null, VLAN200);
+ private static final Interface V200H2 =
+ new Interface("v200h2", OF2P1, null, null, VLAN200);
+ private static final Interface V300H1 =
+ new Interface("v300h1", OF3P1, null, null, VLAN300);
+
+ private static final MacAddress MAC1 = MacAddress.valueOf("00:00:00:00:00:01");
+ private static final MacAddress MAC2 = MacAddress.valueOf("00:00:00:00:00:02");
+ private static final MacAddress MAC3 = MacAddress.valueOf("00:00:00:00:00:03");
+ private static final MacAddress MAC4 = MacAddress.valueOf("00:00:00:00:00:04");
+ private static final MacAddress MAC5 = MacAddress.valueOf("00:00:00:00:00:05");
+
+ private static final ProviderId PID = new ProviderId("of", "foo");
+
+ private final Host v100Host1 = makeHost(MAC1, VLAN100, OF1P1);
+ private final Host v100Host2 = makeHost(MAC2, VLAN100, OF4P1);
+ private final Host v200Host1 = makeHost(MAC3, VLAN200, OF4P2);
+ private final Host v200Host2 = makeHost(MAC5, VLAN200, OF2P1);
+ private final Host v300Host1 = makeHost(MAC4, VLAN300, OF3P1);
+
+ private final Set<Host> availableHosts = ImmutableSet.of(v100Host1,
+ v100Host2,
+ v200Host1,
+ v300Host1,
+ v200Host2);
+
+ private final Set<Interface> availableInterfaces =
+ ImmutableSet.of(V100H1, V100H2, V200H1, V200H2, V300H1);
private VplsNeighbourHandler vplsNeighbourHandler;
private HostService hostService;
/**
- * Sets up 2 VPLS which contain 2 networks and 5 hosts.
- * net1 contains 3 hosts: v100h1, v200h1 and v300h1
- * net2 contains 2 hosts: v100h2, v200h2
+ * Sets up 2 VPLS.
+ * VPLS 1 contains 3 hosts: v100h1, v200h1 and v300h1
+ * VPLS 2 contains 2 hosts: v100h2, v200h2
*/
@Before
public void setUp() {
vplsNeighbourHandler = new VplsNeighbourHandler();
- SetMultimap<String, Interface> vplsNetworks =
+ SetMultimap<String, Interface> ifacesByVpls =
HashMultimap.create();
- vplsNetworks.put("net1", v100h1);
- vplsNetworks.put("net1", v200h1);
- vplsNetworks.put("net1", v300h1);
- vplsNetworks.put("net2", v100h2);
- vplsNetworks.put("net2", v200h2);
+ ifacesByVpls.put(VPLS1, V100H1);
+ ifacesByVpls.put(VPLS1, V200H1);
+ ifacesByVpls.put(VPLS1, V300H1);
+ ifacesByVpls.put(VPLS2, V100H2);
+ ifacesByVpls.put(VPLS2, V200H2);
+ HashMap<String, EncapsulationType> encap = Maps.newHashMap();
vplsNeighbourHandler.vplsConfigService =
- new TestVplsConfigService(vplsNetworks);
+ new TestVplsConfigService(ifacesByVpls, encap);
vplsNeighbourHandler.interfaceService =
new TestInterfaceService();
vplsNeighbourHandler.neighbourService =
@@ -150,133 +159,133 @@
}
/**
- * Sends request messages to all hosts in VPLS net1.
- * Request messages should be received from other hosts in net1.
+ * Sends request messages to all hosts in VPLS 1.
+ * Request messages should be received from other hosts in VPLS 1.
*/
@Test
- public void testNet1RequestMessage() {
- // Request from v100h1 (net1)
- // Should be received by v200h1 and v300h1
+ public void vpls1RequestMessage() {
+ // Request messages from v100h1 (VPLS 1) should be received by v200h1 and v300h1
TestMessageContext requestMessage =
- makeBroadcastRequestContext(v100host1);
- Set<Interface> expectInterfaces = ImmutableSet.of(v200h1, v300h1);
+ makeBroadcastRequestContext(v100Host1);
+ Set<Interface> expectInterfaces = ImmutableSet.of(V200H1, V300H1);
vplsNeighbourHandler.handleRequest(requestMessage);
- assertEquals(expectInterfaces, requestMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
- // Request from v200h1 (net1)
- // Should be received by v100h1 and v300h1
- requestMessage = makeBroadcastRequestContext(v200host1);
- expectInterfaces = ImmutableSet.of(v100h1, v300h1);
+ // Request messages from v200h1 (VPLS 1) should be received by v100h1 and v300h1
+ requestMessage = makeBroadcastRequestContext(v200Host1);
+ expectInterfaces = ImmutableSet.of(V100H1, V300H1);
vplsNeighbourHandler.handleRequest(requestMessage);
- assertEquals(expectInterfaces, requestMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
- // Request from v300h1 (net1)
- // Should be received by v100h1 and v200h1
- requestMessage = makeBroadcastRequestContext(v300host1);
- expectInterfaces = ImmutableSet.of(v100h1, v200h1);
+ // Request from v300h1 (VPLS 1) should be received by v100h1 and v200h1
+ requestMessage = makeBroadcastRequestContext(v300Host1);
+ expectInterfaces = ImmutableSet.of(V100H1, V200H1);
vplsNeighbourHandler.handleRequest(requestMessage);
- assertEquals(expectInterfaces, requestMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
}
/**
- * Sends request messages to all hosts in VPLS net2.
- * Request messages should be received from other hosts in net2.
+ * Sends request messages to all hosts in VPLS 2.
+ * Request messages should be received from other hosts in VPLS 2.
*/
@Test
- public void testNet2RequestMessage() {
- // Request from v100h2
- // Should be received by v200h2
+ public void vpls2RequestMessage() {
+ // Request messages from v100h2 (VPLS 2) should be received by v200h2
TestMessageContext requestMessage =
- makeBroadcastRequestContext(v100host2);
- Set<Interface> expectInterfaces = ImmutableSet.of(v200h2);
+ makeBroadcastRequestContext(v100Host2);
+ Set<Interface> expectInterfaces = ImmutableSet.of(V200H2);
vplsNeighbourHandler.handleRequest(requestMessage);
- assertEquals(expectInterfaces, requestMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
- // Request from v200h2
- // Should be received by v100h2
- requestMessage = makeBroadcastRequestContext(v200host2);
- expectInterfaces = ImmutableSet.of(v100h2);
+ // Request messages from v200h2 (VPLS 2) should be received by v100h2
+ requestMessage = makeBroadcastRequestContext(v200Host2);
+ expectInterfaces = ImmutableSet.of(V100H2);
vplsNeighbourHandler.handleRequest(requestMessage);
- assertEquals(expectInterfaces, requestMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
}
/**
- * Sends reply messages to hosts in VPLS net1.
+ * Sends reply messages to hosts in VPLS 1.
* Reply messages should be received by the host with MAC address equal to
* the dstMac of the message context.
*/
@Test
- public void testNet1ReplyMessage() {
- // Response from v100h1 (net1) to v200h1 (net1)
- // Should be received by v200h1
+ public void vpls1ReplyMessage() {
+ // Reply messages from v100h1 (VPLS 1) should be received by v200h1
TestMessageContext replyMessage =
- makeReplyContext(v100host1, v200host1);
- Set<Interface> expectInterfaces = ImmutableSet.of(v200h1);
+ makeReplyContext(v100Host1, v200Host1);
+ Set<Interface> expectInterfaces = ImmutableSet.of(V200H1);
vplsNeighbourHandler.handleReply(replyMessage, hostService);
- assertEquals(expectInterfaces, replyMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
- // Response from v200h1 (net1) to v300h1 (net1)
- // Should be received by v300h1
- replyMessage = makeReplyContext(v200host1, v300host1);
- expectInterfaces = ImmutableSet.of(v300h1);
+ // Reply messages from v200h1 (VPLS 1) should be received by v300h1
+ replyMessage = makeReplyContext(v200Host1, v300Host1);
+ expectInterfaces = ImmutableSet.of(V300H1);
vplsNeighbourHandler.handleReply(replyMessage, hostService);
- assertEquals(expectInterfaces, replyMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
- // Response from v300h1 (net1) to v100h1 (net1)
- // Should be received by v100h1
- replyMessage = makeReplyContext(v300host1, v100host1);
- expectInterfaces = ImmutableSet.of(v100h1);
+ // Reply messages from v300h1 (VPLS 1) should be received by v100h1
+ replyMessage = makeReplyContext(v300Host1, v100Host1);
+ expectInterfaces = ImmutableSet.of(V100H1);
vplsNeighbourHandler.handleReply(replyMessage, hostService);
- assertEquals(expectInterfaces, replyMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
}
/**
- * Sends reply messages to hosts in VPLS net2.
+ * Sends reply messages to hosts in VPLS 2.
* Reply messages should be received by the host with MAC address equal to
* the dstMac of the message context.
*/
@Test
- public void testNet2ReplyMessage() {
- // Response from v100h2 (net2) to v200h2 (net2)
- // Should be received by v200h2
+ public void vpls2ReplyMessage() {
+ // Reply messages from v100h2 (VPLS 2) should be received by v200h2
TestMessageContext replyMessage =
- makeReplyContext(v100host2, v200host2);
- Set<Interface> expectInterfaces = ImmutableSet.of(v200h2);
+ makeReplyContext(v100Host2, v200Host2);
+ Set<Interface> expectInterfaces = ImmutableSet.of(V200H2);
vplsNeighbourHandler.handleReply(replyMessage, hostService);
- assertEquals(expectInterfaces, replyMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
- // Response from v200h2 (net2) to v100h2 (net2)
- // Should be received by v100h2
- replyMessage = makeReplyContext(v200host2, v100host2);
- expectInterfaces = ImmutableSet.of(v100h2);
+ // Reply messages from v200h2 (VPLS 2) should be received by v100h2
+ replyMessage = makeReplyContext(v200Host2, v100Host2);
+ expectInterfaces = ImmutableSet.of(V100H2);
vplsNeighbourHandler.handleReply(replyMessage, hostService);
- assertEquals(expectInterfaces, replyMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
}
/**
* Sends wrong reply messages to hosts.
* The source and the destination MAC addresses are not set on any host of the VPLS.
- * The reply messages won't be received by any hosts.
+ * The reply messages will not be received by any hosts.
*/
@Test
- public void testWrongReplyMessage() {
- // Response from v100h1 (net1) to v100h2 (net2)
- // forward results should be empty
- TestMessageContext replyMessage = makeReplyContext(v100host1, v100host2);
+ public void wrongReplyMessage() {
+ // Reply message from v100h1 (VPLS 1) to v100h2 (VPLS 2).
+ // Forward results should be empty
+ TestMessageContext replyMessage = makeReplyContext(v100Host1, v100Host2);
Set<Interface> expectInterfaces = ImmutableSet.of();
vplsNeighbourHandler.handleReply(replyMessage, hostService);
- assertEquals(expectInterfaces, replyMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
- // Response from v200h2 (net2) to v300h1 (net1)
- // forward results should be empty
- replyMessage = makeReplyContext(v200host2, v300host1);
+ // Reply message from v200h2 (VPLS 2) to v300h1 (VPLS 1).
+ // Forward results should be empty
+ replyMessage = makeReplyContext(v200Host2, v300Host1);
expectInterfaces = ImmutableSet.of();
vplsNeighbourHandler.handleReply(replyMessage, hostService);
- assertEquals(expectInterfaces, replyMessage.forwardResults);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
+ }
+
+ /**
+ * Returns the device Id of the ith device.
+ *
+ * @param i the device to get the Id of
+ * @return the device Id
+ */
+ private static DeviceId getDeviceId(int i) {
+ return DeviceId.deviceId("" + i);
}
private Host makeHost(MacAddress mac, VlanId vlan, ConnectPoint cp) {
- return new DefaultHost(pid,
+ return new DefaultHost(PID,
HostId.hostId(mac, vlan),
mac,
vlan,
@@ -336,6 +345,7 @@
this.forwardResults = Sets.newHashSet();
}
+
@Override
public ConnectPoint inPort() {
return inPort;
@@ -407,21 +417,22 @@
}
}
- private class TestVplsConfigService implements VplsConfigurationService {
+ private class TestVplsConfigService extends VplsConfigurationServiceAdapter {
- private final SetMultimap<String, Interface> vplsNetworks;
+ private final SetMultimap<String, Interface> ifacesByVplsName;
- public TestVplsConfigService(SetMultimap<String, Interface> networks) {
- this.vplsNetworks = networks;
+ public TestVplsConfigService(SetMultimap<String, Interface> ifacesByVplsName,
+ HashMap<String, EncapsulationType> encapByVplsName) {
+ this.ifacesByVplsName = ifacesByVplsName;
}
@Override
- public void addVpls(String name, Set<String> ifaceNames) {
- if (!vplsNetworks.containsKey(name)) {
+ public void addVpls(String vplsName, Set<String> ifaceNames, String encap) {
+ if (!ifacesByVplsName.containsKey(vplsName)) {
ifaceNames.forEach(ifaceName -> {
- avaliableInterfaces.forEach(intf -> {
- if (intf.name().equals(ifaceName)) {
- vplsNetworks.put(name, intf);
+ availableInterfaces.forEach(iface -> {
+ if (iface.name().equals(ifaceName)) {
+ ifacesByVplsName.put(vplsName, iface);
}
});
});
@@ -429,87 +440,77 @@
}
@Override
- public void removeVpls(String name) {
- if (vplsNetworks.containsKey(name)) {
- vplsNetworks.removeAll(name);
+ public void removeVpls(String vplsName) {
+ if (ifacesByVplsName.containsKey(vplsName)) {
+ ifacesByVplsName.removeAll(vplsName);
}
}
@Override
- public void addInterfaceToVpls(String name, String ifaceName) {
- avaliableInterfaces.forEach(intf -> {
+ public void addIface(String vplsName, String ifaceName) {
+ availableInterfaces.forEach(intf -> {
if (intf.name().equals(ifaceName)) {
- vplsNetworks.put(name, intf);
+ ifacesByVplsName.put(vplsName, intf);
}
});
}
@Override
- public void removeInterfaceFromVpls(String ifaceName) {
+ public void removeIface(String ifaceName) {
SetMultimap<String, Interface> toBeRemoved = HashMultimap.create();
- vplsNetworks.entries().forEach(e -> {
+ ifacesByVplsName.entries().forEach(e -> {
if (e.getValue().name().equals(ifaceName)) {
toBeRemoved.put(e.getKey(), e.getValue());
}
});
toBeRemoved.entries()
- .forEach(e -> vplsNetworks.remove(e.getKey(),
- e.getValue()));
+ .forEach(e -> ifacesByVplsName.remove(e.getKey(),
+ e.getValue()));
}
@Override
- public void cleanVpls() {
- vplsNetworks.clear();
+ public void cleanVplsConfig() {
+ ifacesByVplsName.clear();
}
@Override
- public Set<String> getVplsAffectedByApi() {
- return null;
+ public Set<Interface> allIfaces() {
+ return ImmutableSet.copyOf(ifacesByVplsName.values());
}
@Override
- public Set<Interface> getAllInterfaces() {
- return ImmutableSet.copyOf(vplsNetworks.values());
- }
-
- @Override
- public Set<Interface> getVplsInterfaces(String name) {
- return vplsNetworks.get(name)
+ public Set<Interface> ifaces(String name) {
+ return ifacesByVplsName.get(name)
.stream()
.collect(Collectors.toSet());
}
@Override
- public Set<String> getAllVpls() {
- return vplsNetworks.keySet();
+ public Set<String> vplsNames() {
+ return ifacesByVplsName.keySet();
}
@Override
- public Set<String> getOldVpls() {
- return null;
+ public SetMultimap<String, Interface> ifacesByVplsName() {
+ return ImmutableSetMultimap.copyOf(ifacesByVplsName);
}
@Override
- public SetMultimap<String, Interface> getVplsNetworks() {
- return ImmutableSetMultimap.copyOf(vplsNetworks);
- }
-
- @Override
- public SetMultimap<String, Interface> getVplsNetwork(VlanId vlan,
- ConnectPoint connectPoint) {
- String vplsNetworkName =
- vplsNetworks.entries().stream()
+ public SetMultimap<String, Interface> ifacesByVplsName(VlanId vlan,
+ ConnectPoint connectPoint) {
+ String vplsName =
+ ifacesByVplsName.entries().stream()
.filter(e -> e.getValue().connectPoint().equals(connectPoint))
.filter(e -> e.getValue().vlan().equals(vlan))
.map(e -> e.getKey())
.findFirst()
.orElse(null);
SetMultimap<String, Interface> result = HashMultimap.create();
- if (vplsNetworkName != null &&
- vplsNetworks.containsKey(vplsNetworkName)) {
- vplsNetworks.get(vplsNetworkName)
- .forEach(intf -> result.put(vplsNetworkName, intf));
+ if (vplsName != null &&
+ ifacesByVplsName.containsKey(vplsName)) {
+ ifacesByVplsName.get(vplsName)
+ .forEach(intf -> result.put(vplsName, intf));
return result;
}
return null;
@@ -654,13 +655,13 @@
@Override
public Set<Interface> getInterfaces() {
- return avaliableInterfaces;
+ return availableInterfaces;
}
@Override
public Interface getInterfaceByName(ConnectPoint connectPoint,
String name) {
- return avaliableInterfaces.stream()
+ return availableInterfaces.stream()
.filter(intf -> intf.name().equals(name))
.findFirst()
.orElse(null);
@@ -669,28 +670,28 @@
@Override
public Set<Interface> getInterfacesByPort(ConnectPoint port) {
- return avaliableInterfaces.stream()
+ return availableInterfaces.stream()
.filter(intf -> intf.connectPoint().equals(port))
.collect(Collectors.toSet());
}
@Override
public Set<Interface> getInterfacesByIp(IpAddress ip) {
- return avaliableInterfaces.stream()
+ return availableInterfaces.stream()
.filter(intf -> intf.ipAddressesList().contains(ip))
.collect(Collectors.toSet());
}
@Override
public Set<Interface> getInterfacesByVlan(VlanId vlan) {
- return avaliableInterfaces.stream()
+ return availableInterfaces.stream()
.filter(intf -> intf.vlan().equals(vlan))
.collect(Collectors.toSet());
}
@Override
public Interface getMatchingInterface(IpAddress ip) {
- return avaliableInterfaces.stream()
+ return availableInterfaces.stream()
.filter(intf -> intf.ipAddressesList().contains(ip))
.findFirst()
.orElse(null);