Implement unit test for HostHandler
Change-Id: I0ba37731f70b98019962b4f7deaf88fc2245ea6c
diff --git a/BUCK b/BUCK
index 865cd75..3f4e968 100644
--- a/BUCK
+++ b/BUCK
@@ -15,6 +15,7 @@
TEST_DEPS = [
'//lib:TEST_ADAPTERS',
+ '//incubator/api:onos-incubator-api-tests',
]
osgi_jar_with_tests (
diff --git a/src/main/java/org/onosproject/segmentrouting/HostHandler.java b/src/main/java/org/onosproject/segmentrouting/HostHandler.java
index 399652b..3f5826b 100644
--- a/src/main/java/org/onosproject/segmentrouting/HostHandler.java
+++ b/src/main/java/org/onosproject/segmentrouting/HostHandler.java
@@ -47,7 +47,7 @@
*/
public class HostHandler {
private static final Logger log = LoggerFactory.getLogger(HostHandler.class);
- private final SegmentRoutingManager srManager;
+ protected final SegmentRoutingManager srManager;
private HostService hostService;
private FlowObjectiveService flowObjectiveService;
diff --git a/src/test/java/org/onosproject/segmentrouting/HostHandlerTest.java b/src/test/java/org/onosproject/segmentrouting/HostHandlerTest.java
new file mode 100644
index 0000000..ca89a1d
--- /dev/null
+++ b/src/test/java/org/onosproject/segmentrouting/HostHandlerTest.java
@@ -0,0 +1,491 @@
+/*
+ * Copyright 2017-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.segmentrouting;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.IpPrefix;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onosproject.core.DefaultApplicationId;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.incubator.net.intf.InterfaceServiceAdapter;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DefaultHost;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Host;
+import org.onosproject.net.HostId;
+import org.onosproject.net.HostLocation;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.config.NetworkConfigRegistryAdapter;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flow.criteria.Criterion;
+import org.onosproject.net.flow.criteria.EthCriterion;
+import org.onosproject.net.flow.criteria.VlanIdCriterion;
+import org.onosproject.net.flow.instructions.Instruction;
+import org.onosproject.net.flow.instructions.Instructions;
+import org.onosproject.net.flow.instructions.L2ModificationInstruction;
+import org.onosproject.net.flowobjective.FlowObjectiveServiceAdapter;
+import org.onosproject.net.flowobjective.ForwardingObjective;
+import org.onosproject.net.flowobjective.Objective;
+import org.onosproject.net.host.HostEvent;
+import org.onosproject.net.host.InterfaceIpAddress;
+import org.onosproject.net.provider.ProviderId;
+import org.onosproject.segmentrouting.config.DeviceConfiguration;
+
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.Assert.*;
+
+/**
+ * Unit test for {@link HostHandler}.
+ */
+public class HostHandlerTest {
+ private SegmentRoutingManager srManager;
+ private HostHandler hostHandler;
+
+ // Mocked routing and bridging tables
+ private Map<BridingTableKey, BridingTableValue> bridgingTable = Maps.newConcurrentMap();
+ private Map<RoutingTableKey, RoutingTableValue> routingTable = Maps.newConcurrentMap();
+ // Mocked Next Id
+ private Map<Integer, TrafficTreatment> nextTable = Maps.newConcurrentMap();
+ private AtomicInteger atomicNextId = new AtomicInteger();
+
+ // Host information
+ private static final ProviderId PROVIDER_ID = ProviderId.NONE;
+ private static final MacAddress HOST_MAC = MacAddress.valueOf("00:00:00:00:00:01");
+ private static final VlanId HOST_VLAN_UNTAGGED = VlanId.NONE;
+ private static final HostId HOST_ID_UNTAGGED = HostId.hostId(HOST_MAC, HOST_VLAN_UNTAGGED);
+ private static final VlanId HOST_VLAN_TAGGED = VlanId.vlanId((short) 20);
+ private static final HostId HOST_ID_TAGGED = HostId.hostId(HOST_MAC, HOST_VLAN_TAGGED);
+ private static final IpAddress HOST_IP1 = IpAddress.valueOf("10.0.1.1");
+ private static final IpAddress HOST_IP2 = IpAddress.valueOf("10.0.2.1");
+ private static final IpAddress HOST_IP3 = IpAddress.valueOf("10.0.1.2");
+
+ // Untagged interface
+ private static final ConnectPoint CP1 = new ConnectPoint(DeviceId.deviceId("of:0000000000000001"),
+ PortNumber.portNumber(10));
+ private static final HostLocation HOST_LOC1 = new HostLocation(CP1, 0);
+ private static final IpPrefix INTF_PREFIX1 = IpPrefix.valueOf("10.0.1.254/24");
+ private static final InterfaceIpAddress INTF_IP1 = new InterfaceIpAddress(INTF_PREFIX1.address(),
+ INTF_PREFIX1);
+ private static final VlanId INTF_VLAN_UNTAGGED = VlanId.vlanId((short) 10);
+
+ // Another untagged interface with same subnet and vlan
+ private static final ConnectPoint CP3 = new ConnectPoint(DeviceId.deviceId("of:0000000000000002"),
+ PortNumber.portNumber(30));
+ private static final HostLocation HOST_LOC3 = new HostLocation(CP3, 0);
+
+ // Tagged/Native interface
+ private static final ConnectPoint CP2 = new ConnectPoint(DeviceId.deviceId("of:0000000000000001"),
+ PortNumber.portNumber(20));
+ private static final HostLocation HOST_LOC2 = new HostLocation(CP2, 0);
+ private static final IpPrefix INTF_PREFIX2 = IpPrefix.valueOf("10.0.2.254/24");
+ private static final InterfaceIpAddress INTF_IP2 = new InterfaceIpAddress(INTF_PREFIX2.address(),
+ INTF_PREFIX2);
+ private static final Set<VlanId> INTF_VLAN_TAGGED = Sets.newHashSet(VlanId.vlanId((short) 20));
+ private static final VlanId INTF_VLAN_NATIVE = VlanId.vlanId((short) 30);
+
+ @Before
+ public void setUp() throws Exception {
+ srManager = new MockSegmentRoutingManager();
+ srManager.cfgService = new NetworkConfigRegistryAdapter();
+ srManager.deviceConfiguration = new DeviceConfiguration(srManager);
+ srManager.flowObjectiveService = new MockFlowObjectiveService();
+ srManager.routingRulePopulator = new MockRoutingRulePopulator();
+ srManager.interfaceService = new MockInterfaceService();
+
+ hostHandler = new HostHandler(srManager);
+
+ routingTable.clear();
+ bridgingTable.clear();
+ }
+
+ @Test
+ public void init() throws Exception {
+ // TODO Implement test for init()
+ }
+
+ @Test
+ public void testHostAdded() throws Exception {
+ Host subject;
+
+ // Untagged host discovered on untagged port
+ // Expect: add one routing rule and one bridging rule
+ subject = new DefaultHost(PROVIDER_ID, HOST_ID_UNTAGGED, HOST_MAC, HOST_VLAN_UNTAGGED,
+ Sets.newHashSet(HOST_LOC1), Sets.newHashSet(HOST_IP1), false);
+ hostHandler.processHostAddedEvent(new HostEvent(HostEvent.Type.HOST_ADDED, subject));
+ assertEquals(1, routingTable.size());
+ assertNotNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP1.toIpPrefix())));
+ assertEquals(1, bridgingTable.size());
+ assertNotNull(bridgingTable.get(new BridingTableKey(HOST_LOC1.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+
+ // Untagged host discovered on tagged/native port
+ // Expect: add one routing rule and one bridging rule
+ subject = new DefaultHost(PROVIDER_ID, HOST_ID_UNTAGGED, HOST_MAC, HOST_VLAN_UNTAGGED,
+ Sets.newHashSet(HOST_LOC2), Sets.newHashSet(HOST_IP2), false);
+ hostHandler.processHostAddedEvent(new HostEvent(HostEvent.Type.HOST_ADDED, subject));
+ assertEquals(2, routingTable.size());
+ assertNotNull(routingTable.get(new RoutingTableKey(HOST_LOC2.deviceId(), HOST_IP2.toIpPrefix())));
+ assertEquals(2, bridgingTable.size());
+ assertNotNull(bridgingTable.get(new BridingTableKey(HOST_LOC2.deviceId(), HOST_MAC, INTF_VLAN_NATIVE)));
+
+ // Tagged host discovered on untagged port
+ // Expect: ignore the host. No rule is added.
+ subject = new DefaultHost(PROVIDER_ID, HOST_ID_TAGGED, HOST_MAC, HOST_VLAN_TAGGED,
+ Sets.newHashSet(HOST_LOC1), Sets.newHashSet(HOST_IP1), false);
+ hostHandler.processHostAddedEvent(new HostEvent(HostEvent.Type.HOST_ADDED, subject));
+ assertEquals(2, routingTable.size());
+ assertEquals(2, bridgingTable.size());
+
+ // Tagged host discovered on tagged port with the same IP
+ // Expect: update existing route, add one bridging rule
+ subject = new DefaultHost(PROVIDER_ID, HOST_ID_TAGGED, HOST_MAC, HOST_VLAN_TAGGED,
+ Sets.newHashSet(HOST_LOC2), Sets.newHashSet(HOST_IP2), false);
+ hostHandler.processHostAddedEvent(new HostEvent(HostEvent.Type.HOST_ADDED, subject));
+ assertEquals(2, routingTable.size());
+ assertNotNull(routingTable.get(new RoutingTableKey(HOST_LOC2.deviceId(), HOST_IP2.toIpPrefix())));
+ assertEquals(HOST_VLAN_TAGGED, routingTable.get(new RoutingTableKey(HOST_LOC2.deviceId(),
+ HOST_IP2.toIpPrefix())).vlanId);
+ assertEquals(3, bridgingTable.size());
+ assertNotNull(bridgingTable.get(new BridingTableKey(HOST_LOC2.deviceId(), HOST_MAC, HOST_VLAN_TAGGED)));
+ }
+
+ @Test
+ public void testHostRemoved() throws Exception {
+ Host subject = new DefaultHost(PROVIDER_ID, HOST_ID_UNTAGGED, HOST_MAC, HOST_VLAN_UNTAGGED,
+ Sets.newHashSet(HOST_LOC1), Sets.newHashSet(HOST_IP1), false);
+
+ // Add a host
+ // Expect: add one routing rule and one bridging rule
+ hostHandler.processHostAddedEvent(new HostEvent(HostEvent.Type.HOST_ADDED, subject));
+ assertEquals(1, routingTable.size());
+ assertNotNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP1.toIpPrefix())));
+ assertEquals(1, bridgingTable.size());
+ assertNotNull(bridgingTable.get(new BridingTableKey(HOST_LOC1.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+
+ // Remove the host
+ // Expect: add the routing rule and the bridging rule
+ hostHandler.processHostRemoveEvent(new HostEvent(HostEvent.Type.HOST_REMOVED, subject));
+ assertEquals(0, routingTable.size());
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP2.toIpPrefix())));
+ assertEquals(0, bridgingTable.size());
+ assertNull(bridgingTable.get(new BridingTableKey(HOST_LOC1.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+ }
+
+ @Test
+ public void testHostMoved() throws Exception {
+ Host host1 = new DefaultHost(PROVIDER_ID, HOST_ID_UNTAGGED, HOST_MAC, HOST_VLAN_UNTAGGED,
+ Sets.newHashSet(HOST_LOC1), Sets.newHashSet(HOST_IP1), false);
+ Host host2 = new DefaultHost(PROVIDER_ID, HOST_ID_UNTAGGED, HOST_MAC, HOST_VLAN_UNTAGGED,
+ Sets.newHashSet(HOST_LOC2), Sets.newHashSet(HOST_IP1), false);
+ Host host3 = new DefaultHost(PROVIDER_ID, HOST_ID_UNTAGGED, HOST_MAC, HOST_VLAN_UNTAGGED,
+ Sets.newHashSet(HOST_LOC3), Sets.newHashSet(HOST_IP1), false);
+
+ // Add a host
+ // Expect: add a new routing rule. no change to bridging rule.
+ hostHandler.processHostAddedEvent(new HostEvent(HostEvent.Type.HOST_ADDED, host1));
+ assertEquals(1, routingTable.size());
+ assertNotNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP1.toIpPrefix())));
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP2.toIpPrefix())));
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP3.toIpPrefix())));
+ assertEquals(1, bridgingTable.size());
+ assertNotNull(bridgingTable.get(new BridingTableKey(HOST_LOC1.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+ assertNull(bridgingTable.get(new BridingTableKey(HOST_LOC3.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+
+ // Move the host to CP2, which has different subnet setting
+ // Expect: remove routing rule. Change vlan in bridging rule.
+ hostHandler.processHostMovedEvent(new HostEvent(HostEvent.Type.HOST_MOVED, host2, host1));
+ assertEquals(0, routingTable.size());
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP1.toIpPrefix())));
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC2.deviceId(), HOST_IP1.toIpPrefix())));
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC3.deviceId(), HOST_IP1.toIpPrefix())));
+ assertEquals(1, bridgingTable.size());
+ assertNotNull(bridgingTable.get(new BridingTableKey(HOST_LOC2.deviceId(), HOST_MAC, INTF_VLAN_NATIVE)));
+ assertNull(bridgingTable.get(new BridingTableKey(HOST_LOC3.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+
+ // Move the host to CP3, which has same subnet setting
+ // Expect: add a new routing rule. Change vlan in bridging rule.
+ hostHandler.processHostMovedEvent(new HostEvent(HostEvent.Type.HOST_MOVED, host3, host2));
+ assertEquals(1, routingTable.size());
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP1.toIpPrefix())));
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC2.deviceId(), HOST_IP1.toIpPrefix())));
+ assertNotNull(routingTable.get(new RoutingTableKey(HOST_LOC3.deviceId(), HOST_IP1.toIpPrefix())));
+ assertEquals(1, bridgingTable.size());
+ assertNull(bridgingTable.get(new BridingTableKey(HOST_LOC1.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+ assertNotNull(bridgingTable.get(new BridingTableKey(HOST_LOC3.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+ }
+
+ @Test
+ public void testHostUpdated() throws Exception {
+ Host host1 = new DefaultHost(PROVIDER_ID, HOST_ID_UNTAGGED, HOST_MAC, HOST_VLAN_UNTAGGED,
+ Sets.newHashSet(HOST_LOC1), Sets.newHashSet(HOST_IP1), false);
+ Host host2 = new DefaultHost(PROVIDER_ID, HOST_ID_UNTAGGED, HOST_MAC, HOST_VLAN_UNTAGGED,
+ Sets.newHashSet(HOST_LOC1), Sets.newHashSet(HOST_IP2), false);
+ Host host3 = new DefaultHost(PROVIDER_ID, HOST_ID_UNTAGGED, HOST_MAC, HOST_VLAN_UNTAGGED,
+ Sets.newHashSet(HOST_LOC1), Sets.newHashSet(HOST_IP3), false);
+
+ // Add a host
+ // Expect: add a new routing rule. no change to bridging rule.
+ hostHandler.processHostAddedEvent(new HostEvent(HostEvent.Type.HOST_ADDED, host1));
+ assertEquals(1, routingTable.size());
+ assertNotNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP1.toIpPrefix())));
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP2.toIpPrefix())));
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP3.toIpPrefix())));
+ assertEquals(1, bridgingTable.size());
+ assertNotNull(bridgingTable.get(new BridingTableKey(HOST_LOC1.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+
+ // Update the host IP to same subnet
+ // Expect: update routing rule with new IP. No change to bridging rule.
+ hostHandler.processHostUpdatedEvent(new HostEvent(HostEvent.Type.HOST_UPDATED, host3, host1));
+ assertEquals(1, routingTable.size());
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP1.toIpPrefix())));
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP2.toIpPrefix())));
+ assertNotNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP3.toIpPrefix())));
+ assertEquals(1, bridgingTable.size());
+ assertNotNull(bridgingTable.get(new BridingTableKey(HOST_LOC1.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+
+ // Update the host IP to different subnet
+ // Expect: Remove routing rule. No change to bridging rule.
+ hostHandler.processHostUpdatedEvent(new HostEvent(HostEvent.Type.HOST_UPDATED, host2, host3));
+ assertEquals(0, routingTable.size());
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP1.toIpPrefix())));
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP2.toIpPrefix())));
+ assertNull(routingTable.get(new RoutingTableKey(HOST_LOC1.deviceId(), HOST_IP3.toIpPrefix())));
+ assertEquals(1, bridgingTable.size());
+ assertNotNull(bridgingTable.get(new BridingTableKey(HOST_LOC1.deviceId(), HOST_MAC, INTF_VLAN_UNTAGGED)));
+ }
+
+ class MockSegmentRoutingManager extends SegmentRoutingManager {
+ MockSegmentRoutingManager() {
+ appId = new DefaultApplicationId(1, SegmentRoutingManager.APP_NAME);
+ }
+
+ @Override
+ public int getPortNextObjectiveId(DeviceId deviceId, PortNumber portNum,
+ TrafficTreatment treatment,
+ TrafficSelector meta,
+ boolean createIfMissing) {
+ int nextId = atomicNextId.incrementAndGet();
+ nextTable.put(nextId, treatment);
+ return nextId;
+ }
+ }
+
+ class MockInterfaceService extends InterfaceServiceAdapter {
+ @Override
+ public Set<Interface> getInterfacesByPort(ConnectPoint cp) {
+ Interface intf = null;
+
+ if (CP1.equals(cp)) {
+ intf = new Interface(null, CP1, Lists.newArrayList(INTF_IP1), MacAddress.NONE, null,
+ INTF_VLAN_UNTAGGED, null, null);
+ } else if (CP2.equals(cp)) {
+ intf = new Interface(null, CP2, Lists.newArrayList(INTF_IP2), MacAddress.NONE, null,
+ null, INTF_VLAN_TAGGED, INTF_VLAN_NATIVE);
+ } else if (CP3.equals(cp)) {
+ intf = new Interface(null, CP3, Lists.newArrayList(INTF_IP1), MacAddress.NONE, null,
+ INTF_VLAN_UNTAGGED, null, null);
+ }
+
+ return Objects.nonNull(intf) ? Sets.newHashSet(intf) : Sets.newHashSet();
+ }
+ }
+
+ class MockFlowObjectiveService extends FlowObjectiveServiceAdapter {
+ @Override
+ public void forward(DeviceId deviceId, ForwardingObjective forwardingObjective) {
+ TrafficSelector selector = forwardingObjective.selector();
+ TrafficTreatment treatment = nextTable.get(forwardingObjective.nextId());
+ MacAddress macAddress = ((EthCriterion) selector.getCriterion(Criterion.Type.ETH_DST)).mac();
+ VlanId vlanId = ((VlanIdCriterion) selector.getCriterion(Criterion.Type.VLAN_VID)).vlanId();
+
+ boolean popVlan = treatment.allInstructions().stream()
+ .filter(instruction -> instruction.type().equals(Instruction.Type.L2MODIFICATION))
+ .anyMatch(instruction -> ((L2ModificationInstruction) instruction).subtype()
+ .equals(L2ModificationInstruction.L2SubType.VLAN_POP));
+ PortNumber portNumber = treatment.allInstructions().stream()
+ .filter(instruction -> instruction.type().equals(Instruction.Type.OUTPUT))
+ .map(instruction -> ((Instructions.OutputInstruction) instruction).port()).findFirst().orElse(null);
+ if (portNumber == null) {
+ throw new IllegalArgumentException();
+ }
+
+ Objective.Operation op = forwardingObjective.op();
+
+ BridingTableKey btKey = new BridingTableKey(deviceId, macAddress, vlanId);
+ BridingTableValue btValue = new BridingTableValue(popVlan, portNumber);
+
+ if (op.equals(Objective.Operation.ADD)) {
+ bridgingTable.put(btKey, btValue);
+ } else if (op.equals(Objective.Operation.REMOVE)) {
+ bridgingTable.remove(btKey, btValue);
+ } else {
+ throw new IllegalArgumentException();
+ }
+ }
+ }
+
+ class MockRoutingRulePopulator extends RoutingRulePopulator {
+ MockRoutingRulePopulator() {
+ super(srManager);
+ }
+
+ @Override
+ public void populateRoute(DeviceId deviceId, IpPrefix prefix,
+ MacAddress hostMac, VlanId hostVlanId, PortNumber outPort) {
+ RoutingTableKey rtKey = new RoutingTableKey(deviceId, prefix);
+ RoutingTableValue rtValue = new RoutingTableValue(outPort, hostMac, hostVlanId);
+ routingTable.put(rtKey, rtValue);
+ }
+
+ @Override
+ public void revokeRoute(DeviceId deviceId, IpPrefix prefix,
+ MacAddress hostMac, VlanId hostVlanId, PortNumber outPort) {
+ RoutingTableKey rtKey = new RoutingTableKey(deviceId, prefix);
+ RoutingTableValue rtValue = new RoutingTableValue(outPort, hostMac, hostVlanId);
+ routingTable.remove(rtKey, rtValue);
+ }
+ }
+
+ class BridingTableKey {
+ DeviceId deviceId;
+ MacAddress macAddress;
+ VlanId vlanId;
+
+ BridingTableKey(DeviceId deviceId, MacAddress macAddress, VlanId vlanId) {
+ this.deviceId = deviceId;
+ this.macAddress = macAddress;
+ this.vlanId = vlanId;
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof BridingTableKey)) {
+ return false;
+ }
+ final BridingTableKey other = (BridingTableKey) obj;
+ return Objects.equals(this.macAddress, other.macAddress) &&
+ Objects.equals(this.deviceId, other.deviceId) &&
+ Objects.equals(this.vlanId, other.vlanId);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(macAddress, vlanId);
+ }
+ }
+
+ class BridingTableValue {
+ boolean popVlan;
+ PortNumber portNumber;
+
+ BridingTableValue(boolean popVlan, PortNumber portNumber) {
+ this.popVlan = popVlan;
+ this.portNumber = portNumber;
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof BridingTableValue)) {
+ return false;
+ }
+ final BridingTableValue other = (BridingTableValue) obj;
+ return Objects.equals(this.popVlan, other.popVlan) &&
+ Objects.equals(this.portNumber, other.portNumber);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(popVlan, portNumber);
+ }
+ }
+
+ class RoutingTableKey {
+ DeviceId deviceId;
+ IpPrefix ipPrefix;
+
+ RoutingTableKey(DeviceId deviceId, IpPrefix ipPrefix) {
+ this.deviceId = deviceId;
+ this.ipPrefix = ipPrefix;
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof RoutingTableKey)) {
+ return false;
+ }
+ final RoutingTableKey other = (RoutingTableKey) obj;
+ return Objects.equals(this.deviceId, other.deviceId) &&
+ Objects.equals(this.ipPrefix, other.ipPrefix);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(deviceId, ipPrefix);
+ }
+ }
+
+ class RoutingTableValue {
+ PortNumber portNumber;
+ MacAddress macAddress;
+ VlanId vlanId;
+
+ RoutingTableValue(PortNumber portNumber, MacAddress macAddress, VlanId vlanId) {
+ this.portNumber = portNumber;
+ this.macAddress = macAddress;
+ this.vlanId = vlanId;
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof RoutingTableValue)) {
+ return false;
+ }
+ final RoutingTableValue other = (RoutingTableValue) obj;
+ return Objects.equals(this.portNumber, other.portNumber) &&
+ Objects.equals(this.macAddress, other.macAddress) &&
+ Objects.equals(this.vlanId, other.vlanId);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(portNumber, macAddress, vlanId);
+ }
+ }
+
+}
\ No newline at end of file