홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
Luca Prete
Committed by Gerrit Code Review
f70d399a 1 parent a85c6941

Refactor ProxyManager Tests and added functionality to manage traffic coming and… 

… going through vlan interfaces

Change-Id: I8d748c42b48d0956c670be12ff2742cb2022fa62
Inline Side-by-side
Showing 2 changed files with 379 additions and 158 deletions
......@@ -53,6 +53,7 @@ import org.slf4j.Logger;
import java.nio.ByteBuffer;
import java.util.Set;
import java.util.stream.Collectors;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
......@@ -199,11 +200,49 @@ public class ProxyArpManager implements ProxyArpService {
return;
}
// If the packets has a vlanId look if there are some other
// interfaces in the configuration on the same vlan and broadcast
// the packet out just of through those interfaces.
VlanId vlanId = context.vlan();
Set<Interface> filteredVlanInterfaces =
filterVlanInterfacesNoIp(interfaceService.getInterfacesByVlan(vlanId));
if (vlanId != null
&& !vlanId.equals(VlanId.NONE)
&& confContainsVlans(vlanId, context.inPort())) {
vlanFlood(context.packet(), filteredVlanInterfaces, context.inPort);
return;
}
// The request couldn't be resolved.
// Flood the request on all ports except the incoming port.
flood(context.packet(), context.inPort());
}
private Set<Interface> filterVlanInterfacesNoIp(Set<Interface> vlanInterfaces) {
return vlanInterfaces
.stream()
.filter(intf -> intf.ipAddresses().isEmpty())
.collect(Collectors.toSet());
}
/**
* States if the interface configuration contains more than one interface configured
* on a specific vlan, including the interface passed as argument.
*
* @param vlanId the vlanid to look for in the interface configuration
* @param connectPoint the connect point to exclude from the search
* @return true if interfaces are found. False otherwise
*/
private boolean confContainsVlans(VlanId vlanId, ConnectPoint connectPoint) {
Set<Interface> vlanInterfaces = interfaceService.getInterfacesByVlan(vlanId);
return interfaceService.getInterfacesByVlan(vlanId)
.stream()
.anyMatch(intf -> intf.connectPoint().equals(connectPoint) && intf.ipAddresses().isEmpty())
&& vlanInterfaces.size() > 1;
}
/**
* Builds and sends a reply message given a request context and the resolved
* MAC address to answer with.
......@@ -259,14 +298,29 @@ public class ProxyArpManager implements ProxyArpService {
/**
* Returns whether the given port has any IP addresses configured or not.
*
* @param port the port to check
* @param connectPoint the port to check
* @return true if the port has at least one IP address configured,
* otherwise false
* false otherwise
*/
private boolean hasIpAddress(ConnectPoint connectPoint) {
return interfaceService.getInterfacesByPort(connectPoint)
.stream()
.flatMap(intf -> intf.ipAddresses().stream())
.findAny()
.isPresent();
}
/**
* Returns whether the given port has any VLAN configured or not.
*
* @param connectPoint the port to check
* @return true if the port has at least one VLAN configured,
* false otherwise
*/
private boolean hasIpAddress(ConnectPoint port) {
return interfaceService.getInterfacesByPort(port)
private boolean hasVlan(ConnectPoint connectPoint) {
return interfaceService.getInterfacesByPort(connectPoint)
.stream()
.map(intf -> intf.ipAddresses())
.filter(intf -> !intf.vlan().equals(VlanId.NONE))
.findAny()
.isPresent();
}
......@@ -322,6 +376,30 @@ public class ProxyArpManager implements ProxyArpService {
}
/**
* Flood the arp request at all edges on a specifc VLAN.
*
* @param request the arp request
* @param dsts the destination interfaces
* @param inPort the connect point the arp request was received on
*/
private void vlanFlood(Ethernet request, Set<Interface> dsts, ConnectPoint inPort) {
TrafficTreatment.Builder builder = null;
ByteBuffer buf = ByteBuffer.wrap(request.serialize());
for (Interface intf : dsts) {
ConnectPoint cPoint = intf.connectPoint();
if (cPoint.equals(inPort)) {
continue;
}
builder = DefaultTrafficTreatment.builder();
builder.setOutput(cPoint.port());
packetService.emit(new DefaultOutboundPacket(cPoint.deviceId(),
builder.build(), buf));
}
}
/**
* Flood the arp request at all edges in the network.
*
* @param request the arp request
......@@ -332,7 +410,9 @@ public class ProxyArpManager implements ProxyArpService {
ByteBuffer buf = ByteBuffer.wrap(request.serialize());
for (ConnectPoint connectPoint : edgeService.getEdgePoints()) {
if (hasIpAddress(connectPoint) || connectPoint.equals(inPort)) {
if (hasIpAddress(connectPoint)
|| hasVlan(connectPoint)
|| connectPoint.equals(inPort)) {
continue;
}
......
......@@ -15,7 +15,6 @@
*/
package org.onosproject.net.proxyarp.impl;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import org.junit.Before;
import org.junit.Test;
......@@ -48,7 +47,7 @@ import org.onosproject.net.Port;
import org.onosproject.net.PortNumber;
import org.onosproject.net.device.DeviceListener;
import org.onosproject.net.device.DeviceService;
import org.onosproject.net.edgeservice.impl.EdgeManager;
import org.onosproject.net.edge.EdgePortService;
import org.onosproject.net.flow.DefaultTrafficTreatment;
import org.onosproject.net.flow.TrafficTreatment;
import org.onosproject.net.flow.instructions.Instruction;
......@@ -67,6 +66,7 @@ import org.onosproject.net.proxyarp.ProxyArpStoreDelegate;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
......@@ -88,47 +88,65 @@ import static org.junit.Assert.assertTrue;
*/
public class ProxyArpManagerTest {
private static final int NUM_DEVICES = 6;
private static final int NUM_DEVICES = 10;
private static final int NUM_PORTS_PER_DEVICE = 3;
private static final int NUM_ADDRESS_PORTS = NUM_DEVICES / 2;
private static final int NUM_FLOOD_PORTS = 3;
private static final int LAST_CONF_DEVICE_INTF_VLAN_IP = 3;
private static final int LAST_CONF_DEVICE_INTF_VLAN = 6;
private static final Ip4Address IP1 = Ip4Address.valueOf("192.168.1.1");
private static final Ip4Address IP2 = Ip4Address.valueOf("192.168.1.2");
private static final Ip6Address IP3 = Ip6Address.valueOf("1000::1");
private static final Ip6Address IP4 = Ip6Address.valueOf("1000::2");
private static final Ip6Address IP3 = Ip6Address.valueOf("1000:ffff::1");
private static final Ip6Address IP4 = Ip6Address.valueOf("1000:ffff::2");
private static final ProviderId PID = new ProviderId("of", "foo");
private static final VlanId VLAN1 = VlanId.vlanId((short) 1);
private static final VlanId VLAN2 = VlanId.vlanId((short) 2);
private static final MacAddress MAC1 = MacAddress.valueOf("00:00:11:00:00:01");
private static final MacAddress MAC2 = MacAddress.valueOf("00:00:22:00:00:02");
private static final MacAddress MAC3 = MacAddress.valueOf("00:00:33:00:00:03");
private static final MacAddress MAC4 = MacAddress.valueOf("00:00:44:00:00:04");
private static final VlanId VLAN10 = VlanId.vlanId((short) 10);
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 MAC10 = MacAddress.valueOf("00:00:00:00:00:0A");
private static final MacAddress SOLICITED_MAC3 = MacAddress.valueOf("33:33:FF:00:00:01");
private static final HostId HID1 = HostId.hostId(MAC1, VLAN1);
private static final HostId HID2 = HostId.hostId(MAC2, VLAN1);
private static final HostId HID3 = HostId.hostId(MAC3, VLAN1);
private static final HostId HID4 = HostId.hostId(MAC4, VLAN1);
private static final HostId HID10 = HostId.hostId(MAC10, VLAN10);
private static final HostId SOLICITED_HID3 = HostId.hostId(SOLICITED_MAC3, VLAN1);
private static final DeviceId DID1 = getDeviceId(1);
private static final DeviceId DID2 = getDeviceId(2);
private static final PortNumber P1 = PortNumber.portNumber(1);
private static final HostLocation LOC1 = new HostLocation(DID1, P1, 123L);
private static final HostLocation LOC2 = new HostLocation(DID2, P1, 123L);
private static final byte[] ZERO_MAC_ADDRESS = MacAddress.ZERO.toBytes();
//Return values used for various functions of the TestPacketService inner class.
private boolean isEdgePointReturn;
private List<ConnectPoint> getEdgePointsNoArg;
private final byte[] zeroMacAddress = MacAddress.ZERO.toBytes();
// The first three devices in the topology have interfaces configured
// with VLANs and IPs
private final List<ConnectPoint> configIpCPoints = new ArrayList<>();
// Other three devices in the topology (from 4 to 6) have interfaces
// configured only with VLANs
private final List<ConnectPoint> configVlanCPoints = new ArrayList<>();
// Remaining devices in the network (id > 6) don't have any interface
// configured.
private final List<ConnectPoint> noConfigCPoints = new ArrayList<>();
private ProxyArpManager proxyArp;
private TestPacketService packetService;
private DeviceService deviceService;
private EdgePortService edgePortService;
private LinkService linkService;
private HostService hostService;
private InterfaceService interfaceService;
......@@ -140,20 +158,27 @@ public class ProxyArpManagerTest {
proxyArp.packetService = packetService;
proxyArp.store = new TestProxyArpStoreAdapter();
proxyArp.edgeService = new TestEdgePortService();
// Create a host service mock here. Must be replayed by tests once the
// expectations have been set up
// Create a host service mock here.
hostService = createMock(HostService.class);
proxyArp.hostService = hostService;
// Create an edge port service.
edgePortService = createMock(EdgePortService.class);
proxyArp.edgeService = edgePortService;
// Create interface service
interfaceService = createMock(InterfaceService.class);
proxyArp.interfaceService = interfaceService;
// Create the topology
createTopology();
proxyArp.deviceService = deviceService;
proxyArp.linkService = linkService;
setupNoConfigCPoints();
setupconfigIpCPoints();
setupconfigVlanCPoints();
proxyArp.activate();
}
......@@ -176,7 +201,8 @@ public class ProxyArpManagerTest {
createDevices(NUM_DEVICES, NUM_PORTS_PER_DEVICE);
createLinks(NUM_DEVICES);
addAddressBindings();
addIntfConfig();
popluateEdgePortService();
}
/**
......@@ -237,13 +263,22 @@ public class ProxyArpManagerTest {
replay(linkService);
}
private void addAddressBindings() {
/**
* On the first three devices two config interfaces are binded on port 1.
* The first one with VLAN1, the second one with VLAN equals to none.
* Both interfaces have an IP.
* On devices 4, 5 and 6 it's binded a config interface on port 1.
* The interface is configured with VLAN 1 and no IP.
*/
private void addIntfConfig() {
Set<Interface> interfaces = Sets.newHashSet();
for (int i = 1; i <= NUM_ADDRESS_PORTS; i++) {
Set<Interface> vlanOneSet = new HashSet<>();
for (int i = 1; i <= LAST_CONF_DEVICE_INTF_VLAN_IP; i++) {
ConnectPoint cp = new ConnectPoint(getDeviceId(i), P1);
// Interface address for IPv4
// Interface addresses for IPv4
Ip4Prefix prefix1 = Ip4Prefix.valueOf("10.0." + (2 * i - 1) + ".0/24");
Ip4Address addr1 = Ip4Address.valueOf("10.0." + (2 * i - 1) + ".1");
Ip4Prefix prefix2 = Ip4Prefix.valueOf("10.0." + (2 * i) + ".0/24");
......@@ -251,39 +286,131 @@ public class ProxyArpManagerTest {
InterfaceIpAddress ia1 = new InterfaceIpAddress(addr1, prefix1);
InterfaceIpAddress ia2 = new InterfaceIpAddress(addr2, prefix2);
// Interface address for IPv6
// Interface addresses for IPv6
Ip6Prefix prefix3 = Ip6Prefix.valueOf((2 * i - 1) + "000::0/64");
Ip6Address addr3 = Ip6Address.valueOf((2 * i - 1) + "000::1");
Ip6Prefix prefix4 = Ip6Prefix.valueOf((2 * i) + "000::0/64");
Ip6Address addr4 = Ip6Address.valueOf((2 * i) + "000::1");
Ip6Address addr4 = Ip6Address.valueOf((2 * i) + "000::2");
InterfaceIpAddress ia3 = new InterfaceIpAddress(addr3, prefix3);
InterfaceIpAddress ia4 = new InterfaceIpAddress(addr4, prefix4);
// Setting up interfaces
Interface intf1 = new Interface(cp, Sets.newHashSet(ia1, ia3),
MacAddress.valueOf(2 * i - 1),
VlanId.vlanId((short) 1));
Interface intf2 = new Interface(cp, Sets.newHashSet(ia2, ia4),
MacAddress.valueOf(2 * i),
VlanId.NONE);
interfaces.add(intf1);
interfaces.add(intf2);
vlanOneSet.add(intf1);
expect(interfaceService.getInterfacesByPort(cp))
.andReturn(Sets.newHashSet(intf1, intf2)).anyTimes();
}
for (int i = LAST_CONF_DEVICE_INTF_VLAN_IP + 1; i <= LAST_CONF_DEVICE_INTF_VLAN; i++) {
ConnectPoint cp = new ConnectPoint(getDeviceId(i), P1);
Interface intf1 = new Interface(cp, null,
MacAddress.NONE,
VlanId.vlanId((short) 1));
interfaces.add(intf1);
vlanOneSet.add(intf1);
expect(interfaceService.getInterfacesByPort(cp))
.andReturn(Sets.newHashSet(intf1)).anyTimes();
}
expect(interfaceService.getInterfacesByVlan(VLAN1))
.andReturn(vlanOneSet).anyTimes();
expect(interfaceService.getInterfacesByVlan(VLAN10))
.andReturn(Collections.emptySet()).anyTimes();
expect(interfaceService.getInterfaces()).andReturn(interfaces).anyTimes();
for (int i = 1; i <= NUM_FLOOD_PORTS; i++) {
ConnectPoint cp = new ConnectPoint(getDeviceId(i + NUM_ADDRESS_PORTS),
for (int i = LAST_CONF_DEVICE_INTF_VLAN + 1; i <= NUM_DEVICES; i++) {
ConnectPoint cp = new ConnectPoint(getDeviceId(i),
P1);
expect(interfaceService.getInterfacesByPort(cp))
.andReturn(Collections.emptySet()).anyTimes();
}
}
/**
* Populates edge ports in the EdgePortService to return all port 1
* as edge ports.
*/
private void popluateEdgePortService() {
Set<ConnectPoint> edgeConnectPoints = new HashSet<>();
for (int i = 1; i <= NUM_DEVICES; i++) {
for (int j = 1; j <= NUM_PORTS_PER_DEVICE; j++) {
ConnectPoint edgeConnectPoint = new ConnectPoint(
getDeviceId(i),
PortNumber.portNumber(1));
ConnectPoint noEdgeConnectPointOne = new ConnectPoint(
getDeviceId(i),
PortNumber.portNumber(2));
ConnectPoint noEdgeConnectPointTwo = new ConnectPoint(
getDeviceId(i),
PortNumber.portNumber(3));
edgeConnectPoints.add(edgeConnectPoint);
expect(edgePortService.isEdgePoint(edgeConnectPoint))
.andReturn(true).anyTimes();
expect(edgePortService.isEdgePoint(noEdgeConnectPointOne))
.andReturn(false).anyTimes();
expect(edgePortService.isEdgePoint(noEdgeConnectPointTwo))
.andReturn(false).anyTimes();
}
}
expect(edgePortService.getEdgePoints())
.andReturn(edgeConnectPoints).anyTimes();
replay(edgePortService);
}
/**
* Creates a list of connect points used to verify floodling on ports
* with no interfaces configured (all ports without interface config).
*/
private void setupNoConfigCPoints() {
for (int i = NUM_DEVICES / 2 + 2; i <= NUM_DEVICES; i++) {
ConnectPoint connectPoint = new ConnectPoint(
getDeviceId(i),
PortNumber.portNumber(1));
noConfigCPoints.add(connectPoint);
}
}
/**
* Creates a list of connect points used to verify floodling on ports
* with interfaces configured (both VLAN and IP).
*/
private void setupconfigIpCPoints() {
for (int i = 1; i <= 3; i++) {
ConnectPoint connectPoint = new ConnectPoint(
getDeviceId(i),
PortNumber.portNumber(1));
configIpCPoints.add(connectPoint);
}
}
/**
* Creates a list of connect points used to verify floodling on ports
* with interfaces configured (both VLAN and IP).
*/
private void setupconfigVlanCPoints() {
for (int i = LAST_CONF_DEVICE_INTF_VLAN_IP + 1; i <= LAST_CONF_DEVICE_INTF_VLAN; i++) {
ConnectPoint connectPoint = new ConnectPoint(
getDeviceId(i),
PortNumber.portNumber(1));
configVlanCPoints.add(connectPoint);
}
}
/**
* Tests {@link ProxyArpManager#isKnown(org.onlab.packet.IpAddress)} in the
* case where the IP address is not known.
* Verifies the method returns false.
......@@ -318,33 +445,34 @@ public class ProxyArpManagerTest {
/**
* Tests {@link ProxyArpManager#reply(Ethernet, ConnectPoint)} in the case where the
* destination host is known.
* Verifies the correct ARP reply is sent out the correct port.
* Two host using the same VLAN are registered on the host service on devices 5 and 6.
* Host on port 6 asks for the MAC of the device on port 5.
* Since the destination mac address is known, the request is not flooded to anywhere
* and ONOS directly builds an ARP reply, sended back to the requester on device 6.
* It's verified that a proper ARP reply is received on port 1 of device 6.
*/
@Test
public void testReplyKnown() {
//Set the return value of isEdgePoint from the edgemanager.
isEdgePointReturn = true;
Host replyer = new DefaultHost(PID, HID1, MAC1, VLAN1, getLocation(4),
Host requestor = new DefaultHost(PID, HID1, MAC1, VLAN1, getLocation(NUM_DEVICES),
Collections.singleton(IP1));
Host requestor = new DefaultHost(PID, HID2, MAC2, VLAN1, getLocation(5),
Host replyer = new DefaultHost(PID, HID2, MAC2, VLAN1, getLocation(NUM_DEVICES - 1),
Collections.singleton(IP2));
expect(hostService.getHostsByIp(IP1))
expect(hostService.getHostsByIp(IP2))
.andReturn(Collections.singleton(replyer));
expect(hostService.getHost(HID2)).andReturn(requestor);
expect(hostService.getHost(HID1)).andReturn(requestor);
replay(hostService);
replay(interfaceService);
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, MAC2, null, IP2, IP1);
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, VLAN1, MAC1, null, IP1, IP2);
proxyArp.reply(arpRequest, getLocation(5));
proxyArp.reply(arpRequest, getLocation(NUM_DEVICES));
assertEquals(1, packetService.packets.size());
Ethernet arpReply = buildArp(ARP.OP_REPLY, MAC1, MAC2, IP1, IP2);
verifyPacketOut(arpReply, getLocation(5), packetService.packets.get(0));
Ethernet arpReply = buildArp(ARP.OP_REPLY, VLAN1, MAC2, MAC1, IP2, IP1);
verifyPacketOut(arpReply, getLocation(NUM_DEVICES), packetService.packets.get(0));
}
/**
......@@ -354,9 +482,6 @@ public class ProxyArpManagerTest {
*/
@Test
public void testReplyKnownIpv6() {
//Set the return value of isEdgePoint from the edgemanager.
isEdgePointReturn = true;
Host replyer = new DefaultHost(PID, HID3, MAC3, VLAN1, getLocation(4),
Collections.singleton(IP3));
......@@ -385,34 +510,31 @@ public class ProxyArpManagerTest {
/**
* Tests {@link ProxyArpManager#reply(Ethernet, ConnectPoint)} in the case where the
* destination host is not known.
* Only a requestor is present (on device 6, port 1). The device has a VLAN configured
* which is not configured anywhere in the system.
* Since the destination is not known, and since the ARP request can't be sent out of
* interfaces configured, the ARP request is flooded out of ports 4 and 5.
* Verifies the ARP request is flooded out the correct edge ports.
*/
@Test
public void testReplyUnknown() {
isEdgePointReturn = true;
Host requestor = new DefaultHost(PID, HID2, MAC2, VLAN1, getLocation(5),
Collections.singleton(IP2));
Host requestor = new DefaultHost(PID, HID10, MAC10, VLAN10, getLocation(NUM_DEVICES),
Collections.singleton(IP1));
expect(hostService.getHostsByIp(IP1))
expect(hostService.getHostsByIp(IP2))
.andReturn(Collections.emptySet());
expect(interfaceService.getInterfacesByIp(IP2))
expect(interfaceService.getInterfacesByIp(IP1))
.andReturn(Collections.emptySet());
expect(hostService.getHost(HID2)).andReturn(requestor);
expect(hostService.getHost(HID10)).andReturn(requestor);
replay(hostService);
replay(interfaceService);
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, MAC2, null, IP2, IP1);
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, VLAN10, MAC10, null, IP1, IP2);
//Setup the set of edge ports to be used in the reply method
getEdgePointsNoArg = Lists.newLinkedList();
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("5"), PortNumber.portNumber(1)));
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("4"), PortNumber.portNumber(1)));
proxyArp.reply(arpRequest, getLocation(NUM_DEVICES));
proxyArp.reply(arpRequest, getLocation(6));
verifyFlood(arpRequest);
verifyFlood(arpRequest, noConfigCPoints);
}
/**
......@@ -422,9 +544,7 @@ public class ProxyArpManagerTest {
*/
@Test
public void testReplyUnknownIpv6() {
isEdgePointReturn = true;
Host requestor = new DefaultHost(PID, HID4, MAC4, VLAN1, getLocation(5),
Host requestor = new DefaultHost(PID, HID4, MAC4, VLAN1, getLocation(NUM_DEVICES),
Collections.singleton(IP4));
expect(hostService.getHostsByIp(IP3))
......@@ -440,49 +560,107 @@ public class ProxyArpManagerTest {
MAC4, SOLICITED_MAC3,
IP4, IP3);
//Setup the set of edge ports to be used in the reply method
getEdgePointsNoArg = Lists.newLinkedList();
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("5"), PortNumber.portNumber(1)));
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("4"), PortNumber.portNumber(1)));
proxyArp.reply(ndpRequest, getLocation(6));
proxyArp.reply(ndpRequest, getLocation(NUM_DEVICES));
verifyFlood(ndpRequest);
verifyFlood(ndpRequest, noConfigCPoints);
}
/**
* Tests {@link ProxyArpManager#reply(Ethernet, ConnectPoint)} in the case where the
* destination host is known for that IP address, but is not on the same
* VLAN as the source host.
* An host is connected on device 6, port 1 where no interfaces are defined. It sends
* ARP requests from VLAN10, not configured anywhere in the network. Another host with
* the IP address requested lives on device 5, port 1 in the network. Anyway, since the
* host uses another VLAN it's not found and the ARP packet is flooded out of port
* 4 and 5.
*
* Verifies the ARP request is flooded out the correct edge ports.
*/
@Test
public void testReplyDifferentVlan() {
Host replyer = new DefaultHost(PID, HID1, MAC1, VLAN2, getLocation(4),
Host requestor = new DefaultHost(PID, HID10, MAC10, VLAN10, getLocation(NUM_DEVICES),
Collections.singleton(IP1));
Host requestor = new DefaultHost(PID, HID2, MAC2, VLAN1, getLocation(5),
Host replyer = new DefaultHost(PID, HID2, MAC2, VLAN2, getLocation(NUM_DEVICES - 1),
Collections.singleton(IP2));
expect(hostService.getHostsByIp(IP1))
expect(hostService.getHostsByIp(IP2))
.andReturn(Collections.singleton(replyer));
expect(interfaceService.getInterfacesByIp(IP2))
expect(interfaceService.getInterfacesByIp(IP1))
.andReturn(Collections.emptySet());
expect(hostService.getHost(HID2)).andReturn(requestor);
expect(hostService.getHost(HID10)).andReturn(requestor);
replay(hostService);
replay(interfaceService);
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, VLAN10, MAC10, null, IP1, IP2);
proxyArp.reply(arpRequest, getLocation(NUM_DEVICES));
verifyFlood(arpRequest, noConfigCPoints);
}
/**
* Tests {@link ProxyArpManager#reply(Ethernet, ConnectPoint)} in the case where the
* a vlan packet comes in from a port without interfaces configured. The destination
* host is unknown for that IP address and there are some interfaces configured on
* the same vlan.
* It's expected to see the ARP request going out through ports with no interfaces
* configured, devices 4 and 5, port 1.
*
* Verifies the ARP request is flooded out the correct edge ports.
*/
@Test
public void testConfiguredVlan() {
Host requestor = new DefaultHost(PID, HID1, MAC1, VLAN1, getLocation(NUM_DEVICES),
Collections.singleton(IP1));
expect(hostService.getHostsByIp(IP2))
.andReturn(Collections.emptySet());
expect(interfaceService.getInterfacesByIp(IP1))
.andReturn(Collections.emptySet());
expect(hostService.getHost(HID1)).andReturn(requestor);
replay(hostService);
replay(interfaceService);
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, VLAN1, MAC1, null, IP1, IP2);
proxyArp.reply(arpRequest, getLocation(NUM_DEVICES));
verifyFlood(arpRequest, noConfigCPoints);
}
/**
* Tests {@link ProxyArpManager#reply(Ethernet, ConnectPoint)} in the case where the
* a vlan packet comes in from a port without interfaces configured. The destination
* host is not known for that IP address and there are some interfaces configured on
* the same vlan.
* It's expected to see the ARP request going out through ports with no interfaces
* configured, devices 4 and 5, port 1.
*
* Verifies the ARP request is flooded out the correct edge ports.
*/
@Test
public void testConfiguredVlanOnInterfaces() {
Host requestor = new DefaultHost(PID, HID1, MAC1, VLAN1, getLocation(6),
Collections.singleton(IP1));
expect(hostService.getHostsByIp(IP2))
.andReturn(Collections.emptySet());
expect(interfaceService.getInterfacesByIp(IP1))
.andReturn(Collections.emptySet());
expect(hostService.getHost(HID1)).andReturn(requestor);
replay(hostService);
replay(interfaceService);
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, MAC2, null, IP2, IP1);
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, VLAN1, MAC1, null, IP1, IP2);
//Setup for flood test
getEdgePointsNoArg = Lists.newLinkedList();
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("5"), PortNumber.portNumber(1)));
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("4"), PortNumber.portNumber(1)));
proxyArp.reply(arpRequest, getLocation(6));
verifyFlood(arpRequest);
verifyFlood(arpRequest, configVlanCPoints);
}
/**
......@@ -493,13 +671,12 @@ public class ProxyArpManagerTest {
*/
@Test
public void testReplyDifferentVlanIpv6() {
Host requestor = new DefaultHost(PID, HID4, MAC4, VLAN1, getLocation(NUM_DEVICES),
Collections.singleton(IP4));
Host replyer = new DefaultHost(PID, HID3, MAC3, VLAN2, getLocation(4),
Host replyer = new DefaultHost(PID, HID3, MAC3, VLAN2, getLocation(NUM_DEVICES - 1),
Collections.singleton(IP3));
Host requestor = new DefaultHost(PID, HID4, MAC4, VLAN1, getLocation(5),
Collections.singleton(IP4));
expect(hostService.getHostsByIp(IP3))
.andReturn(Collections.singleton(replyer));
expect(interfaceService.getInterfacesByIp(IP4))
......@@ -513,13 +690,9 @@ public class ProxyArpManagerTest {
MAC4, SOLICITED_MAC3,
IP4, IP3);
//Setup for flood test
getEdgePointsNoArg = Lists.newLinkedList();
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("5"), PortNumber.portNumber(1)));
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("4"), PortNumber.portNumber(1)));
proxyArp.reply(ndpRequest, getLocation(6));
proxyArp.reply(ndpRequest, getLocation(NUM_DEVICES));
verifyFlood(ndpRequest);
verifyFlood(ndpRequest, noConfigCPoints);
}
/**
......@@ -533,29 +706,29 @@ public class ProxyArpManagerTest {
MacAddress firstMac = MacAddress.valueOf(1L);
MacAddress secondMac = MacAddress.valueOf(2L);
Host requestor = new DefaultHost(PID, HID2, MAC2, VLAN1, LOC1,
Host requestor = new DefaultHost(PID, HID1, MAC1, VLAN1, LOC1,
Collections.singleton(theirIp));
expect(hostService.getHost(HID2)).andReturn(requestor);
expect(hostService.getHost(HID1)).andReturn(requestor);
replay(hostService);
replay(interfaceService);
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, MAC2, null, theirIp, ourFirstIp);
isEdgePointReturn = true;
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, VLAN1, MAC1, null, theirIp, ourFirstIp);
proxyArp.reply(arpRequest, LOC1);
assertEquals(1, packetService.packets.size());
Ethernet arpReply = buildArp(ARP.OP_REPLY, firstMac, MAC2, ourFirstIp, theirIp);
Ethernet arpReply = buildArp(ARP.OP_REPLY, VLAN1, firstMac, MAC1, ourFirstIp, theirIp);
verifyPacketOut(arpReply, LOC1, packetService.packets.get(0));
// Test a request for the second address on that port
packetService.packets.clear();
arpRequest = buildArp(ARP.OP_REQUEST, MAC2, null, theirIp, ourSecondIp);
arpRequest = buildArp(ARP.OP_REQUEST, VLAN1, MAC1, null, theirIp, ourSecondIp);
proxyArp.reply(arpRequest, LOC1);
assertEquals(1, packetService.packets.size());
arpReply = buildArp(ARP.OP_REPLY, secondMac, MAC2, ourSecondIp, theirIp);
arpReply = buildArp(ARP.OP_REPLY, VLAN1, secondMac, MAC1, ourSecondIp, theirIp);
verifyPacketOut(arpReply, LOC1, packetService.packets.get(0));
}
......@@ -566,7 +739,7 @@ public class ProxyArpManagerTest {
public void testReplyToRequestForUsIpv6() {
Ip6Address theirIp = Ip6Address.valueOf("1000::ffff");
Ip6Address ourFirstIp = Ip6Address.valueOf("1000::1");
Ip6Address ourSecondIp = Ip6Address.valueOf("2000::1");
Ip6Address ourSecondIp = Ip6Address.valueOf("2000::2");
MacAddress firstMac = MacAddress.valueOf(1L);
MacAddress secondMac = MacAddress.valueOf(2L);
......@@ -584,7 +757,7 @@ public class ProxyArpManagerTest {
MacAddress.valueOf("33:33:ff:00:00:01"),
theirIp,
ourFirstIp);
isEdgePointReturn = true;
proxyArp.reply(ndpRequest, LOC1);
assertEquals(1, packetService.packets.size());
......@@ -624,14 +797,14 @@ public class ProxyArpManagerTest {
Ip4Address theirIp = Ip4Address.valueOf("10.0.1.254");
// Request for a valid external IP address but coming in the wrong port
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, MAC1, null, theirIp,
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, VLAN1, MAC1, null, theirIp,
Ip4Address.valueOf("10.0.3.1"));
proxyArp.reply(arpRequest, LOC1);
assertEquals(0, packetService.packets.size());
// Request for a valid internal IP address but coming in an external port
packetService.packets.clear();
arpRequest = buildArp(ARP.OP_REQUEST, MAC1, null, theirIp, IP1);
arpRequest = buildArp(ARP.OP_REQUEST, VLAN1, MAC1, null, theirIp, IP1);
proxyArp.reply(arpRequest, LOC1);
assertEquals(0, packetService.packets.size());
}
......@@ -685,9 +858,8 @@ public class ProxyArpManagerTest {
// This is a request from something inside our network (like a BGP
// daemon) to an external host.
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, ourMac, null, ourIp, theirIp);
Ethernet arpRequest = buildArp(ARP.OP_REQUEST, VLAN1, ourMac, null, ourIp, theirIp);
//Ensure the packet is allowed through (it is not to an internal port)
isEdgePointReturn = true;
proxyArp.reply(arpRequest, getLocation(5));
assertEquals(1, packetService.packets.size());
......@@ -728,9 +900,6 @@ public class ProxyArpManagerTest {
ourIp,
theirIp);
//Ensure the packet is allowed through (it is not to an internal port)
isEdgePointReturn = true;
proxyArp.reply(ndpRequest, getLocation(5));
assertEquals(1, packetService.packets.size());
verifyPacketOut(ndpRequest, getLocation(1), packetService.packets.get(0));
......@@ -758,7 +927,7 @@ public class ProxyArpManagerTest {
replay(hostService);
replay(interfaceService);
Ethernet arpRequest = buildArp(ARP.OP_REPLY, MAC2, MAC1, IP2, IP1);
Ethernet arpRequest = buildArp(ARP.OP_REPLY, VLAN1, MAC2, MAC1, IP2, IP1);
proxyArp.forward(arpRequest, LOC2);
......@@ -804,22 +973,15 @@ public class ProxyArpManagerTest {
*/
@Test
public void testForwardFlood() {
expect(hostService.getHost(HID1)).andReturn(null);
expect(hostService.getHost(HID2)).andReturn(null);
replay(hostService);
replay(interfaceService);
Ethernet arpRequest = buildArp(ARP.OP_REPLY, MAC2, MAC1, IP2, IP1);
//populate the list of edges when so that when forward hits flood in the manager it contains the values
//that should continue on
getEdgePointsNoArg = Lists.newLinkedList();
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("3"), PortNumber.portNumber(1)));
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("5"), PortNumber.portNumber(1)));
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("4"), PortNumber.portNumber(1)));
Ethernet arpRequest = buildArp(ARP.OP_REPLY, VLAN1, MAC1, MAC2, IP1, IP2);
proxyArp.forward(arpRequest, getLocation(6));
proxyArp.forward(arpRequest, getLocation(NUM_DEVICES));
verifyFlood(arpRequest);
verifyFlood(arpRequest, noConfigCPoints);
}
/**
......@@ -837,16 +999,9 @@ public class ProxyArpManagerTest {
MAC4, SOLICITED_MAC3,
IP4, IP3);
//populate the list of edges when so that when forward hits flood in the manager it contains the values
//that should continue on
getEdgePointsNoArg = Lists.newLinkedList();
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("3"), PortNumber.portNumber(1)));
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("5"), PortNumber.portNumber(1)));
getEdgePointsNoArg.add(new ConnectPoint(DeviceId.deviceId("4"), PortNumber.portNumber(1)));
proxyArp.forward(ndpRequest, getLocation(NUM_DEVICES));
proxyArp.forward(ndpRequest, getLocation(6));
verifyFlood(ndpRequest);
verifyFlood(ndpRequest, noConfigCPoints);
}
/**
......@@ -854,21 +1009,20 @@ public class ProxyArpManagerTest {
* except for the input port.
*
* @param packet the packet that was expected to be flooded
* @param connectPoints the connectPoints where the outpacket should be
* observed
*/
private void verifyFlood(Ethernet packet) {
private void verifyFlood(Ethernet packet, List<ConnectPoint> connectPoints) {
// There should be 1 less than NUM_FLOOD_PORTS; the inPort should be excluded.
assertEquals(NUM_FLOOD_PORTS - 1, packetService.packets.size());
assertEquals(connectPoints.size() - 1, packetService.packets.size());
Collections.sort(packetService.packets,
(o1, o2) -> o1.sendThrough().uri().compareTo(o2.sendThrough().uri()));
for (int i = 0; i < NUM_FLOOD_PORTS - 1; i++) {
ConnectPoint cp = new ConnectPoint(getDeviceId(NUM_ADDRESS_PORTS + i + 1),
PortNumber.portNumber(1));
for (int i = 0; i < connectPoints.size() - 1; i++) {
OutboundPacket outboundPacket = packetService.packets.get(i);
verifyPacketOut(packet, cp, outboundPacket);
verifyPacketOut(packet, connectPoints.get(i), outboundPacket);
}
}
......@@ -913,8 +1067,8 @@ public class ProxyArpManagerTest {
* @param dstIp destination IP address
* @return the ARP packet
*/
private Ethernet buildArp(short opcode, MacAddress srcMac, MacAddress dstMac,
Ip4Address srcIp, Ip4Address dstIp) {
private Ethernet buildArp(short opcode, VlanId vlanId, MacAddress srcMac,
MacAddress dstMac, Ip4Address srcIp, Ip4Address dstIp) {
Ethernet eth = new Ethernet();
if (dstMac == null) {
......@@ -925,7 +1079,7 @@ public class ProxyArpManagerTest {
eth.setSourceMACAddress(srcMac);
eth.setEtherType(Ethernet.TYPE_ARP);
eth.setVlanID(VLAN1.toShort());
eth.setVlanID(vlanId.toShort());
ARP arp = new ARP();
arp.setOpCode(opcode);
......@@ -937,7 +1091,7 @@ public class ProxyArpManagerTest {
arp.setSenderHardwareAddress(srcMac.toBytes());
if (dstMac == null) {
arp.setTargetHardwareAddress(ZERO_MAC_ADDRESS);
arp.setTargetHardwareAddress(zeroMacAddress);
} else {
arp.setTargetHardwareAddress(dstMac.toBytes());
}
......@@ -1019,19 +1173,6 @@ public class ProxyArpManagerTest {
}
class TestEdgePortService extends EdgeManager {
@Override
public boolean isEdgePoint(ConnectPoint connectPoint) {
return isEdgePointReturn;
}
@Override
public Iterable<ConnectPoint> getEdgePoints() {
return getEdgePointsNoArg;
}
}
private class TestProxyArpStoreAdapter implements ProxyArpStore {
@Override
public void forward(ConnectPoint outPort, Host subject, ByteBuffer packet) {
......