Gitiles
Code Review Sign In
gerrit.onosproject.org / trellis-control / d66d6719db51155f84ca0014df6a5b726becd821 / . / app / src / test / java / org / onosproject / segmentrouting / DefaultRoutingHandlerTest.java
blob: 05abcfc995da78b23abb613f6bf2f0a38780eeda [file] [log] [blame]
Charles Chand66d6712018-03-29 16:03:41 -0700[diff] [blame^]1/*
2 * Copyright 2018-present Open Networking Foundation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package org.onosproject.segmentrouting;
17
18import com.google.common.collect.Sets;
19import org.junit.Before;
20import org.junit.Test;
21import org.onlab.packet.IpAddress;
22import org.onosproject.cluster.ClusterService;
23import org.onosproject.cluster.DefaultControllerNode;
24import org.onosproject.cluster.NodeId;
25import org.onosproject.mastership.MastershipService;
26import org.onosproject.net.DeviceId;
27import org.onosproject.net.device.DeviceService;
28import org.onosproject.segmentrouting.config.DeviceConfiguration;
29import org.onosproject.store.service.StorageService;
30import org.onosproject.store.service.TestConsistentMap;
31
32import java.util.Optional;
33
34import static org.easymock.EasyMock.createMock;
35import static org.easymock.EasyMock.expect;
36import static org.easymock.EasyMock.replay;
37import static org.easymock.EasyMock.reset;
38import static org.junit.Assert.*;
39
40public class DefaultRoutingHandlerTest {
41 private SegmentRoutingManager srManager;
42 private DefaultRoutingHandler dfh;
43
44 private static final DeviceId DEV1A = DeviceId.deviceId("of:1a");
45 private static final DeviceId DEV1B = DeviceId.deviceId("of:1b");
46 private static final DeviceId DEV2 = DeviceId.deviceId("of:2");
47
48 private static final NodeId NODE1 = NodeId.nodeId("192.168.1.1");
49 private static final NodeId NODE2 = NodeId.nodeId("192.168.1.2");
50 private static final NodeId NODE3 = NodeId.nodeId("192.168.1.3");
51 private static final IpAddress IP1 = IpAddress.valueOf("192.168.1.1");
52 private static final IpAddress IP2 = IpAddress.valueOf("192.168.1.2");
53 private static final IpAddress IP3 = IpAddress.valueOf("192.168.1.3");
54
55 @Before
56 public void setUp() {
57 srManager = createMock(SegmentRoutingManager.class);
58 srManager.storageService = createMock(StorageService.class);
59 expect(srManager.storageService.consistentMapBuilder()).andReturn(new TestConsistentMap.Builder<>()).anyTimes();
60 replay(srManager.storageService);
61 srManager.routingRulePopulator = createMock(RoutingRulePopulator.class);
62 srManager.deviceService = createMock(DeviceService.class);
63 srManager.deviceConfiguration = createMock(DeviceConfiguration.class);
64 srManager.mastershipService = createMock(MastershipService.class);
65 srManager.clusterService = createMock(ClusterService.class);
66 dfh = new DefaultRoutingHandler(srManager);
67 }
68
69 // Node 1 is the master of switch 1A, 1B, and 2
70 @Test
71 public void testShouldHandleRoutingCase1() {
72 expect(srManager.mastershipService.getMasterFor(DEV1A)).andReturn(NODE1).anyTimes();
73 expect(srManager.mastershipService.getMasterFor(DEV1B)).andReturn(NODE1).anyTimes();
74 expect(srManager.mastershipService.getMasterFor(DEV2)).andReturn(NODE1).anyTimes();
75 replay(srManager.mastershipService);
76
77 expect(srManager.getPairDeviceId(DEV1A)).andReturn(Optional.of(DEV1B)).anyTimes();
78 expect(srManager.getPairDeviceId(DEV1B)).andReturn(Optional.of(DEV1A)).anyTimes();
79 expect(srManager.getPairDeviceId(DEV2)).andReturn(Optional.empty()).anyTimes();
80 replay(srManager);
81
82 // Node 1 should program every device
83 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE1, IP1)).anyTimes();
84 replay(srManager.clusterService);
85 assertTrue(dfh.shouldProgram(DEV1A));
86 assertTrue(dfh.shouldProgram(DEV1B));
87 assertTrue(dfh.shouldProgram(DEV2));
88
89 reset(srManager.clusterService);
90
91 // Node 2 should program no device
92 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE2, IP2)).anyTimes();
93 replay(srManager.clusterService);
94 assertFalse(dfh.shouldProgram(DEV1A));
95 assertFalse(dfh.shouldProgram(DEV1B));
96 assertFalse(dfh.shouldProgram(DEV2));
97
98 reset(srManager.clusterService);
99
100 // Node 3 should program no device
101 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE3, IP3)).anyTimes();
102 replay(srManager.clusterService);
103 assertFalse(dfh.shouldProgram(DEV1A));
104 assertFalse(dfh.shouldProgram(DEV1B));
105 assertFalse(dfh.shouldProgram(DEV2));
106 }
107
108 // Node 1 is the master of switch 1A, 1B
109 // Node 2 is the master of switch 2
110 @Test
111 public void testShouldHandleRoutingCase2() {
112 expect(srManager.mastershipService.getMasterFor(DEV1A)).andReturn(NODE1).anyTimes();
113 expect(srManager.mastershipService.getMasterFor(DEV1B)).andReturn(NODE1).anyTimes();
114 expect(srManager.mastershipService.getMasterFor(DEV2)).andReturn(NODE2).anyTimes();
115 replay(srManager.mastershipService);
116
117 expect(srManager.getPairDeviceId(DEV1A)).andReturn(Optional.of(DEV1B)).anyTimes();
118 expect(srManager.getPairDeviceId(DEV1B)).andReturn(Optional.of(DEV1A)).anyTimes();
119 expect(srManager.getPairDeviceId(DEV2)).andReturn(Optional.empty()).anyTimes();
120 replay(srManager);
121
122 // Node 1 should program 1A, 1B
123 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE1, IP1)).anyTimes();
124 replay(srManager.clusterService);
125 assertTrue(dfh.shouldProgram(DEV1A));
126 assertTrue(dfh.shouldProgram(DEV1B));
127 assertFalse(dfh.shouldProgram(DEV2));
128
129 reset(srManager.clusterService);
130
131 // Node 2 should program 2
132 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE2, IP2)).anyTimes();
133 replay(srManager.clusterService);
134 assertFalse(dfh.shouldProgram(DEV1A));
135 assertFalse(dfh.shouldProgram(DEV1B));
136 assertTrue(dfh.shouldProgram(DEV2));
137
138 reset(srManager.clusterService);
139
140 // Node 3 should program no device
141 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE3, IP3)).anyTimes();
142 replay(srManager.clusterService);
143 assertFalse(dfh.shouldProgram(DEV1A));
144 assertFalse(dfh.shouldProgram(DEV1B));
145 assertFalse(dfh.shouldProgram(DEV2));
146 }
147
148 // Node 1 is the master of switch 1A
149 // Node 2 is the master of switch 1B
150 // Node 3 is the master of switch 2
151 @Test
152 public void testShouldHandleRoutingCase3() {
153 expect(srManager.mastershipService.getMasterFor(DEV1A)).andReturn(NODE1).anyTimes();
154 expect(srManager.mastershipService.getMasterFor(DEV1B)).andReturn(NODE2).anyTimes();
155 expect(srManager.mastershipService.getMasterFor(DEV2)).andReturn(NODE3).anyTimes();
156 replay(srManager.mastershipService);
157
158 expect(srManager.getPairDeviceId(DEV1A)).andReturn(Optional.of(DEV1B)).anyTimes();
159 expect(srManager.getPairDeviceId(DEV1B)).andReturn(Optional.of(DEV1A)).anyTimes();
160 expect(srManager.getPairDeviceId(DEV2)).andReturn(Optional.empty()).anyTimes();
161 replay(srManager);
162
163 // Node 1 should program 1A, 1B
164 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE1, IP1)).anyTimes();
165 replay(srManager.clusterService);
166 assertTrue(dfh.shouldProgram(DEV1A));
167 assertTrue(dfh.shouldProgram(DEV1B));
168 assertFalse(dfh.shouldProgram(DEV2));
169
170 reset(srManager.clusterService);
171
172 // Node 2 should program no device
173 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE2, IP2)).anyTimes();
174 replay(srManager.clusterService);
175 assertFalse(dfh.shouldProgram(DEV1A));
176 assertFalse(dfh.shouldProgram(DEV1B));
177 assertFalse(dfh.shouldProgram(DEV2));
178
179 reset(srManager.clusterService);
180
181 // Node 3 should program 2
182 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE3, IP3)).anyTimes();
183 replay(srManager.clusterService);
184 assertFalse(dfh.shouldProgram(DEV1A));
185 assertFalse(dfh.shouldProgram(DEV1B));
186 assertTrue(dfh.shouldProgram(DEV2));
187 }
188
189 // Node 3 is the master of switch 1A, 1B, 2
190 // Later on, node 1 becomes the master of 1A; Node 2 becomes the master of 1B.
191 @Test
192 public void testShouldHandleRoutingCase4() {
193 expect(srManager.mastershipService.getMasterFor(DEV1A)).andReturn(NODE3).anyTimes();
194 expect(srManager.mastershipService.getMasterFor(DEV1B)).andReturn(NODE3).anyTimes();
195 expect(srManager.mastershipService.getMasterFor(DEV2)).andReturn(NODE3).anyTimes();
196 replay(srManager.mastershipService);
197
198 expect(srManager.getPairDeviceId(DEV1A)).andReturn(Optional.of(DEV1B)).anyTimes();
199 expect(srManager.getPairDeviceId(DEV1B)).andReturn(Optional.of(DEV1A)).anyTimes();
200 expect(srManager.getPairDeviceId(DEV2)).andReturn(Optional.empty()).anyTimes();
201 replay(srManager);
202
203 // Node 1 should program no device
204 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE1, IP1)).anyTimes();
205 replay(srManager.clusterService);
206 assertFalse(dfh.shouldProgram(DEV1A));
207 assertFalse(dfh.shouldProgram(DEV1B));
208 assertFalse(dfh.shouldProgram(DEV2));
209
210 reset(srManager.clusterService);
211
212 // Node 2 should program no device
213 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE2, IP2)).anyTimes();
214 replay(srManager.clusterService);
215 assertFalse(dfh.shouldProgram(DEV1A));
216 assertFalse(dfh.shouldProgram(DEV1B));
217 assertFalse(dfh.shouldProgram(DEV2));
218
219 reset(srManager.clusterService);
220
221 // Node 3 should program 1A, 1B and 2
222 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE3, IP3)).anyTimes();
223 replay(srManager.clusterService);
224 assertTrue(dfh.shouldProgram(DEV1A));
225 assertTrue(dfh.shouldProgram(DEV1B));
226 assertTrue(dfh.shouldProgram(DEV2));
227
228 // Mastership of switch 1A moves to Node 1
229 reset(srManager.mastershipService);
230 expect(srManager.mastershipService.getMasterFor(DEV1A)).andReturn(NODE1).anyTimes();
231 expect(srManager.mastershipService.getMasterFor(DEV1B)).andReturn(NODE2).anyTimes();
232 expect(srManager.mastershipService.getMasterFor(DEV2)).andReturn(NODE3).anyTimes();
233 replay(srManager.mastershipService);
234
235 reset(srManager.clusterService);
236
237 // Node 1 should program 1A, 1B
238 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE1, IP1)).anyTimes();
239 replay(srManager.clusterService);
240 assertTrue(dfh.shouldProgram(DEV1A));
241 assertTrue(dfh.shouldProgram(DEV1B));
242 assertFalse(dfh.shouldProgram(DEV2));
243
244 reset(srManager.clusterService);
245
246 // Node 2 should program no device
247 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE2, IP2)).anyTimes();
248 replay(srManager.clusterService);
249 assertFalse(dfh.shouldProgram(DEV1A));
250 assertFalse(dfh.shouldProgram(DEV1B));
251 assertFalse(dfh.shouldProgram(DEV2));
252
253 reset(srManager.clusterService);
254
255 // Node 3 should program 2
256 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE3, IP3)).anyTimes();
257 replay(srManager.clusterService);
258 assertFalse(dfh.shouldProgram(DEV1A));
259 assertFalse(dfh.shouldProgram(DEV1B));
260 assertTrue(dfh.shouldProgram(DEV2));
261 }
262
263 // Node 1 is the master of 1A. 1B has no master
264 // Node 2 becomes the master of 1B later
265 @Test
266 public void testShouldHandleRoutingCase5() {
267 expect(srManager.mastershipService.getMasterFor(DEV1A)).andReturn(NODE1).anyTimes();
268 expect(srManager.mastershipService.getMasterFor(DEV1B)).andReturn(null).anyTimes();
269 replay(srManager.mastershipService);
270
271 expect(srManager.getPairDeviceId(DEV1A)).andReturn(Optional.of(DEV1B)).anyTimes();
272 expect(srManager.getPairDeviceId(DEV1B)).andReturn(Optional.of(DEV1A)).anyTimes();
273 replay(srManager);
274
275 // Node 1 should program both 1A and 1B
276 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE1, IP1)).anyTimes();
277 replay(srManager.clusterService);
278 assertTrue(dfh.shouldProgram(DEV1A));
279 assertTrue(dfh.shouldProgram(DEV1B));
280
281 reset(srManager.clusterService);
282
283 // Node 2 should program no device
284 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE2, IP2)).anyTimes();
285 replay(srManager.clusterService);
286 assertFalse(dfh.shouldProgram(DEV1A));
287 assertFalse(dfh.shouldProgram(DEV1B));
288
289 // Mastership of switch 1B moves to Node 2
290 reset(srManager.mastershipService);
291 expect(srManager.mastershipService.getMasterFor(DEV1A)).andReturn(NODE1).anyTimes();
292 expect(srManager.mastershipService.getMasterFor(DEV1B)).andReturn(NODE2).anyTimes();
293 replay(srManager.mastershipService);
294
295 reset(srManager.clusterService);
296
297 // Node 1 should program 1A, 1B
298 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE1, IP1)).anyTimes();
299 replay(srManager.clusterService);
300 assertTrue(dfh.shouldProgram(DEV1A));
301 assertTrue(dfh.shouldProgram(DEV1B));
302
303 reset(srManager.clusterService);
304
305 // Node 2 should program no device
306 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE2, IP2)).anyTimes();
307 replay(srManager.clusterService);
308 assertFalse(dfh.shouldProgram(DEV1A));
309 assertFalse(dfh.shouldProgram(DEV1B));
310 }
311
312 // Neither 1A or 1B has master
313 @Test
314 public void testShouldHandleRoutingCase6() {
315 expect(srManager.mastershipService.getMasterFor(DEV1A)).andReturn(null).anyTimes();
316 expect(srManager.mastershipService.getMasterFor(DEV1B)).andReturn(null).anyTimes();
317 replay(srManager.mastershipService);
318
319 expect(srManager.getPairDeviceId(DEV1A)).andReturn(Optional.of(DEV1B)).anyTimes();
320 expect(srManager.getPairDeviceId(DEV1B)).andReturn(Optional.of(DEV1A)).anyTimes();
321 replay(srManager);
322
323 // Node 1 should program no device
324 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE1, IP1)).anyTimes();
325 replay(srManager.clusterService);
326 assertFalse(dfh.shouldProgram(DEV1A));
327 assertFalse(dfh.shouldProgram(DEV1B));
328
329 reset(srManager.clusterService);
330
331 // Node 2 should program no device
332 expect(srManager.clusterService.getLocalNode()).andReturn(new DefaultControllerNode(NODE2, IP2)).anyTimes();
333 replay(srManager.clusterService);
334 assertFalse(dfh.shouldProgram(DEV1A));
335 assertFalse(dfh.shouldProgram(DEV1B));
336
337 assertFalse(dfh.shouldProgram.containsKey(Sets.newHashSet(DEV1A, DEV1B)));
338 }
339}