1 package org.opendaylight.controller.hosttracker.internal;
4 // * Copyright (c) 2011,2013 Big Switch Networks, Inc.
6 // * Licensed under the Eclipse Public License, Version 1.0 (the
7 // * "License"); you may not use this file except in compliance with the
8 // * License. You may obtain a copy of the License at
10 // * http://www.eclipse.org/legal/epl-v10.html
12 // * Unless required by applicable law or agreed to in writing, software
13 // * distributed under the License is distributed on an "AS IS" BASIS,
14 // * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15 // * implied. See the License for the specific language governing
16 // * permissions and limitations under the License.
18 // * This file incorporates work covered by the following copyright and
19 // * permission notice:
21 // * Originally created by David Erickson, Stanford University
23 // * Licensed under the Apache License, Version 2.0 (the "License");
24 // * you may not use this file except in compliance with the
25 // * License. You may obtain a copy of the License at
27 // * http://www.apache.org/licenses/LICENSE-2.0
29 // * Unless required by applicable law or agreed to in writing,
30 // * software distributed under the License is distributed on an "AS
31 // * IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
32 // * express or implied. See the License for the specific language
33 // * governing permissions and limitations under the License.
36 //package org.opendaylight.controller.hosttracker.internal;
38 //import static org.easymock.EasyMock.anyLong;
39 //import static org.easymock.EasyMock.anyObject;
40 //import static org.easymock.EasyMock.anyShort;
41 //import static org.easymock.EasyMock.createMock;
42 //import static org.easymock.EasyMock.createNiceMock;
43 //import static org.easymock.EasyMock.eq;
44 //import static org.easymock.EasyMock.expect;
45 //import static org.easymock.EasyMock.expectLastCall;
46 //import static org.easymock.EasyMock.isA;
47 //import static org.easymock.EasyMock.or;
48 //import static org.easymock.EasyMock.replay;
49 //import static org.easymock.EasyMock.reset;
50 //import static org.easymock.EasyMock.verify;
51 //import static org.junit.Assert.*;
53 //import java.util.ArrayList;
54 //import java.util.Arrays;
55 //import java.util.Calendar;
56 //import java.util.Collection;
57 //import java.util.Collections;
58 //import java.util.Date;
59 //import java.util.EnumSet;
60 //import java.util.HashMap;
61 //import java.util.HashSet;
62 //import java.util.Iterator;
63 //import java.util.List;
64 //import java.util.Map;
65 //import java.util.Map.Entry;
66 //import java.util.Set;
67 //import java.util.concurrent.ConcurrentHashMap;
69 //import org.junit.Before;
70 //import org.junit.Test;
72 //import org.slf4j.Logger;
73 //import org.slf4j.LoggerFactory;
75 //public class DeviceManagerImplTest {
77 // protected static Logger logger =
78 // LoggerFactory.getLogger(DeviceManagerImplTest.class);
80 // protected OFPacketIn packetIn_1, packetIn_2, packetIn_3;
81 // protected IPacket testARPReplyPacket_1, testARPReplyPacket_2,
82 // testARPReplyPacket_3;
83 // protected IPacket testARPReqPacket_1, testARPReqPacket_2;
84 // protected byte[] testARPReplyPacket_1_Srld, testARPReplyPacket_2_Srld;
85 // private MockSyncService syncService;
86 // private IStoreClient<String, DeviceSyncRepresentation> storeClient;
88 // DeviceManagerImpl deviceManager;
89 // MemoryStorageSource storageSource;
90 // FlowReconcileManager flowReconcileMgr;
92 // private IOFSwitch makeSwitchMock(long id) {
93 // IOFSwitch mockSwitch = createMock(IOFSwitch.class);
94 // ImmutablePort port = ImmutablePort.create("p1", (short)1);
95 // expect(mockSwitch.getId()).andReturn(id).anyTimes();
96 // expect(mockSwitch.getStringId())
97 // .andReturn(HexString.toHexString(id, 6)).anyTimes();
98 // expect(mockSwitch.getPort(anyShort()))
99 // .andReturn(port).anyTimes();
100 // return mockSwitch;
104 // * return an EasyMock ITopologyService that's setup so that it will
105 // * answer all questions a device or device manager will ask
106 // * (isAttachmentPointPort, etc.) in a way so that every port is a
107 // * non-BD, attachment point port.
108 // * The returned mock is still in record mode
110 // private ITopologyService makeMockTopologyAllPortsAp() {
111 // ITopologyService mockTopology = createMock(ITopologyService.class);
112 // mockTopology.isAttachmentPointPort(anyLong(), anyShort());
113 // expectLastCall().andReturn(true).anyTimes();
114 // mockTopology.getL2DomainId(anyLong());
115 // expectLastCall().andReturn(1L).anyTimes();
116 // mockTopology.isBroadcastDomainPort(anyLong(), anyShort());
117 // expectLastCall().andReturn(false).anyTimes();
118 // mockTopology.isConsistent(anyLong(), anyShort(), anyLong(), anyShort());
119 // expectLastCall().andReturn(false).anyTimes();
120 // mockTopology.isInSameBroadcastDomain(anyLong(), anyShort(),
121 // anyLong(), anyShort());
122 // expectLastCall().andReturn(false).anyTimes();
123 // return mockTopology;
128 // public void setUp() throws Exception {
129 // doSetUp(Role.MASTER);
132 // public void doSetUp(Role initialRole) throws Exception {
135 // this.syncService = new MockSyncService();
137 // FloodlightModuleContext fmc = new FloodlightModuleContext();
138 // RestApiServer restApi = new RestApiServer();
139 // MockThreadPoolService tp = new MockThreadPoolService();
140 // ITopologyService topology = createMock(ITopologyService.class);
141 // fmc.addService(IThreadPoolService.class, tp);
142 // mockFloodlightProvider = getMockFloodlightProvider();
143 // mockFloodlightProvider.setRole(initialRole, "");
145 // deviceManager = new DeviceManagerImpl();
146 // flowReconcileMgr = new FlowReconcileManager();
147 // DefaultEntityClassifier entityClassifier = new DefaultEntityClassifier();
148 // fmc.addService(IDeviceService.class, deviceManager);
149 // storageSource = new MemoryStorageSource();
150 // fmc.addService(IStorageSourceService.class, storageSource);
151 // fmc.addService(IFloodlightProviderService.class, mockFloodlightProvider);
152 // fmc.addService(IRestApiService.class, restApi);
153 // fmc.addService(IFlowReconcileService.class, flowReconcileMgr);
154 // fmc.addService(IEntityClassifierService.class, entityClassifier);
155 // fmc.addService(ITopologyService.class, topology);
156 // fmc.addService(ISyncService.class, syncService);
158 // restApi.init(fmc);
159 // storageSource.init(fmc);
160 // deviceManager.init(fmc);
161 // flowReconcileMgr.init(fmc);
162 // entityClassifier.init(fmc);
163 // syncService.init(fmc);
164 // storageSource.startUp(fmc);
165 // deviceManager.startUp(fmc);
166 // flowReconcileMgr.startUp(fmc);
168 // entityClassifier.startUp(fmc);
169 // syncService.startUp(fmc);
171 // this.storeClient =
172 // this.syncService.getStoreClient(DeviceManagerImpl.DEVICE_SYNC_STORE_NAME,
173 // String.class, DeviceSyncRepresentation.class);
176 // topology.addListener(deviceManager);
177 // expectLastCall().anyTimes();
180 // IOFSwitch mockSwitch1 = makeSwitchMock(1L);
181 // IOFSwitch mockSwitch10 = makeSwitchMock(10L);
182 // IOFSwitch mockSwitch5 = makeSwitchMock(5L);
183 // IOFSwitch mockSwitch50 = makeSwitchMock(50L);
184 // Map<Long, IOFSwitch> switches = new HashMap<Long,IOFSwitch>();
185 // switches.put(1L, mockSwitch1);
186 // switches.put(10L, mockSwitch10);
187 // switches.put(5L, mockSwitch5);
188 // switches.put(50L, mockSwitch50);
189 // mockFloodlightProvider.setSwitches(switches);
191 // replay(mockSwitch1, mockSwitch5, mockSwitch10, mockSwitch50);
193 // // Build our test packet
194 // this.testARPReplyPacket_1 = new Ethernet()
195 // .setSourceMACAddress("00:44:33:22:11:01")
196 // .setDestinationMACAddress("00:11:22:33:44:55")
197 // .setEtherType(Ethernet.TYPE_ARP)
198 // .setVlanID((short)5)
201 // .setHardwareType(ARP.HW_TYPE_ETHERNET)
202 // .setProtocolType(ARP.PROTO_TYPE_IP)
203 // .setHardwareAddressLength((byte) 6)
204 // .setProtocolAddressLength((byte) 4)
205 // .setOpCode(ARP.OP_REPLY)
206 // .setSenderHardwareAddress(Ethernet.toMACAddress("00:44:33:22:11:01"))
207 // .setSenderProtocolAddress(IPv4.toIPv4AddressBytes("192.168.1.1"))
208 // .setTargetHardwareAddress(Ethernet.toMACAddress("00:11:22:33:44:55"))
209 // .setTargetProtocolAddress(IPv4.toIPv4AddressBytes("192.168.1.2")));
210 // this.testARPReplyPacket_1_Srld = testARPReplyPacket_1.serialize();
212 // // Another test packet with a different source IP
213 // this.testARPReplyPacket_2 = new Ethernet()
214 // .setSourceMACAddress("00:99:88:77:66:55")
215 // .setDestinationMACAddress("00:11:22:33:44:55")
216 // .setEtherType(Ethernet.TYPE_ARP)
217 // .setVlanID((short)5)
220 // .setHardwareType(ARP.HW_TYPE_ETHERNET)
221 // .setProtocolType(ARP.PROTO_TYPE_IP)
222 // .setHardwareAddressLength((byte) 6)
223 // .setProtocolAddressLength((byte) 4)
224 // .setOpCode(ARP.OP_REPLY)
225 // .setSenderHardwareAddress(Ethernet.toMACAddress("00:44:33:22:11:01"))
226 // .setSenderProtocolAddress(IPv4.toIPv4AddressBytes("192.168.1.1"))
227 // .setTargetHardwareAddress(Ethernet.toMACAddress("00:11:22:33:44:55"))
228 // .setTargetProtocolAddress(IPv4.toIPv4AddressBytes("192.168.1.2")));
229 // this.testARPReplyPacket_2_Srld = testARPReplyPacket_2.serialize();
231 // // Build the PacketIn
232 // this.packetIn_1 = ((OFPacketIn) mockFloodlightProvider.
233 // getOFMessageFactory().getMessage(OFType.PACKET_IN))
235 // .setInPort((short) 1)
236 // .setPacketData(this.testARPReplyPacket_1_Srld)
237 // .setReason(OFPacketInReason.NO_MATCH)
238 // .setTotalLength((short) this.testARPReplyPacket_1_Srld.length);
240 // // Build the PacketIn
241 // this.packetIn_2 = ((OFPacketIn) mockFloodlightProvider.
242 // getOFMessageFactory().getMessage(OFType.PACKET_IN))
244 // .setInPort((short) 1)
245 // .setPacketData(this.testARPReplyPacket_2_Srld)
246 // .setReason(OFPacketInReason.NO_MATCH)
247 // .setTotalLength((short) this.testARPReplyPacket_2_Srld.length);
255 // public void testLastSeen() throws Exception {
256 // Calendar c = Calendar.getInstance();
257 // Date d1 = c.getTime();
258 // Entity entity1 = new Entity(1L, null, null, null, null, d1);
259 // c.add(Calendar.SECOND, 1);
260 // Entity entity2 = new Entity(1L, null, 1, null, null, c.getTime());
262 // IDevice d = deviceManager.learnDeviceByEntity(entity2);
263 // assertEquals(c.getTime(), d.getLastSeen());
264 // d = deviceManager.learnDeviceByEntity(entity1);
265 // assertEquals(c.getTime(), d.getLastSeen());
267 // deviceManager.startUp(null);
268 // d = deviceManager.learnDeviceByEntity(entity1);
269 // assertEquals(d1, d.getLastSeen());
270 // d = deviceManager.learnDeviceByEntity(entity2);
271 // assertEquals(c.getTime(), d.getLastSeen());
275 // public void testEntityLearning() throws Exception {
276 // IDeviceListener mockListener =
277 // createMock(IDeviceListener.class);
278 // expect(mockListener.getName()).andReturn("mockListener").atLeastOnce();
279 // expect(mockListener.isCallbackOrderingPostreq((String)anyObject(), (String)anyObject()))
280 // .andReturn(false).atLeastOnce();
281 // expect(mockListener.isCallbackOrderingPrereq((String)anyObject(), (String)anyObject()))
282 // .andReturn(false).atLeastOnce();
284 // replay(mockListener);
285 // deviceManager.addListener(mockListener);
286 // verify(mockListener);
287 // reset(mockListener);
288 // deviceManager.entityClassifier= new MockEntityClassifier();
289 // deviceManager.startUp(null);
291 // ITopologyService mockTopology = createMock(ITopologyService.class);
292 // expect(mockTopology.getL2DomainId(anyLong())).
293 // andReturn(1L).anyTimes();
294 // expect(mockTopology.isBroadcastDomainPort(anyLong(), anyShort())).
295 // andReturn(false).anyTimes();
297 // expect(mockTopology.isAttachmentPointPort(anyLong(),
298 // anyShort())).andReturn(true).anyTimes();
299 // expect(mockTopology.isConsistent(10L, (short)1, 10L, (short)1)).
300 // andReturn(true).anyTimes();
301 // expect(mockTopology.isConsistent(1L, (short)1, 1L, (short)1)).
302 // andReturn(true).anyTimes();
303 // expect(mockTopology.isConsistent(50L, (short)3, 50L, (short)3)).
304 // andReturn(true).anyTimes();
306 // Date topologyUpdateTime = new Date();
307 // expect(mockTopology.getLastUpdateTime()).andReturn(topologyUpdateTime).
310 // deviceManager.topology = mockTopology;
312 // Entity entity1 = new Entity(1L, null, null, 1L, 1, new Date());
313 // Entity entity2 = new Entity(1L, null, null, 10L, 1, new Date());
314 // Entity entity3 = new Entity(1L, null, 1, 10L, 1, new Date());
315 // Entity entity4 = new Entity(1L, null, 1, 1L, 1, new Date());
316 // Entity entity5 = new Entity(2L, (short)4, 1, 5L, 2, new Date());
317 // Entity entity6 = new Entity(2L, (short)4, 1, 50L, 3, new Date());
318 // Entity entity7 = new Entity(2L, (short)4, 2, 50L, 3, new Date());
320 // mockListener.deviceAdded(isA(IDevice.class));
321 // replay(mockListener, mockTopology);
323 // Device d1 = deviceManager.learnDeviceByEntity(entity1);
324 // assertSame(d1, deviceManager.learnDeviceByEntity(entity1));
325 // assertSame(d1, deviceManager.findDeviceByEntity(entity1));
326 // assertEquals(DefaultEntityClassifier.entityClass ,
327 // d1.getEntityClass());
328 // assertArrayEquals(new Short[] { -1 }, d1.getVlanId());
329 // assertArrayEquals(new Integer[] { }, d1.getIPv4Addresses());
331 // assertEquals(1, deviceManager.getAllDevices().size());
332 // verify(mockListener);
334 // reset(mockListener);
335 // mockListener.deviceAdded(isA(IDevice.class));
336 // replay(mockListener);
338 // Device d2 = deviceManager.learnDeviceByEntity(entity2);
339 // assertFalse(d1.equals(d2));
340 // assertNotSame(d1, d2);
341 // assertNotSame(d1.getDeviceKey(), d2.getDeviceKey());
342 // assertEquals(MockEntityClassifier.testEC, d2.getEntityClass());
343 // assertArrayEquals(new Short[] { -1 }, d2.getVlanId());
344 // assertArrayEquals(new Integer[] { }, d2.getIPv4Addresses());
346 // assertEquals(2, deviceManager.getAllDevices().size());
347 // verify(mockListener);
349 // reset(mockListener);
350 // mockListener.deviceIPV4AddrChanged(isA(IDevice.class));
351 // replay(mockListener);
353 // Device d3 = deviceManager.learnDeviceByEntity(entity3);
354 // assertNotSame(d2, d3);
355 // assertEquals(d2.getDeviceKey(), d3.getDeviceKey());
356 // assertEquals(MockEntityClassifier.testEC, d3.getEntityClass());
357 // assertArrayEquals(new Integer[] { 1 },
358 // d3.getIPv4Addresses());
359 // assertArrayEquals(new SwitchPort[] { new SwitchPort(10L, 1) },
360 // d3.getAttachmentPoints());
361 // assertArrayEquals(new SwitchPort[] { new SwitchPort(10L, 1) },
362 // d3.getAttachmentPoints(true));
363 // assertArrayEquals(new Short[] { -1 },
366 // assertEquals(2, deviceManager.getAllDevices().size());
367 // verify(mockListener);
369 // reset(mockListener);
370 // mockListener.deviceIPV4AddrChanged(isA(IDevice.class));
371 // replay(mockListener);
373 // Device d4 = deviceManager.learnDeviceByEntity(entity4);
374 // assertNotSame(d1, d4);
375 // assertEquals(d1.getDeviceKey(), d4.getDeviceKey());
376 // assertEquals(DefaultEntityClassifier.entityClass, d4.getEntityClass());
377 // assertArrayEquals(new Integer[] { 1 },
378 // d4.getIPv4Addresses());
379 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1) },
380 // d4.getAttachmentPoints());
381 // assertArrayEquals(new Short[] { -1 },
384 // assertEquals(2, deviceManager.getAllDevices().size());
385 // verify(mockListener);
387 // reset(mockListener);
388 // mockListener.deviceAdded((isA(IDevice.class)));
389 // replay(mockListener);
391 // Device d5 = deviceManager.learnDeviceByEntity(entity5);
392 // assertArrayEquals(new SwitchPort[] { new SwitchPort(5L, 2) },
393 // d5.getAttachmentPoints());
394 // assertArrayEquals(new Short[] { (short) 4 },
396 // assertEquals(2L, d5.getMACAddress());
397 // assertEquals("00:00:00:00:00:02", d5.getMACAddressString());
398 // verify(mockListener);
400 // reset(mockListener);
401 // mockListener.deviceAdded(isA(IDevice.class));
402 // replay(mockListener);
404 // Device d6 = deviceManager.learnDeviceByEntity(entity6);
405 // assertArrayEquals(new SwitchPort[] { new SwitchPort(50L, 3) },
406 // d6.getAttachmentPoints());
407 // assertArrayEquals(new Short[] { (short) 4 },
410 // assertEquals(4, deviceManager.getAllDevices().size());
411 // verify(mockListener);
413 // reset(mockListener);
414 // mockListener.deviceIPV4AddrChanged(isA(IDevice.class));
415 // replay(mockListener);
417 // Device d7 = deviceManager.learnDeviceByEntity(entity7);
418 // assertNotSame(d6, d7);
419 // assertEquals(d6.getDeviceKey(), d7.getDeviceKey());
420 // assertArrayEquals(new SwitchPort[] { new SwitchPort(50L, 3) },
421 // d7.getAttachmentPoints());
422 // assertArrayEquals(new Short[] { (short) 4 },
425 // assertEquals(4, deviceManager.getAllDevices().size());
426 // verify(mockListener);
429 // reset(mockListener);
430 // replay(mockListener);
432 // reset(deviceManager.topology);
433 // deviceManager.topology.addListener(deviceManager);
434 // expectLastCall().times(1);
435 // replay(deviceManager.topology);
437 // deviceManager.entityClassifier = new MockEntityClassifierMac();
438 // deviceManager.startUp(null);
439 // Entity entityNoClass = new Entity(5L, (short)1, 5, -1L, 1, new Date());
440 // assertEquals(null, deviceManager.learnDeviceByEntity(entityNoClass));
442 // verify(mockListener);
446 // private void doTestEntityOrdering(boolean computeInsertionPoint) throws Exception {
447 // Entity e = new Entity(10L, null, null, null, null, null);
448 // IEntityClass ec = createNiceMock(IEntityClass.class);
449 // Device d = new Device(deviceManager, 1L, e, ec);
451 // int expectedLength = 1;
452 // Long[] macs = new Long[] { 5L, // new first element
453 // 15L, // new last element
454 // 7L, // insert in middle
455 // 12L, // insert in middle
456 // 6L, // insert at idx 1
457 // 14L, // insert at idx length-2
462 // for (Long mac: macs) {
463 // e = new Entity(mac, null, null, null, null, null);
464 // int insertionPoint;
465 // if (computeInsertionPoint) {
466 // insertionPoint = -(Arrays.binarySearch(d.entities, e)+1);
468 // insertionPoint = -1;
470 // d = deviceManager.allocateDevice(d, e, insertionPoint);
472 // assertEquals(expectedLength, d.entities.length);
473 // for (int i = 0; i < d.entities.length-1; i++)
474 // assertEquals(-1, d.entities[i].compareTo(d.entities[i+1]));
479 // public void testEntityOrderingExternal() throws Exception {
480 // doTestEntityOrdering(true);
484 // public void testEntityOrderingInternal() throws Exception {
485 // doTestEntityOrdering(false);
489 // public void testAttachmentPointLearning() throws Exception {
490 // IDeviceListener mockListener =
491 // createMock(IDeviceListener.class);
492 // expect(mockListener.getName()).andReturn("mockListener").atLeastOnce();
493 // expect(mockListener.isCallbackOrderingPostreq((String)anyObject(), (String)anyObject()))
494 // .andReturn(false).atLeastOnce();
495 // expect(mockListener.isCallbackOrderingPrereq((String)anyObject(), (String)anyObject()))
496 // .andReturn(false).atLeastOnce();
498 // replay(mockListener);
499 // deviceManager.addListener(mockListener);
500 // verify(mockListener);
501 // reset(mockListener);
503 // ITopologyService mockTopology = createMock(ITopologyService.class);
504 // expect(mockTopology.getL2DomainId(1L)).
505 // andReturn(1L).anyTimes();
506 // expect(mockTopology.getL2DomainId(5L)).
507 // andReturn(1L).anyTimes();
508 // expect(mockTopology.getL2DomainId(10L)).
509 // andReturn(10L).anyTimes();
510 // expect(mockTopology.getL2DomainId(50L)).
511 // andReturn(10L).anyTimes();
512 // expect(mockTopology.isBroadcastDomainPort(anyLong(), anyShort())).
513 // andReturn(false).anyTimes();
514 // expect(mockTopology.isInSameBroadcastDomain(anyLong(), anyShort(),
515 // anyLong(), anyShort())).andReturn(false).anyTimes();
517 // expect(mockTopology.isAttachmentPointPort(anyLong(),
518 // anyShort())).andReturn(true).anyTimes();
519 // expect(mockTopology.isConsistent(1L, (short)1, 5L, (short)1)).
520 // andReturn(false).anyTimes();
521 // expect(mockTopology.isConsistent(5L, (short)1, 10L, (short)1)).
522 // andReturn(false).anyTimes();
523 // expect(mockTopology.isConsistent(10L, (short)1, 50L, (short)1)).
524 // andReturn(false).anyTimes();
526 // Date topologyUpdateTime = new Date();
527 // expect(mockTopology.getLastUpdateTime()).andReturn(topologyUpdateTime).
530 // replay(mockTopology);
532 // deviceManager.topology = mockTopology;
534 // Calendar c = Calendar.getInstance();
535 // Entity entity1 = new Entity(1L, null, 1, 1L, 1, c.getTime());
536 // Entity entity0 = new Entity(1L, null, null, null, null, c.getTime());
537 // c.add(Calendar.SECOND, 1);
538 // Entity entity2 = new Entity(1L, null, null, 5L, 1, c.getTime());
539 // c.add(Calendar.SECOND, 1);
540 // Entity entity3 = new Entity(1L, null, null, 10L, 1, c.getTime());
541 // c.add(Calendar.SECOND, 1);
542 // Entity entity4 = new Entity(1L, null, null, 50L, 1, c.getTime());
548 // mockListener.deviceAdded(isA(IDevice.class));
549 // replay(mockListener);
551 // deviceManager.learnDeviceByEntity(entity1);
552 // d = deviceManager.learnDeviceByEntity(entity0);
553 // assertEquals(1, deviceManager.getAllDevices().size());
554 // aps = d.getAttachmentPoints();
555 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1) }, aps);
556 // ips = d.getIPv4Addresses();
557 // assertArrayEquals(new Integer[] { 1 }, ips);
558 // verify(mockListener);
560 // reset(mockListener);
561 // mockListener.deviceMoved((isA(IDevice.class)));
562 // replay(mockListener);
564 // d = deviceManager.learnDeviceByEntity(entity2);
565 // assertEquals(1, deviceManager.getAllDevices().size());
566 // aps = d.getAttachmentPoints();
568 // assertArrayEquals(new SwitchPort[] { new SwitchPort(5L, 1) }, aps);
569 // ips = d.getIPv4Addresses();
570 // assertArrayEquals(new Integer[] { 1 }, ips);
571 // verify(mockListener);
573 // reset(mockListener);
574 // mockListener.deviceMoved((isA(IDevice.class)));
575 // replay(mockListener);
577 // d = deviceManager.learnDeviceByEntity(entity3);
578 // assertEquals(1, deviceManager.getAllDevices().size());
579 // aps = d.getAttachmentPoints();
580 // assertArrayEquals(new SwitchPort[] {new SwitchPort(5L, 1), new SwitchPort(10L, 1)}, aps);
581 // ips = d.getIPv4Addresses();
582 // assertArrayEquals(new Integer[] { 1 }, ips);
583 // verify(mockListener);
585 // reset(mockListener);
586 // mockListener.deviceMoved((isA(IDevice.class)));
587 // replay(mockListener);
589 // d = deviceManager.learnDeviceByEntity(entity4);
590 // assertEquals(1, deviceManager.getAllDevices().size());
591 // aps = d.getAttachmentPoints();
592 // assertArrayEquals(new SwitchPort[] { new SwitchPort(5L, 1),
593 // new SwitchPort(50L, 1) }, aps);
594 // ips = d.getIPv4Addresses();
595 // assertArrayEquals(new Integer[] { 1 }, ips);
596 // verify(mockListener);
599 // private void verifyEntityArray(Entity[] expected, Device d) {
600 // Arrays.sort(expected);
601 // assertArrayEquals(expected, d.entities);
605 // public void testNoLearningOnInternalPorts() throws Exception {
606 // IDeviceListener mockListener =
607 // createMock(IDeviceListener.class);
609 // expect(mockListener.getName()).andReturn("mockListener").anyTimes();
610 // expect(mockListener.isCallbackOrderingPostreq((String)anyObject(), (String)anyObject()))
611 // .andReturn(false).atLeastOnce();
612 // expect(mockListener.isCallbackOrderingPrereq((String)anyObject(), (String)anyObject()))
613 // .andReturn(false).atLeastOnce();
615 // replay(mockListener);
616 // deviceManager.addListener(mockListener);
617 // verify(mockListener);
618 // reset(mockListener);
620 // ITopologyService mockTopology = createMock(ITopologyService.class);
621 // expect(mockTopology.getL2DomainId(1L)).
622 // andReturn(1L).anyTimes();
623 // expect(mockTopology.getL2DomainId(2L)).
624 // andReturn(1L).anyTimes();
625 // expect(mockTopology.getL2DomainId(3L)).
626 // andReturn(1L).anyTimes();
627 // expect(mockTopology.getL2DomainId(4L)).
628 // andReturn(1L).anyTimes();
629 // expect(mockTopology.isBroadcastDomainPort(anyLong(), anyShort()))
630 // .andReturn(false).anyTimes();
631 // expect(mockTopology.isInSameBroadcastDomain(anyLong(), anyShort(),
632 // anyLong(), anyShort()))
633 // .andReturn(false).anyTimes();
635 // expect(mockTopology.isAttachmentPointPort(or(eq(1L), eq(3L)), anyShort()))
636 // .andReturn(true).anyTimes();
637 // // Switches 2 and 4 have only internal ports
638 // expect(mockTopology.isAttachmentPointPort(or(eq(2L), eq(4L)), anyShort()))
639 // .andReturn(false).anyTimes();
641 // expect(mockTopology.isConsistent(1L, (short)1, 3L, (short)1))
642 // .andReturn(false).once();
644 // Date topologyUpdateTime = new Date();
645 // expect(mockTopology.getLastUpdateTime()).andReturn(topologyUpdateTime).
648 // replay(mockTopology);
650 // deviceManager.topology = mockTopology;
652 // Calendar c = Calendar.getInstance();
653 // Entity entity1 = new Entity(1L, null, 1, 1L, 1, c.getTime());
654 // c.add(Calendar.SECOND, 1);
655 // Entity entity2 = new Entity(1L, null, 2, 2L, 1, c.getTime());
656 // c.add(Calendar.SECOND, 1);
657 // Entity entity3 = new Entity(1L, null, 3, 3L, 1, c.getTime());
658 // c.add(Calendar.SECOND, 1);
659 // Entity entity4 = new Entity(1L, null, 4, 4L, 1, c.getTime());
665 // mockListener.deviceAdded(isA(IDevice.class));
666 // expectLastCall().once();
667 // replay(mockListener);
669 // // cannot learn device internal ports
670 // d = deviceManager.learnDeviceByEntity(entity2);
672 // d = deviceManager.learnDeviceByEntity(entity4);
675 // d = deviceManager.learnDeviceByEntity(entity1);
676 // assertEquals(1, deviceManager.getAllDevices().size());
677 // aps = d.getAttachmentPoints();
678 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1) }, aps);
679 // verifyEntityArray(new Entity[] { entity1 } , (Device)d);
680 // ips = d.getIPv4Addresses();
681 // assertArrayEquals(new Integer[] { 1 }, ips);
682 // verify(mockListener);
684 // reset(mockListener);
685 // replay(mockListener);
688 // d = deviceManager.learnDeviceByEntity(entity2);
689 // assertEquals(1, deviceManager.getAllDevices().size());
690 // aps = d.getAttachmentPoints();
691 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1) }, aps);
692 // verifyEntityArray(new Entity[] { entity1 } , (Device)d);
693 // ips = d.getIPv4Addresses();
694 // assertArrayEquals(new Integer[] { 1 }, ips);
695 // verify(mockListener);
697 // reset(mockListener);
698 // mockListener.deviceMoved(isA(IDevice.class));
699 // mockListener.deviceIPV4AddrChanged(isA(IDevice.class));
700 // replay(mockListener);
703 // d = deviceManager.learnDeviceByEntity(entity3);
704 // assertEquals(1, deviceManager.getAllDevices().size());
705 // aps = d.getAttachmentPoints();
706 // assertArrayEquals(new SwitchPort[] { new SwitchPort(3L, 1) }, aps);
707 // verifyEntityArray(new Entity[] { entity1, entity3 } , (Device)d);
708 // ips = d.getIPv4Addresses();
710 // assertArrayEquals(new Integer[] { 1, 3 }, ips);
711 // verify(mockListener);
713 // reset(mockListener);
714 // replay(mockListener);
717 // d = deviceManager.learnDeviceByEntity(entity4);
718 // assertEquals(1, deviceManager.getAllDevices().size());
719 // aps = d.getAttachmentPoints();
720 // assertArrayEquals(new SwitchPort[] { new SwitchPort(3L, 1) }, aps);
721 // verifyEntityArray(new Entity[] { entity1, entity3 } , (Device)d);
722 // ips = d.getIPv4Addresses();
724 // assertArrayEquals(new Integer[] { 1, 3 }, ips);
725 // verify(mockListener);
729 // public void testAttachmentPointSuppression() throws Exception {
730 // IDeviceListener mockListener =
731 // createMock(IDeviceListener.class);
733 // expect(mockListener.getName()).andReturn("mockListener").anyTimes();
734 // expect(mockListener.isCallbackOrderingPostreq((String)anyObject(), (String)anyObject()))
735 // .andReturn(false).atLeastOnce();
736 // expect(mockListener.isCallbackOrderingPrereq((String)anyObject(), (String)anyObject()))
737 // .andReturn(false).atLeastOnce();
739 // replay(mockListener);
740 // deviceManager.addListener(mockListener);
741 // verify(mockListener);
742 // reset(mockListener);
744 // ITopologyService mockTopology = createMock(ITopologyService.class);
745 // expect(mockTopology.getL2DomainId(1L)).
746 // andReturn(1L).anyTimes();
747 // expect(mockTopology.getL2DomainId(5L)).
748 // andReturn(1L).anyTimes();
749 // expect(mockTopology.getL2DomainId(10L)).
750 // andReturn(10L).anyTimes();
751 // expect(mockTopology.getL2DomainId(50L)).
752 // andReturn(10L).anyTimes();
753 // expect(mockTopology.isBroadcastDomainPort(anyLong(), anyShort()))
754 // .andReturn(false).anyTimes();
755 // expect(mockTopology.isInSameBroadcastDomain(anyLong(), anyShort(),
756 // anyLong(), anyShort()))
757 // .andReturn(false).anyTimes();
759 // expect(mockTopology.isAttachmentPointPort(anyLong(), anyShort()))
760 // .andReturn(true).anyTimes();
761 // expect(mockTopology.isConsistent(5L, (short)1, 50L, (short)1))
762 // .andReturn(false).anyTimes();
764 // Date topologyUpdateTime = new Date();
765 // expect(mockTopology.getLastUpdateTime()).andReturn(topologyUpdateTime).
768 // replay(mockTopology);
770 // deviceManager.topology = mockTopology;
771 // // suppress (1L, 1) and (10L, 1)
772 // deviceManager.addSuppressAPs(1L, (short)1);
773 // deviceManager.addSuppressAPs(10L, (short)1);
775 // Calendar c = Calendar.getInstance();
776 // Entity entity0 = new Entity(1L, null, null, null, null, c.getTime());
777 // // No attachment point should be learnt on 1L, 1
778 // Entity entity1 = new Entity(1L, null, 1, 1L, 1, c.getTime());
779 // c.add(Calendar.SECOND, 1);
780 // Entity entity2 = new Entity(1L, null, 1, 5L, 1, c.getTime());
781 // c.add(Calendar.SECOND, 1);
782 // Entity entity3 = new Entity(1L, null, null, 10L, 1, c.getTime());
783 // c.add(Calendar.SECOND, 1);
784 // Entity entity4 = new Entity(1L, null, null, 50L, 1, c.getTime());
790 // mockListener.deviceAdded(isA(IDevice.class));
791 // mockListener.deviceIPV4AddrChanged((isA(IDevice.class)));
792 // replay(mockListener);
794 // // TODO: we currently do learn entities on suppressed APs
795 // // // cannot learn device on suppressed AP
796 // // d = deviceManager.learnDeviceByEntity(entity1);
799 // deviceManager.learnDeviceByEntity(entity0);
800 // d = deviceManager.learnDeviceByEntity(entity1);
801 // assertEquals(1, deviceManager.getAllDevices().size());
802 // aps = d.getAttachmentPoints();
803 // assertEquals(aps.length, 0);
804 // verifyEntityArray(new Entity[] { entity0, entity1} , (Device)d);
805 // ips = d.getIPv4Addresses();
806 // assertArrayEquals(new Integer[] { 1 }, ips);
807 // verify(mockListener);
809 // reset(mockListener);
810 // mockListener.deviceMoved((isA(IDevice.class)));
811 // //mockListener.deviceIPV4AddrChanged((isA(IDevice.class)));
812 // replay(mockListener);
813 // d = deviceManager.learnDeviceByEntity(entity2);
814 // assertEquals(1, deviceManager.getAllDevices().size());
815 // aps = d.getAttachmentPoints();
816 // assertArrayEquals(new SwitchPort[] { new SwitchPort(5L, 1) }, aps);
817 // verifyEntityArray(new Entity[] { entity0, entity1, entity2 } , (Device)d);
818 // ips = d.getIPv4Addresses();
819 // assertArrayEquals(new Integer[] { 1 }, ips);
820 // verify(mockListener);
822 // reset(mockListener);
823 // replay(mockListener);
825 // d = deviceManager.learnDeviceByEntity(entity3);
826 // assertEquals(1, deviceManager.getAllDevices().size());
827 // aps = d.getAttachmentPoints();
828 // assertArrayEquals(new SwitchPort[] { new SwitchPort(5L, 1) }, aps);
829 // verifyEntityArray(new Entity[] { entity0, entity1, entity2, entity3 } , (Device)d);
830 // ips = d.getIPv4Addresses();
831 // assertArrayEquals(new Integer[] { 1 }, ips);
832 // verify(mockListener);
834 // reset(mockListener);
835 // mockListener.deviceMoved((isA(IDevice.class)));
836 // replay(mockListener);
838 // d = deviceManager.learnDeviceByEntity(entity4);
839 // assertEquals(1, deviceManager.getAllDevices().size());
840 // aps = d.getAttachmentPoints();
841 // assertArrayEquals(new SwitchPort[] { new SwitchPort(5L, 1),
842 // new SwitchPort(50L, 1) }, aps);
843 // verifyEntityArray(new Entity[] { entity0, entity1, entity2, entity3, entity4} , (Device)d);
844 // ips = d.getIPv4Addresses();
845 // assertArrayEquals(new Integer[] { 1 }, ips);
846 // verify(mockListener);
850 // public void testBDAttachmentPointLearning() throws Exception {
851 // ITopologyService mockTopology = createMock(ITopologyService.class);
852 // expect(mockTopology.getL2DomainId(anyLong())).
853 // andReturn(1L).anyTimes();
854 // expect(mockTopology.isAttachmentPointPort(anyLong(), anyShort())).
855 // andReturn(true).anyTimes();
856 // expect(mockTopology.isBroadcastDomainPort(1L, (short)1)).
857 // andReturn(false).anyTimes();
858 // expect(mockTopology.isBroadcastDomainPort(1L, (short)2)).
859 // andReturn(true).anyTimes();
860 // expect(mockTopology.isInSameBroadcastDomain(1L, (short)1,
861 // 1L, (short)2)).andReturn(true).anyTimes();
862 // expect(mockTopology.isInSameBroadcastDomain(1L, (short)2,
863 // 1L, (short)1)).andReturn(true).anyTimes();
864 // expect(mockTopology.isConsistent(anyLong(), anyShort(), anyLong(), anyShort())).andReturn(false).anyTimes();
866 // Date topologyUpdateTime = new Date();
867 // expect(mockTopology.getLastUpdateTime()).andReturn(topologyUpdateTime).
870 // replay(mockTopology);
872 // deviceManager.topology = mockTopology;
874 // Calendar c = Calendar.getInstance();
875 // Entity entity1 = new Entity(1L, null, 1, 1L, 1, c.getTime());
876 // c.add(Calendar.MILLISECOND,
877 // (int)AttachmentPoint.OPENFLOW_TO_EXTERNAL_TIMEOUT/ 2);
878 // Entity entity2 = new Entity(1L, null, null, 1L, 2, c.getTime());
879 // c.add(Calendar.MILLISECOND,
880 // (int)AttachmentPoint.OPENFLOW_TO_EXTERNAL_TIMEOUT / 2 + 1);
881 // Entity entity3 = new Entity(1L, null, null, 1L, 2, c.getTime());
886 // d = deviceManager.learnDeviceByEntity(entity1);
887 // assertEquals(1, deviceManager.getAllDevices().size());
888 // aps = d.getAttachmentPoints();
889 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1) }, aps);
891 // // this timestamp is too soon; don't switch
892 // d = deviceManager.learnDeviceByEntity(entity2);
893 // assertEquals(1, deviceManager.getAllDevices().size());
894 // aps = d.getAttachmentPoints();
895 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1) }, aps);
897 // // it should switch when we learn with a timestamp after the
899 // d = deviceManager.learnDeviceByEntity(entity3);
900 // assertEquals(1, deviceManager.getAllDevices().size());
901 // aps = d.getAttachmentPoints();
902 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 2) }, aps);
906 // * This test verifies that the learning behavior on OFPP_LOCAL ports.
907 // * Once a host is learned on OFPP_LOCAL, it is allowed to move only from
908 // * one OFPP_LOCAL to another OFPP_LOCAL port.
909 // * @throws Exception
912 // public void testLOCALAttachmentPointLearning() throws Exception {
913 // ITopologyService mockTopology = createMock(ITopologyService.class);
914 // expect(mockTopology.getL2DomainId(anyLong())).
915 // andReturn(1L).anyTimes();
916 // expect(mockTopology.isAttachmentPointPort(anyLong(), anyShort())).
917 // andReturn(true).anyTimes();
918 // expect(mockTopology.isBroadcastDomainPort(1L, (short)1)).
919 // andReturn(false).anyTimes();
920 // expect(mockTopology.isBroadcastDomainPort(1L, OFPort.OFPP_LOCAL.getValue())).
921 // andReturn(false).anyTimes();
922 // expect(mockTopology.isBroadcastDomainPort(1L, (short)2)).
923 // andReturn(true).anyTimes();
924 // expect(mockTopology.isInSameBroadcastDomain(1L, (short)1,
925 // 1L, OFPort.OFPP_LOCAL.getValue())).andReturn(true).anyTimes();
926 // expect(mockTopology.isInSameBroadcastDomain(1L, OFPort.OFPP_LOCAL.getValue(),
927 // 1L, (short)2)).andReturn(true).anyTimes();
928 // expect(mockTopology.isInSameBroadcastDomain(1L, (short)2,
929 // 1L, OFPort.OFPP_LOCAL.getValue())).andReturn(true).anyTimes();
930 // expect(mockTopology.isConsistent(anyLong(), anyShort(), anyLong(), anyShort())).andReturn(false).anyTimes();
932 // Date topologyUpdateTime = new Date();
933 // expect(mockTopology.getLastUpdateTime()).andReturn(topologyUpdateTime).
936 // replay(mockTopology);
938 // deviceManager.topology = mockTopology;
940 // Calendar c = Calendar.getInstance();
941 // Entity entity1 = new Entity(1L, null, 1, 1L, 1, c.getTime());
942 // c.add(Calendar.MILLISECOND,
943 // (int)AttachmentPoint.OPENFLOW_TO_EXTERNAL_TIMEOUT/ 2);
944 // Entity entity2 = new Entity(1L, null, null, 1L, (int)OFPort.OFPP_LOCAL.getValue(), c.getTime());
945 // c.add(Calendar.MILLISECOND,
946 // (int)AttachmentPoint.OPENFLOW_TO_EXTERNAL_TIMEOUT + 1);
947 // Entity entity3 = new Entity(1L, null, null, 1L, 2, c.getTime());
952 // d = deviceManager.learnDeviceByEntity(entity1);
953 // assertEquals(1, deviceManager.getAllDevices().size());
954 // aps = d.getAttachmentPoints();
955 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1) }, aps);
957 // // Ensure that the attachment point changes to OFPP_LOCAL
958 // d = deviceManager.learnDeviceByEntity(entity2);
959 // assertEquals(1, deviceManager.getAllDevices().size());
960 // aps = d.getAttachmentPoints();
961 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, OFPort.OFPP_LOCAL.getValue()) }, aps);
963 // // Even though the new attachment point is consistent with old
964 // // and the time has elapsed, OFPP_LOCAL attachment point should
966 // d = deviceManager.learnDeviceByEntity(entity3);
967 // assertEquals(1, deviceManager.getAllDevices().size());
968 // aps = d.getAttachmentPoints();
969 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, OFPort.OFPP_LOCAL.getValue()) }, aps);
973 // public void testPacketInBasic(byte[] deviceMac, OFPacketIn packetIn) {
974 // // Mock up our expected behavior
975 // ITopologyService mockTopology = createMock(ITopologyService.class);
976 // deviceManager.topology = mockTopology;
977 // expect(mockTopology.isAttachmentPointPort(EasyMock.anyLong(),
978 // EasyMock.anyShort())).
979 // andReturn(true).anyTimes();
980 // expect(mockTopology.isConsistent(EasyMock.anyLong(),
981 // EasyMock.anyShort(),
982 // EasyMock.anyLong(),
983 // EasyMock.anyShort())).andReturn(false).
985 // expect(mockTopology.getL2DomainId(EasyMock.anyLong())).andReturn(1L).anyTimes();
986 // replay(mockTopology);
988 // Date currentDate = new Date();
990 // // build our expected Device
991 // Integer ipaddr = IPv4.toIPv4Address("192.168.1.1");
993 // new Device(deviceManager,
994 // new Long(deviceManager.deviceKeyCounter),
995 // new Entity(Ethernet.toLong(deviceMac),
1001 // DefaultEntityClassifier.entityClass);
1003 // // Get the listener and trigger the packet in
1004 // IOFSwitch switch1 = mockFloodlightProvider.getSwitch(1L);
1005 // mockFloodlightProvider.dispatchMessage(switch1, packetIn);
1007 // // Verify the replay matched our expectations
1008 // // verify(mockTopology);
1010 // // Verify the device
1011 // Device rdevice = (Device)
1012 // deviceManager.findDevice(Ethernet.toLong(deviceMac),
1013 // (short)5, null, null, null);
1015 // assertEquals(device, rdevice);
1016 // assertEquals(new Short((short)5), rdevice.getVlanId()[0]);
1018 // Device result = null;
1019 // Iterator<? extends IDevice> dstiter =
1020 // deviceManager.queryClassDevices(device.getEntityClass(),
1021 // null, null, ipaddr,
1023 // if (dstiter.hasNext()) {
1024 // result = (Device)dstiter.next();
1027 // assertEquals(device, result);
1030 // new Device(device,
1031 // new Entity(Ethernet.toLong(deviceMac),
1039 // reset(mockTopology);
1040 // expect(mockTopology.isAttachmentPointPort(anyLong(),
1044 // expect(mockTopology.isConsistent(EasyMock.anyLong(),
1045 // EasyMock.anyShort(),
1046 // EasyMock.anyLong(),
1047 // EasyMock.anyShort())).andReturn(false).
1049 // expect(mockTopology.isBroadcastDomainPort(EasyMock.anyLong(),
1050 // EasyMock.anyShort()))
1051 // .andReturn(false)
1053 // expect(mockTopology.getL2DomainId(1L)).andReturn(1L).anyTimes();
1054 // expect(mockTopology.getL2DomainId(5L)).andReturn(1L).anyTimes();
1055 // expect(mockTopology.isInSameBroadcastDomain(1L, (short)1, 5L, (short)2)).
1056 // andReturn(false).anyTimes();
1058 // // Start recording the replay on the mocks
1059 // replay(mockTopology);
1060 // // Get the listener and trigger the packet in
1061 // IOFSwitch switch5 = mockFloodlightProvider.getSwitch(5L);
1062 // mockFloodlightProvider.
1063 // dispatchMessage(switch5, this.packetIn_1.setInPort((short)2));
1065 // // Verify the replay matched our expectations
1066 // verify(mockTopology);
1068 // // Verify the device
1069 // rdevice = (Device)
1070 // deviceManager.findDevice(Ethernet.toLong(deviceMac),
1071 // (short)5, null, null, null);
1072 // assertEquals(device, rdevice);
1076 // public void testPacketIn() throws Exception {
1077 // byte[] deviceMac1 =
1078 // ((Ethernet)this.testARPReplyPacket_1).getSourceMACAddress();
1079 // testPacketInBasic(deviceMac1, packetIn_1);
1083 // * This test ensures the device manager learns the source device
1084 // * corresponding to the senderHardwareAddress and senderProtocolAddress
1085 // * in an ARP response whenever the senderHardwareAddress is different
1086 // * from the source MAC address of the Ethernet frame.
1088 // * This test is the same as testPacketIn method, except for the
1089 // * packet-in that's used.
1090 // * @throws Exception
1093 // public void testDeviceLearningFromArpResponseData() throws Exception {
1094 // ARP arp = (ARP)((Ethernet)this.testARPReplyPacket_2).getPayload();
1095 // byte[] deviceMac2 = arp.getSenderHardwareAddress();
1097 // testPacketInBasic(deviceMac2, packetIn_2);
1101 // * Note: Entity expiration does not result in device moved notification.
1102 // * @throws Exception
1104 // public void doTestEntityExpiration() throws Exception {
1105 // IDeviceListener mockListener =
1106 // createMock(IDeviceListener.class);
1107 // expect(mockListener.getName()).andReturn("mockListener").anyTimes();
1108 // expect(mockListener.isCallbackOrderingPostreq((String)anyObject(), (String)anyObject()))
1109 // .andReturn(false).atLeastOnce();
1110 // expect(mockListener.isCallbackOrderingPrereq((String)anyObject(), (String)anyObject()))
1111 // .andReturn(false).atLeastOnce();
1113 // ITopologyService mockTopology = createMock(ITopologyService.class);
1114 // expect(mockTopology.isAttachmentPointPort(anyLong(),
1116 // andReturn(true).anyTimes();
1118 // expect(mockTopology.isBroadcastDomainPort(1L, (short)1)).andReturn(false).anyTimes();
1119 // expect(mockTopology.isBroadcastDomainPort(5L, (short)1)).andReturn(false).anyTimes();
1120 // expect(mockTopology.getL2DomainId(1L)).andReturn(1L).anyTimes();
1121 // expect(mockTopology.getL2DomainId(5L)).andReturn(5L).anyTimes();
1122 // expect(mockTopology.isConsistent(1L, (short)1, 5L, (short)1)).
1123 // andReturn(false).anyTimes();
1125 // Date topologyUpdateTime = new Date();
1126 // expect(mockTopology.getLastUpdateTime()).andReturn(topologyUpdateTime).
1129 // replay(mockTopology);
1130 // deviceManager.topology = mockTopology;
1132 // Calendar c = Calendar.getInstance();
1133 // Entity entity1 = new Entity(1L, null, 2, 1L, 1, c.getTime());
1134 // c.add(Calendar.MILLISECOND, -DeviceManagerImpl.ENTITY_TIMEOUT-1);
1135 // Entity entity2 = new Entity(1L, null, 1, 5L, 1, c.getTime());
1137 // deviceManager.learnDeviceByEntity(entity1);
1138 // IDevice d = deviceManager.learnDeviceByEntity(entity2);
1139 // assertArrayEquals(new Integer[] { 1, 2 }, d.getIPv4Addresses());
1140 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1),
1141 // new SwitchPort(5L, 1)},
1142 // d.getAttachmentPoints());
1143 // Iterator<? extends IDevice> diter =
1144 // deviceManager.queryClassDevices(d.getEntityClass(),
1145 // null, null, 1, null, null);
1146 // assertTrue(diter.hasNext());
1147 // assertEquals(d.getDeviceKey(), diter.next().getDeviceKey());
1148 // diter = deviceManager.queryClassDevices(d.getEntityClass(),
1149 // null, null, 2, null, null);
1150 // assertTrue(diter.hasNext());
1151 // assertEquals(d.getDeviceKey(), diter.next().getDeviceKey());
1153 // replay(mockListener);
1154 // deviceManager.addListener(mockListener);
1155 // verify(mockListener);
1156 // reset(mockListener);
1158 // mockListener.deviceIPV4AddrChanged(isA(IDevice.class));
1159 // replay(mockListener);
1160 // deviceManager.entityCleanupTask.reschedule(0, null);
1162 // d = deviceManager.getDevice(d.getDeviceKey());
1163 // assertArrayEquals(new Integer[] { 2 }, d.getIPv4Addresses());
1165 // // Attachment points are not removed, previous ones are still valid.
1166 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1),
1167 // new SwitchPort(5L, 1) },
1168 // d.getAttachmentPoints());
1169 // diter = deviceManager.queryClassDevices(d.getEntityClass(),
1170 // null, null, 2, null, null);
1171 // assertTrue(diter.hasNext());
1172 // assertEquals(d.getDeviceKey(), diter.next().getDeviceKey());
1173 // diter = deviceManager.queryClassDevices(d.getEntityClass(),
1174 // null, null, 1, null, null);
1175 // assertFalse(diter.hasNext());
1177 // d = deviceManager.findDevice(1L, null, null, null, null);
1178 // assertArrayEquals(new Integer[] { 2 }, d.getIPv4Addresses());
1180 // // Attachment points are not removed, previous ones are still valid.
1181 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1),
1182 // new SwitchPort(5L, 1) },
1183 // d.getAttachmentPoints());
1185 // verify(mockListener);
1188 // public void doTestDeviceExpiration() throws Exception {
1189 // IDeviceListener mockListener =
1190 // createMock(IDeviceListener.class);
1191 // expect(mockListener.getName()).andReturn("mockListener").anyTimes();
1192 // expect(mockListener.isCallbackOrderingPostreq((String)anyObject(), (String)anyObject()))
1193 // .andReturn(false).atLeastOnce();
1194 // expect(mockListener.isCallbackOrderingPrereq((String)anyObject(), (String)anyObject()))
1195 // .andReturn(false).atLeastOnce();
1197 // Calendar c = Calendar.getInstance();
1198 // c.add(Calendar.MILLISECOND, -DeviceManagerImpl.ENTITY_TIMEOUT-1);
1199 // Entity entity1 = new Entity(1L, null, 1, 1L, 1, c.getTime());
1200 // Entity entity2 = new Entity(1L, null, 2, 5L, 1, c.getTime());
1202 // ITopologyService mockTopology = createMock(ITopologyService.class);
1203 // deviceManager.topology = mockTopology;
1205 // expect(mockTopology.isAttachmentPointPort(EasyMock.anyLong(),
1206 // EasyMock.anyShort())).
1209 // expect(mockTopology.getL2DomainId(1L)).andReturn(1L).anyTimes();
1210 // expect(mockTopology.getL2DomainId(5L)).andReturn(1L).anyTimes();
1211 // expect(mockTopology.isConsistent(EasyMock.anyLong(),
1212 // EasyMock.anyShort(),
1213 // EasyMock.anyLong(),
1214 // EasyMock.anyShort())).andReturn(false).
1216 // expect(mockTopology.isBroadcastDomainPort(EasyMock.anyLong(),
1217 // EasyMock.anyShort())).
1218 // andReturn(false).anyTimes();
1219 // replay(mockTopology);
1221 // IDevice d = deviceManager.learnDeviceByEntity(entity2);
1222 // d = deviceManager.learnDeviceByEntity(entity1);
1223 // assertArrayEquals(new Integer[] { 1, 2 }, d.getIPv4Addresses());
1225 // replay(mockListener);
1226 // deviceManager.addListener(mockListener);
1227 // verify(mockListener);
1228 // reset(mockListener);
1230 // mockListener.deviceRemoved(isA(IDevice.class));
1231 // replay(mockListener);
1232 // deviceManager.entityCleanupTask.reschedule(0, null);
1234 // IDevice r = deviceManager.getDevice(d.getDeviceKey());
1236 // Iterator<? extends IDevice> diter =
1237 // deviceManager.queryClassDevices(d.getEntityClass(),
1238 // null, null, 1, null, null);
1239 // assertFalse(diter.hasNext());
1241 // r = deviceManager.findDevice(1L, null, null, null, null);
1244 // verify(mockListener);
1248 // * A ConcurrentHashMap for devices (deviceMap) that can be used to test
1249 // * code that specially handles concurrent modification situations. In
1250 // * particular, we overwrite values() and will replace / remove all the
1251 // * elements returned by values.
1253 // * The remove flag in the constructor specifies if devices returned by
1254 // * values() should be removed or replaced.
1256 // protected static class ConcurrentlyModifiedDeviceMap
1257 // extends ConcurrentHashMap<Long, Device> {
1258 // private static final long serialVersionUID = 7784938535441180562L;
1259 // protected boolean remove;
1260 // public ConcurrentlyModifiedDeviceMap(boolean remove) {
1262 // this.remove = remove;
1266 // public Collection<Device> values() {
1267 // // Get the values from the real map and copy them since
1268 // // the collection returned by values can reflect changed
1269 // Collection<Device> devs = new ArrayList<Device>(super.values());
1270 // for (Device d: devs) {
1272 // // We remove the device from the underlying map
1273 // super.remove(d.getDeviceKey());
1275 // super.remove(d.getDeviceKey());
1276 // // We add a different Device instance with the same
1277 // // key to the map. We'll do some hackery so the device
1278 // // is different enough to compare differently in equals
1279 // // but otherwise looks the same.
1280 // // It's ugly but it works.
1281 // // clone entities
1282 // Device newDevice = d;
1283 // for (Entity e: d.getEntities()) {
1284 // Entity newEntity = new Entity (e.macAddress,
1289 // e.lastSeenTimestamp);
1290 // if (e.vlan == null)
1291 // newEntity.vlan = (short)1;
1293 // newEntity.vlan = (short)((e.vlan + 1 % 4095)+1);
1294 // newDevice = new Device(newDevice, newEntity, -1);
1296 // assertEquals(false, newDevice.equals(d));
1297 // super.put(newDevice.getDeviceKey(), newDevice);
1305 // public void testEntityExpiration() throws Exception {
1306 // doTestEntityExpiration();
1310 // public void testDeviceExpiration() throws Exception {
1311 // doTestDeviceExpiration();
1314 // /* Test correct entity cleanup behavior when a concurrent modification
1318 // public void testEntityExpirationConcurrentModification() throws Exception {
1319 // deviceManager.deviceMap = new ConcurrentlyModifiedDeviceMap(false);
1320 // doTestEntityExpiration();
1323 // /* Test correct entity cleanup behavior when a concurrent remove
1327 // public void testDeviceExpirationConcurrentRemove() throws Exception {
1328 // deviceManager.deviceMap = new ConcurrentlyModifiedDeviceMap(true);
1329 // doTestDeviceExpiration();
1332 // /* Test correct entity cleanup behavior when a concurrent modification
1336 // public void testDeviceExpirationConcurrentModification() throws Exception {
1337 // deviceManager.deviceMap = new ConcurrentlyModifiedDeviceMap(false);
1338 // doTestDeviceExpiration();
1343 // public void testAttachmentPointFlapping() throws Exception {
1344 // Calendar c = Calendar.getInstance();
1346 // ITopologyService mockTopology = createMock(ITopologyService.class);
1347 // expect(mockTopology.isAttachmentPointPort(anyLong(),
1348 // anyShort())).andReturn(true).anyTimes();
1349 // expect(mockTopology.isBroadcastDomainPort(anyLong(),
1351 // andReturn(false).anyTimes();
1352 // expect(mockTopology.isInSameBroadcastDomain(anyLong(), anyShort(),
1353 // anyLong(), anyShort())).andReturn(false).anyTimes();
1354 // expect(mockTopology.getL2DomainId(anyLong())).
1355 // andReturn(1L).anyTimes();
1356 // expect(mockTopology.isConsistent(1L, (short)1, 1L, (short)1)).
1357 // andReturn(true).anyTimes();
1358 // expect(mockTopology.isConsistent(1L, (short)1, 5L, (short)1)).
1359 // andReturn(false).anyTimes();
1360 // expect(mockTopology.isConsistent(1L, (short)1, 10L, (short)1)).
1361 // andReturn(false).anyTimes();
1362 // expect(mockTopology.isConsistent(5L, (short)1, 10L, (short)1)).
1363 // andReturn(false).anyTimes();
1364 // expect(mockTopology.isConsistent(10L, (short)1, 1L, (short)1)).
1365 // andReturn(false).anyTimes();
1366 // expect(mockTopology.isConsistent(5L, (short)1, 1L, (short)1)).
1367 // andReturn(false).anyTimes();
1368 // expect(mockTopology.isConsistent(10L, (short)1, 5L, (short)1)).
1369 // andReturn(false).anyTimes();
1371 // Date topologyUpdateTime = new Date();
1372 // expect(mockTopology.getLastUpdateTime()).andReturn(topologyUpdateTime).
1376 // replay(mockTopology);
1377 // deviceManager.topology = mockTopology;
1379 // Entity entity1 = new Entity(1L, null, null, 1L, 1, c.getTime());
1380 // Entity entity1a = new Entity(1L, null, 1, 1L, 1, c.getTime());
1381 // Entity entity2 = new Entity(1L, null, null, 5L, 1, c.getTime());
1382 // Entity entity3 = new Entity(1L, null, null, 10L, 1, c.getTime());
1383 // entity1.setLastSeenTimestamp(c.getTime());
1384 // c.add(Calendar.MILLISECOND, Entity.ACTIVITY_TIMEOUT/2);
1385 // entity1a.setLastSeenTimestamp(c.getTime());
1386 // c.add(Calendar.MILLISECOND, 1);
1387 // entity2.setLastSeenTimestamp(c.getTime());
1388 // c.add(Calendar.MILLISECOND, 1);
1389 // entity3.setLastSeenTimestamp(c.getTime());
1394 // d = deviceManager.learnDeviceByEntity(entity1);
1395 // d = deviceManager.learnDeviceByEntity(entity1a);
1396 // d = deviceManager.learnDeviceByEntity(entity2);
1397 // d = deviceManager.learnDeviceByEntity(entity3);
1399 // // all entities are active, so entity3 should win
1400 // assertArrayEquals(new SwitchPort[] { new SwitchPort(10L, 1) },
1401 // d.getAttachmentPoints());
1403 // assertArrayEquals(new SwitchPort[] { new SwitchPort(10L, 1),},
1404 // d.getAttachmentPoints(true));
1406 // c.add(Calendar.MILLISECOND, Entity.ACTIVITY_TIMEOUT/4);
1407 // entity1.setLastSeenTimestamp(c.getTime());
1408 // d = deviceManager.learnDeviceByEntity(entity1);
1410 // // all are still active; entity3 should still win
1411 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1) },
1412 // d.getAttachmentPoints());
1413 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1),
1414 // new SwitchPort(5L, 1,
1415 // ErrorStatus.DUPLICATE_DEVICE),
1416 // new SwitchPort(10L, 1,
1417 // ErrorStatus.DUPLICATE_DEVICE) },
1418 // d.getAttachmentPoints(true));
1420 // c.add(Calendar.MILLISECOND, Entity.ACTIVITY_TIMEOUT+2000);
1421 // entity1.setLastSeenTimestamp(c.getTime());
1422 // d = deviceManager.learnDeviceByEntity(entity1);
1424 // assertEquals(entity1.getActiveSince(), entity1.getLastSeenTimestamp());
1425 // // entity1 should now be the only active entity
1426 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1) },
1427 // d.getAttachmentPoints());
1428 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1) },
1429 // d.getAttachmentPoints(true));
1434 // public void testAttachmentPointFlappingTwoCluster() throws Exception {
1435 // Calendar c = Calendar.getInstance();
1437 // ITopologyService mockTopology = createMock(ITopologyService.class);
1438 // expect(mockTopology.isAttachmentPointPort(anyLong(),
1439 // anyShort())).andReturn(true).anyTimes();
1440 // expect(mockTopology.isBroadcastDomainPort(anyLong(),
1442 // andReturn(false).anyTimes();
1443 // expect(mockTopology.isInSameBroadcastDomain(anyLong(), anyShort(),
1444 // anyLong(), anyShort())).andReturn(false).anyTimes();
1445 // expect(mockTopology.getL2DomainId(1L)).
1446 // andReturn(1L).anyTimes();
1447 // expect(mockTopology.getL2DomainId(5L)).
1448 // andReturn(5L).anyTimes();
1449 // expect(mockTopology.isConsistent(1L, (short)1, 1L, (short)2)).
1450 // andReturn(false).anyTimes();
1451 // expect(mockTopology.isConsistent(1L, (short)2, 5L, (short)1)).
1452 // andReturn(false).anyTimes();
1453 // expect(mockTopology.isConsistent(5L, (short)1, 5L, (short)2)).
1454 // andReturn(false).anyTimes();
1455 // expect(mockTopology.isConsistent(1L, (short)2, 1L, (short)1)).
1456 // andReturn(false).anyTimes();
1457 // expect(mockTopology.isConsistent(1L, (short)1, 5L, (short)1)).
1458 // andReturn(false).anyTimes();
1459 // expect(mockTopology.isConsistent(1L, (short)1, 5L, (short)2)).
1460 // andReturn(false).anyTimes();
1461 // expect(mockTopology.isConsistent(5L, (short)2, 5L, (short)1)).
1462 // andReturn(false).anyTimes();
1464 // Date topologyUpdateTime = new Date();
1465 // expect(mockTopology.getLastUpdateTime()).andReturn(topologyUpdateTime).
1468 // replay(mockTopology);
1469 // deviceManager.topology = mockTopology;
1471 // Entity entity1 = new Entity(1L, null, null, 1L, 1, c.getTime());
1472 // Entity entity2 = new Entity(1L, null, null, 1L, 2, c.getTime());
1473 // Entity entity3 = new Entity(1L, null, null, 5L, 1, c.getTime());
1474 // Entity entity4 = new Entity(1L, null, null, 5L, 2, c.getTime());
1475 // entity1.setLastSeenTimestamp(c.getTime());
1476 // c.add(Calendar.MILLISECOND, Entity.ACTIVITY_TIMEOUT/2);
1477 // c.add(Calendar.MILLISECOND, 1);
1478 // entity2.setLastSeenTimestamp(c.getTime());
1479 // c.add(Calendar.MILLISECOND, 1);
1480 // entity3.setLastSeenTimestamp(c.getTime());
1481 // c.add(Calendar.MILLISECOND, 1);
1482 // entity4.setLastSeenTimestamp(c.getTime());
1484 // deviceManager.learnDeviceByEntity(entity1);
1485 // deviceManager.learnDeviceByEntity(entity2);
1486 // deviceManager.learnDeviceByEntity(entity3);
1487 // IDevice d = deviceManager.learnDeviceByEntity(entity4);
1489 // // all entities are active, so entities 2,4 should win
1490 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 2),
1491 // new SwitchPort(5L, 2) },
1492 // d.getAttachmentPoints());
1493 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 2),
1494 // new SwitchPort(5L, 2)},
1495 // d.getAttachmentPoints(true));
1497 // c.add(Calendar.MILLISECOND, 1);
1498 // entity1.setLastSeenTimestamp(c.getTime());
1499 // d = deviceManager.learnDeviceByEntity(entity1);
1501 // // all entities are active, so entities 2,4 should win
1502 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1),
1503 // new SwitchPort(5L, 2) },
1504 // d.getAttachmentPoints());
1505 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1),
1506 // new SwitchPort(5L, 2),
1507 // new SwitchPort(1L, 2, ErrorStatus.DUPLICATE_DEVICE)},
1508 // d.getAttachmentPoints(true));
1510 // c.add(Calendar.MILLISECOND, Entity.ACTIVITY_TIMEOUT+1);
1511 // entity1.setLastSeenTimestamp(c.getTime());
1512 // d = deviceManager.learnDeviceByEntity(entity1);
1514 // // entities 3,4 are still in conflict, but 1 should be resolved
1515 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1),
1516 // new SwitchPort(5L, 2) },
1517 // d.getAttachmentPoints());
1518 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1),
1519 // new SwitchPort(5L, 2)},
1520 // d.getAttachmentPoints(true));
1522 // entity3.setLastSeenTimestamp(c.getTime());
1523 // d = deviceManager.learnDeviceByEntity(entity3);
1525 // // no conflicts, 1 and 3 will win
1526 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1),
1527 // new SwitchPort(5L, 1) },
1528 // d.getAttachmentPoints());
1529 // assertArrayEquals(new SwitchPort[] { new SwitchPort(1L, 1),
1530 // new SwitchPort(5L, 1) },
1531 // d.getAttachmentPoints(true));
1535 // protected void doTestDeviceQuery() throws Exception {
1536 // Entity entity1 = new Entity(1L, (short)1, 1, 1L, 1, new Date());
1537 // Entity entity2 = new Entity(2L, (short)2, 2, 1L, 2, new Date());
1538 // Entity entity3 = new Entity(3L, (short)3, 3, 5L, 1, new Date());
1539 // Entity entity4 = new Entity(4L, (short)4, 3, 5L, 2, new Date());
1540 // Entity entity5 = new Entity(1L, (short)4, 3, 5L, 2, new Date());
1542 // Device d1 = deviceManager.learnDeviceByEntity(entity1);
1543 // deviceManager.learnDeviceByEntity(entity2);
1544 // Device d3 = deviceManager.learnDeviceByEntity(entity3);
1545 // Device d4 = deviceManager.learnDeviceByEntity(entity4);
1549 // Iterator<? extends IDevice> iter =
1550 // deviceManager.queryDevices(null, (short)1, 1, null, null);
1552 // while (iter.hasNext()) {
1555 // assertEquals(d1.getDeviceKey(), d.getDeviceKey());
1557 // assertEquals(1, count);
1559 // iter = deviceManager.queryDevices(null, (short)3, 3, null, null);
1561 // while (iter.hasNext()) {
1564 // assertEquals(d3.getDeviceKey(), d.getDeviceKey());
1566 // assertEquals(1, count);
1568 // iter = deviceManager.queryDevices(null, (short)1, 3, null, null);
1570 // while (iter.hasNext()) {
1574 // assertEquals(0, count);
1576 // Device d5 = deviceManager.learnDeviceByEntity(entity5);
1577 // iter = deviceManager.queryDevices(null, (short)4, 3, null, null);
1579 // Set<Long> deviceKeysFromIterator = new HashSet<Long>();
1580 // while (iter.hasNext()) {
1583 // deviceKeysFromIterator.add(d.getDeviceKey());
1585 // Set<Long> expectedDeviceKeys = new HashSet<Long>();
1586 // expectedDeviceKeys.add(d4.getDeviceKey());
1587 // expectedDeviceKeys.add(d5.getDeviceKey());
1588 // assertEquals(expectedDeviceKeys, deviceKeysFromIterator);
1589 // assertEquals(2, count);
1592 // iter = deviceManager.queryDevices(1L, null, null, null, null);
1594 // deviceKeysFromIterator = new HashSet<Long>();
1595 // while (iter.hasNext()) {
1598 // deviceKeysFromIterator.add(d.getDeviceKey());
1600 // expectedDeviceKeys = new HashSet<Long>();
1601 // expectedDeviceKeys.add(d1.getDeviceKey());
1602 // expectedDeviceKeys.add(d5.getDeviceKey());
1603 // assertEquals(expectedDeviceKeys, deviceKeysFromIterator);
1604 // assertEquals(2, count);
1608 // public void testDeviceIndex() throws Exception {
1609 // EnumSet<IDeviceService.DeviceField> indexFields =
1610 // EnumSet.noneOf(IDeviceService.DeviceField.class);
1611 // indexFields.add(IDeviceService.DeviceField.IPV4);
1612 // indexFields.add(IDeviceService.DeviceField.VLAN);
1613 // deviceManager.addIndex(false, indexFields);
1615 // indexFields = EnumSet.noneOf(IDeviceService.DeviceField.class);
1616 // deviceManager.addIndex(false, indexFields);
1618 // ITopologyService mockTopology = createMock(ITopologyService.class);
1619 // deviceManager.topology = mockTopology;
1620 // expect(mockTopology.isAttachmentPointPort(anyLong(),
1622 // andReturn(true).anyTimes();
1623 // expect(mockTopology.getL2DomainId(EasyMock.anyLong())).andReturn(1L).anyTimes();
1624 // replay(mockTopology);
1625 // doTestDeviceQuery();
1629 // public void testDeviceQuery() throws Exception {
1630 // ITopologyService mockTopology = createMock(ITopologyService.class);
1631 // deviceManager.topology = mockTopology;
1632 // expect(mockTopology.isAttachmentPointPort(anyLong(),
1634 // andReturn(true).anyTimes();
1635 // expect(mockTopology.getL2DomainId(EasyMock.anyLong())).andReturn(1L).anyTimes();
1636 // replay(mockTopology);
1638 // doTestDeviceQuery();
1641 // protected void doTestDeviceClassQuery() throws Exception {
1642 // Entity entity1 = new Entity(1L, (short)1, 1, 1L, 1, new Date());
1643 // Entity entity2 = new Entity(2L, (short)2, 2, 1L, 2, new Date());
1644 // Entity entity3 = new Entity(3L, (short)3, 3, 5L, 1, new Date());
1645 // Entity entity4 = new Entity(4L, (short)4, 3, 5L, 2, new Date());
1646 // Entity entity5 = new Entity(1L, (short)4, 3, 5L, 2, new Date());
1648 // IDevice d1 = deviceManager.learnDeviceByEntity(entity1);
1649 // IDevice d2 = deviceManager.learnDeviceByEntity(entity2);
1650 // IDevice d3 = deviceManager.learnDeviceByEntity(entity3);
1651 // IDevice d4 = deviceManager.learnDeviceByEntity(entity4);
1652 // assertEquals(d1.getEntityClass(), d2.getEntityClass());
1653 // assertEquals(d1.getEntityClass(), d3.getEntityClass());
1654 // assertEquals(d1.getEntityClass(), d4.getEntityClass());
1658 // Iterator<? extends IDevice> iter =
1659 // deviceManager.queryClassDevices(d1.getEntityClass(), null,
1660 // (short)1, 1, null, null);
1662 // while (iter.hasNext()) {
1665 // assertEquals(d1.getDeviceKey(), d.getDeviceKey());
1667 // assertEquals(1, count);
1669 // iter = deviceManager.queryClassDevices(d1.getEntityClass(), null,
1670 // (short)3, 3, null, null);
1672 // while (iter.hasNext()) {
1675 // assertEquals(d3.getDeviceKey(), d.getDeviceKey());
1678 // assertEquals(1, count);
1680 // iter = deviceManager.queryClassDevices(d1.getEntityClass(), null,
1681 // (short)1, 3, null, null);
1683 // while (iter.hasNext()) {
1687 // assertEquals(0, count);
1689 // IDevice d5 = deviceManager.learnDeviceByEntity(entity5);
1690 // assertEquals(d1.getEntityClass(), d5.getEntityClass());
1691 // iter = deviceManager.queryClassDevices(d1.getEntityClass(), null,
1692 // (short)4, 3, null, null);
1694 // Set<Long> deviceKeysFromIterator = new HashSet<Long>();
1695 // while (iter.hasNext()) {
1698 // deviceKeysFromIterator.add(d.getDeviceKey());
1700 // Set<Long> expectedDeviceKeys = new HashSet<Long>();
1701 // expectedDeviceKeys.add(d4.getDeviceKey());
1702 // expectedDeviceKeys.add(d5.getDeviceKey());
1703 // assertEquals(expectedDeviceKeys, deviceKeysFromIterator);
1704 // assertEquals(2, count);
1708 // public void testDeviceClassIndex() throws Exception {
1709 // EnumSet<IDeviceService.DeviceField> indexFields =
1710 // EnumSet.noneOf(IDeviceService.DeviceField.class);
1711 // indexFields.add(IDeviceService.DeviceField.IPV4);
1712 // indexFields.add(IDeviceService.DeviceField.VLAN);
1713 // deviceManager.addIndex(true, indexFields);
1715 // ITopologyService mockTopology = createMock(ITopologyService.class);
1716 // deviceManager.topology = mockTopology;
1717 // expect(mockTopology.isAttachmentPointPort(anyLong(),
1719 // andReturn(true).anyTimes();
1720 // expect(mockTopology.getL2DomainId(EasyMock.anyLong())).andReturn(1L).anyTimes();
1721 // replay(mockTopology);
1723 // doTestDeviceClassQuery();
1727 // public void testDeviceClassQuery() throws Exception {
1728 // ITopologyService mockTopology = createMock(ITopologyService.class);
1729 // deviceManager.topology = mockTopology;
1730 // expect(mockTopology.isAttachmentPointPort(anyLong(),
1732 // andReturn(true).anyTimes();
1733 // expect(mockTopology.getL2DomainId(EasyMock.anyLong())).andReturn(1L).anyTimes();
1734 // replay(mockTopology);
1736 // doTestDeviceClassQuery();
1740 // public void testFindDevice() throws FloodlightModuleException {
1741 // boolean exceptionCaught;
1742 // deviceManager.entityClassifier= new MockEntityClassifierMac();
1743 // deviceManager.startUp(null);
1745 // ITopologyService mockTopology = createMock(ITopologyService.class);
1746 // deviceManager.topology = mockTopology;
1747 // expect(mockTopology.isAttachmentPointPort(anyLong(),
1749 // andReturn(true).anyTimes();
1750 // expect(mockTopology.getL2DomainId(EasyMock.anyLong())).andReturn(1L).anyTimes();
1751 // replay(mockTopology);
1753 // Entity entity1 = new Entity(1L, (short)1, 1, 1L, 1, new Date());
1754 // Entity entity2 = new Entity(2L, (short)2, 2, 1L, 2, new Date());
1755 // Entity entity2b = new Entity(22L, (short)2, 2, 1L, 2, new Date());
1757 // Entity entity3 = new Entity(3L, (short)1, 3, 2L, 1, new Date());
1758 // Entity entity4 = new Entity(4L, (short)2, 4, 2L, 2, new Date());
1760 // Entity entity5 = new Entity(5L, (short)1, 5, 3L, 1, new Date());
1763 // IDevice d1 = deviceManager.learnDeviceByEntity(entity1);
1764 // IDevice d2 = deviceManager.learnDeviceByEntity(entity2);
1765 // IDevice d3 = deviceManager.learnDeviceByEntity(entity3);
1766 // IDevice d4 = deviceManager.learnDeviceByEntity(entity4);
1767 // IDevice d5 = deviceManager.learnDeviceByEntity(entity5);
1769 // // Make sure the entity classifier worked as expected
1770 // assertEquals(MockEntityClassifierMac.testECMac1, d1.getEntityClass());
1771 // assertEquals(MockEntityClassifierMac.testECMac1, d2.getEntityClass());
1772 // assertEquals(MockEntityClassifierMac.testECMac2, d3.getEntityClass());
1773 // assertEquals(MockEntityClassifierMac.testECMac2, d4.getEntityClass());
1774 // assertEquals(DefaultEntityClassifier.entityClass,
1775 // d5.getEntityClass());
1777 // // Look up the device using findDevice() which uses only the primary
1779 // assertEquals(d1, deviceManager.findDevice(entity1.getMacAddress(),
1780 // entity1.getVlan(),
1781 // entity1.getIpv4Address(),
1782 // entity1.getSwitchDPID(),
1783 // entity1.getSwitchPort()));
1784 // // port changed. Device will be found through class index
1785 // assertEquals(d1, deviceManager.findDevice(entity1.getMacAddress(),
1786 // entity1.getVlan(),
1787 // entity1.getIpv4Address(),
1788 // entity1.getSwitchDPID(),
1789 // entity1.getSwitchPort()+1));
1790 // // VLAN changed. No device matches
1791 // assertEquals(null, deviceManager.findDevice(entity1.getMacAddress(),
1793 // entity1.getIpv4Address(),
1794 // entity1.getSwitchDPID(),
1795 // entity1.getSwitchPort()));
1796 // assertEquals(null, deviceManager.findDevice(entity1.getMacAddress(),
1798 // entity1.getIpv4Address(),
1799 // entity1.getSwitchDPID(),
1800 // entity1.getSwitchPort()));
1801 // assertEquals(d2, deviceManager.findDeviceByEntity(entity2));
1802 // assertEquals(null, deviceManager.findDeviceByEntity(entity2b));
1803 // assertEquals(d3, deviceManager.findDevice(entity3.getMacAddress(),
1804 // entity3.getVlan(),
1805 // entity3.getIpv4Address(),
1806 // entity3.getSwitchDPID(),
1807 // entity3.getSwitchPort()));
1808 // // switch and port not set. throws exception
1809 // exceptionCaught = false;
1811 // assertEquals(null, deviceManager.findDevice(entity3.getMacAddress(),
1812 // entity3.getVlan(),
1813 // entity3.getIpv4Address(),
1817 // catch (IllegalArgumentException e) {
1818 // exceptionCaught = true;
1820 // if (!exceptionCaught)
1821 // fail("findDevice() did not throw IllegalArgumentException");
1822 // assertEquals(d4, deviceManager.findDeviceByEntity(entity4));
1823 // assertEquals(d5, deviceManager.findDevice(entity5.getMacAddress(),
1824 // entity5.getVlan(),
1825 // entity5.getIpv4Address(),
1826 // entity5.getSwitchDPID(),
1827 // entity5.getSwitchPort()));
1828 // // switch and port not set. throws exception (swith/port are key
1829 // // fields of IEntityClassifier but not d5.entityClass
1830 // exceptionCaught = false;
1832 // assertEquals(d5, deviceManager.findDevice(entity5.getMacAddress(),
1833 // entity5.getVlan(),
1834 // entity5.getIpv4Address(),
1838 // catch (IllegalArgumentException e) {
1839 // exceptionCaught = true;
1841 // if (!exceptionCaught)
1842 // fail("findDevice() did not throw IllegalArgumentException");
1845 // Entity entityNoClass = new Entity(5L, (short)1, 5, -1L, 1, new Date());
1846 // assertEquals(null, deviceManager.findDeviceByEntity(entityNoClass));
1849 // // Now look up destination devices
1850 // assertEquals(d1, deviceManager.findClassDevice(d2.getEntityClass(),
1851 // entity1.getMacAddress(),
1852 // entity1.getVlan(),
1853 // entity1.getIpv4Address()));
1854 // assertEquals(d1, deviceManager.findClassDevice(d2.getEntityClass(),
1855 // entity1.getMacAddress(),
1856 // entity1.getVlan(),
1858 // assertEquals(null, deviceManager.findClassDevice(d2.getEntityClass(),
1859 // entity1.getMacAddress(),
1867 // public void testGetIPv4Addresses() {
1868 // // Looks like Date is only 1s granularity
1870 // ITopologyService mockTopology = createMock(ITopologyService.class);
1871 // deviceManager.topology = mockTopology;
1872 // expect(mockTopology.isAttachmentPointPort(anyLong(),
1874 // andReturn(true).anyTimes();
1875 // expect(mockTopology.getL2DomainId(anyLong())).andReturn(1L).anyTimes();
1876 // expect(mockTopology.isConsistent(EasyMock.anyLong(),
1877 // EasyMock.anyShort(),
1878 // EasyMock.anyLong(),
1879 // EasyMock.anyShort()))
1880 // .andReturn(false)
1882 // expect(mockTopology.isBroadcastDomainPort(EasyMock.anyLong(),
1883 // EasyMock.anyShort()))
1884 // .andReturn(false)
1886 // expect(mockTopology.isInSameBroadcastDomain(EasyMock.anyLong(),
1887 // EasyMock.anyShort(),
1888 // EasyMock.anyLong(),
1889 // EasyMock.anyShort())).
1890 // andReturn(false).anyTimes();
1891 // replay(mockTopology);
1893 // Entity e1 = new Entity(1L, (short)1, null, null, null, new Date(2000));
1894 // Device d1 = deviceManager.learnDeviceByEntity(e1);
1895 // assertArrayEquals(new Integer[0], d1.getIPv4Addresses());
1898 // Entity e2 = new Entity(2L, (short)2, 2, null, null, new Date(2000));
1899 // Device d2 = deviceManager.learnDeviceByEntity(e2);
1900 // d2 = deviceManager.learnDeviceByEntity(e2);
1901 // assertArrayEquals(new Integer[] { 2 }, d2.getIPv4Addresses());
1902 // // More than one entity
1903 // Entity e2b = new Entity(2L, (short)2, null, 2L, 2, new Date(3000));
1904 // d2 = deviceManager.learnDeviceByEntity(e2b);
1905 // assertEquals(2, d2.entities.length);
1906 // assertArrayEquals(new Integer[] { 2 }, d2.getIPv4Addresses());
1907 // // and now add an entity with an IP
1908 // Entity e2c = new Entity(2L, (short)2, 2, 2L, 3, new Date(3000));
1909 // d2 = deviceManager.learnDeviceByEntity(e2c);
1910 // assertArrayEquals(new Integer[] { 2 }, d2.getIPv4Addresses());
1911 // assertEquals(3, d2.entities.length);
1913 // // Other devices with different IPs shouldn't interfere
1914 // Entity e3 = new Entity(3L, (short)3, 3, null, null, new Date(4000));
1915 // Entity e3b = new Entity(3L, (short)3, 3, 3L, 3, new Date(4400));
1916 // Device d3 = deviceManager.learnDeviceByEntity(e3);
1917 // d3 = deviceManager.learnDeviceByEntity(e3b);
1918 // assertArrayEquals(new Integer[] { 2 }, d2.getIPv4Addresses());
1919 // assertArrayEquals(new Integer[] { 3 }, d3.getIPv4Addresses());
1921 // // Add another IP to d3
1922 // Entity e3c = new Entity(3L, (short)3, 33, 3L, 3, new Date(4400));
1923 // d3 = deviceManager.learnDeviceByEntity(e3c);
1924 // Integer[] ips = d3.getIPv4Addresses();
1925 // Arrays.sort(ips);
1926 // assertArrayEquals(new Integer[] { 3, 33 }, ips);
1928 // // Add another device that also claims IP2 but is older than e2
1929 // Entity e4 = new Entity(4L, (short)4, 2, null, null, new Date(1000));
1930 // Entity e4b = new Entity(4L, (short)4, null, 4L, 4, new Date(1000));
1931 // Device d4 = deviceManager.learnDeviceByEntity(e4);
1932 // assertArrayEquals(new Integer[] { 2 }, d2.getIPv4Addresses());
1933 // assertArrayEquals(new Integer[0], d4.getIPv4Addresses());
1934 // // add another entity to d4
1935 // d4 = deviceManager.learnDeviceByEntity(e4b);
1936 // assertArrayEquals(new Integer[0], d4.getIPv4Addresses());
1938 // // Make e4 and e4a newer
1939 // Entity e4c = new Entity(4L, (short)4, 2, null, null, new Date(5000));
1940 // Entity e4d = new Entity(4L, (short)4, null, 4L, 5, new Date(5000));
1941 // d4 = deviceManager.learnDeviceByEntity(e4c);
1942 // d4 = deviceManager.learnDeviceByEntity(e4d);
1943 // assertArrayEquals(new Integer[0], d2.getIPv4Addresses());
1944 // // FIXME: d4 should not return IP4
1945 // assertArrayEquals(new Integer[] { 2 }, d4.getIPv4Addresses());
1947 // // Add another newer entity to d2 but with different IP
1948 // Entity e2d = new Entity(2L, (short)2, 22, 4L, 6, new Date(6000));
1949 // d2 = deviceManager.learnDeviceByEntity(e2d);
1950 // assertArrayEquals(new Integer[] { 22 }, d2.getIPv4Addresses());
1951 // assertArrayEquals(new Integer[] { 2 }, d4.getIPv4Addresses());
1953 // // new IP for d2,d4 but with same timestamp. Both devices get the IP
1954 // Entity e2e = new Entity(2L, (short)2, 42, 2L, 4, new Date(7000));
1955 // d2 = deviceManager.learnDeviceByEntity(e2e);
1956 // ips= d2.getIPv4Addresses();
1957 // Arrays.sort(ips);
1958 // assertArrayEquals(new Integer[] { 22, 42 }, ips);
1959 // Entity e4e = new Entity(4L, (short)4, 42, 4L, 7, new Date(7000));
1960 // d4 = deviceManager.learnDeviceByEntity(e4e);
1961 // ips= d4.getIPv4Addresses();
1962 // Arrays.sort(ips);
1963 // assertArrayEquals(new Integer[] { 2, 42 }, ips);
1965 // // add a couple more IPs
1966 // Entity e2f = new Entity(2L, (short)2, 4242, 2L, 5, new Date(8000));
1967 // d2 = deviceManager.learnDeviceByEntity(e2f);
1968 // ips= d2.getIPv4Addresses();
1969 // Arrays.sort(ips);
1970 // assertArrayEquals(new Integer[] { 22, 42, 4242 }, ips);
1971 // Entity e4f = new Entity(4L, (short)4, 4242, 4L, 8, new Date(9000));
1972 // d4 = deviceManager.learnDeviceByEntity(e4f);
1973 // ips= d4.getIPv4Addresses();
1974 // Arrays.sort(ips);
1975 // assertArrayEquals(new Integer[] { 2, 42, 4242 }, ips);
1978 // // TODO: this test should really go into a separate class that collects
1979 // // unit tests for Device
1981 // public void testGetSwitchPortVlanId() {
1982 // Entity entity1 = new Entity(1L, (short)1, null, 10L, 1, new Date());
1983 // Entity entity2 = new Entity(1L, null, null, 10L, 1, new Date());
1984 // Entity entity3 = new Entity(1L, (short)3, null, 1L, 1, new Date());
1985 // Entity entity4 = new Entity(1L, (short)42, null, 1L, 1, new Date());
1986 // Entity[] entities = new Entity[] { entity1, entity2,
1989 // Device d = new Device(null,1L, null, null, null,
1990 // Arrays.asList(entities), null);
1991 // SwitchPort swp1x1 = new SwitchPort(1L, 1);
1992 // SwitchPort swp1x2 = new SwitchPort(1L, 2);
1993 // SwitchPort swp2x1 = new SwitchPort(2L, 1);
1994 // SwitchPort swp10x1 = new SwitchPort(10L, 1);
1995 // assertArrayEquals(new Short[] { -1, 1},
1996 // d.getSwitchPortVlanIds(swp10x1));
1997 // assertArrayEquals(new Short[] { 3, 42},
1998 // d.getSwitchPortVlanIds(swp1x1));
1999 // assertArrayEquals(new Short[0],
2000 // d.getSwitchPortVlanIds(swp1x2));
2001 // assertArrayEquals(new Short[0],
2002 // d.getSwitchPortVlanIds(swp2x1));
2006 // public void testReclassifyDevice() throws FloodlightModuleException {
2007 // MockFlexEntityClassifier flexClassifier =
2008 // new MockFlexEntityClassifier();
2009 // deviceManager.entityClassifier= flexClassifier;
2010 // deviceManager.startUp(null);
2012 // ITopologyService mockTopology = createMock(ITopologyService.class);
2013 // deviceManager.topology = mockTopology;
2014 // expect(mockTopology.isAttachmentPointPort(anyLong(),
2016 // andReturn(true).anyTimes();
2017 // expect(mockTopology.getL2DomainId(anyLong())).andReturn(1L).anyTimes();
2018 // expect(mockTopology.isConsistent(EasyMock.anyLong(),
2019 // EasyMock.anyShort(),
2020 // EasyMock.anyLong(),
2021 // EasyMock.anyShort()))
2022 // .andReturn(false)
2024 // expect(mockTopology.isBroadcastDomainPort(EasyMock.anyLong(),
2025 // EasyMock.anyShort()))
2026 // .andReturn(false)
2028 // replay(mockTopology);
2030 // //flexClassifier.createTestEntityClass("Class1");
2032 // Entity entity1 = new Entity(1L, (short)1, 1, 1L, 1, new Date());
2033 // Entity entity1b = new Entity(1L, (short)2, 1, 1L, 1, new Date());
2034 // Entity entity2 = new Entity(2L, (short)1, 2, 2L, 2, new Date());
2035 // Entity entity2b = new Entity(2L, (short)2, 2, 2L, 2, new Date());
2038 // Device d1 = deviceManager.learnDeviceByEntity(entity1);
2039 // Device d2 = deviceManager.learnDeviceByEntity(entity2);
2040 // Device d1b = deviceManager.learnDeviceByEntity(entity1b);
2041 // Device d2b = deviceManager.learnDeviceByEntity(entity2b);
2043 // d1 = deviceManager.getDeviceIteratorForQuery(entity1.getMacAddress(),
2044 // entity1.getVlan(), entity1.getIpv4Address(),
2045 // entity1.getSwitchDPID(), entity1.getSwitchPort())
2047 // d1b = deviceManager.getDeviceIteratorForQuery(entity1b.getMacAddress(),
2048 // entity1b.getVlan(), entity1b.getIpv4Address(),
2049 // entity1b.getSwitchDPID(), entity1b.getSwitchPort()).next();
2051 // assertEquals(d1, d1b);
2053 // d2 = deviceManager.getDeviceIteratorForQuery(entity2.getMacAddress(),
2054 // entity2.getVlan(), entity2.getIpv4Address(),
2055 // entity2.getSwitchDPID(), entity2.getSwitchPort()).next();
2056 // d2b = deviceManager.getDeviceIteratorForQuery(entity2b.getMacAddress(),
2057 // entity2b.getVlan(), entity2b.getIpv4Address(),
2058 // entity2b.getSwitchDPID(), entity2b.getSwitchPort()).next();
2059 // assertEquals(d2, d2b);
2061 // IEntityClass eC1 = flexClassifier.createTestEntityClass("C1");
2062 // IEntityClass eC2 = flexClassifier.createTestEntityClass("C2");
2064 // flexClassifier.addVlanEntities((short)1, eC1);
2065 // flexClassifier.addVlanEntities((short)2, eC1);
2067 // deviceManager.reclassifyDevice(d1);
2068 // deviceManager.reclassifyDevice(d2);
2070 // d1 = deviceManager.deviceMap.get(
2071 // deviceManager.primaryIndex.findByEntity(entity1));
2072 // d1b = deviceManager.deviceMap.get(
2073 // deviceManager.primaryIndex.findByEntity(entity1b));
2075 // assertEquals(d1, d1b);
2077 // d2 = deviceManager.deviceMap.get(
2078 // deviceManager.primaryIndex.findByEntity(entity2));
2079 // d2b = deviceManager.deviceMap.get(
2080 // deviceManager.primaryIndex.findByEntity(entity2b));
2082 // assertEquals(d2, d2b);
2084 // flexClassifier.addVlanEntities((short)1, eC2);
2086 // deviceManager.reclassifyDevice(d1);
2087 // deviceManager.reclassifyDevice(d2);
2088 // d1 = deviceManager.deviceMap.get(
2089 // deviceManager.primaryIndex.findByEntity(entity1));
2090 // d1b = deviceManager.deviceMap.get(
2091 // deviceManager.primaryIndex.findByEntity(entity1b));
2092 // d2 = deviceManager.deviceMap.get(
2093 // deviceManager.primaryIndex.findByEntity(entity2));
2094 // d2b = deviceManager.deviceMap.get(
2095 // deviceManager.primaryIndex.findByEntity(entity2b));
2097 // assertNotSame(d1, d1b);
2099 // assertNotSame(d2, d2b);
2101 // flexClassifier.addVlanEntities((short)1, eC1);
2102 // deviceManager.reclassifyDevice(d1);
2103 // deviceManager.reclassifyDevice(d2);
2104 // ClassState classState = deviceManager.classStateMap.get(eC1.getName());
2106 // Long deviceKey1 = null;
2107 // Long deviceKey1b = null;
2108 // Long deviceKey2 = null;
2109 // Long deviceKey2b = null;
2112 // classState.classIndex.findByEntity(entity1);
2114 // classState.classIndex.findByEntity(entity1b);
2116 // classState.classIndex.findByEntity(entity2);
2118 // classState.classIndex.findByEntity(entity2b);
2120 // assertEquals(deviceKey1, deviceKey1b);
2122 // assertEquals(deviceKey2, deviceKey2b);
2126 // public void testSyncEntity() {
2127 // Date d1 = new Date();
2128 // Date d2 = new Date(0);
2129 // Entity e1 = new Entity(1L, (short)2, 3, 4L, 5, d1);
2130 // e1.setActiveSince(d2);
2131 // SyncEntity se1 = new SyncEntity(e1);
2132 // assertEntityEquals(e1, se1);
2133 // assertEquals(1L, se1.macAddress);
2134 // assertEquals(Short.valueOf((short)2), se1.vlan);
2135 // assertEquals(Integer.valueOf(3), se1.ipv4Address);
2136 // assertEquals(Long.valueOf(4L), se1.switchDPID);
2137 // assertEquals(Integer.valueOf(5), se1.switchPort);
2138 // assertEquals(d1, se1.lastSeenTimestamp);
2139 // assertEquals(d2, se1.activeSince);
2140 // assertNotSame(d1, se1.lastSeenTimestamp);
2141 // assertNotSame(d2, se1.activeSince);
2143 // Entity e2 = new Entity(42L, null, null, null, null, null);
2144 // SyncEntity se2 = new SyncEntity(e2);
2145 // assertEntityEquals(e2, se2);
2147 // SyncEntity se3 = new SyncEntity();
2148 // SyncEntity se4 = new SyncEntity();
2149 // se3.lastSeenTimestamp = new Date(1000);
2150 // se4.lastSeenTimestamp = new Date(2000);
2151 // assertTrue("", se3.compareTo(se4) < 0);
2152 // assertTrue("", se4.compareTo(se3) > 0);
2153 // se4.lastSeenTimestamp = new Date(1000);
2154 // assertTrue("", se3.compareTo(se4) == 0);
2155 // assertTrue("", se4.compareTo(se3) == 0);
2156 // se4.lastSeenTimestamp = new Date(500);
2157 // assertTrue("", se3.compareTo(se4) > 0);
2158 // assertTrue("", se4.compareTo(se3) < 0);
2161 // /* Test basic DeviceSyncRepresentation behavior */
2163 // public void testDeviceSyncRepresentationBasics() {
2164 // DeviceSyncRepresentation dsr = new DeviceSyncRepresentation();
2165 // assertNull(dsr.getKey());
2166 // assertNull(dsr.getEntities());
2167 // dsr.setKey("MyKey");
2168 // assertEquals("MyKey", dsr.getKey());
2169 // assertEquals("MyKey", dsr.toString());
2171 // List<SyncEntity> entities = new ArrayList<SyncEntity>();
2172 // Entity e1a = new Entity(1L, (short)2, 3, 4L, 5, new Date(1000));
2173 // Entity e1b = new Entity(1L, (short)2, null, 4L, 5, new Date(0));
2174 // entities.add(new SyncEntity(e1a));
2175 // entities.add(new SyncEntity(e1b));
2176 // // e1b comes before e1 (lastSeen) but we add it after it to test
2178 // dsr.setEntities(entities);
2180 // assertEquals(2, dsr.getEntities().size());
2181 // // e1b has earlier time
2182 // assertEquals(e1b, dsr.getEntities().get(0).asEntity());
2183 // assertEquals(e1a, dsr.getEntities().get(1).asEntity());
2185 // dsr.setKey(null);
2186 // dsr.setEntities(null);
2187 // assertNull(dsr.getKey());
2188 // assertNull(dsr.getEntities());
2192 // public void testDeviceSyncRepresentationFromDevice() {
2193 // ITopologyService mockTopology = makeMockTopologyAllPortsAp();
2194 // replay(mockTopology);
2195 // deviceManager.topology = mockTopology;
2197 // deviceManager.entityClassifier = new MockEntityClassifier();
2199 // //**************************************
2200 // // Test 1: a single entity
2201 // Entity e1 = new Entity(1L, (short)2, 3, 4L, 5, new Date(1000));
2202 // Device d1 = deviceManager.learnDeviceByEntity(e1);
2203 // assertEquals("Sanity check failed. Device doesn't have the expected " +
2204 // "entity class. Something with the test setup is strange",
2205 // "DefaultEntityClass", d1.getEntityClass().getName());
2206 // assertEquals("Sanity check failed. Device doesn't have the expected " +
2207 // "entity class. Something with the test setup is strange",
2208 // EnumSet.of(DeviceField.MAC, DeviceField.VLAN),
2209 // d1.getEntityClass().getKeyFields());
2211 // Long deviceKey = d1.getDeviceKey();
2212 // DeviceSyncRepresentation dsr1 = new DeviceSyncRepresentation(d1);
2213 // assertEquals("DefaultEntityClass::00:00:00:00:00:01::[2]::",
2215 // assertEquals(1, dsr1.getEntities().size());
2216 // assertEquals(e1, dsr1.getEntities().get(0).asEntity());
2218 // //**************************************
2219 // // Test 1b: same device, now with a second entity (no IP).
2220 // // this second entity has a lastSeen time that is earlier than the
2222 // Entity e1b = new Entity(1L, (short)2, null, 4L, 5, new Date(0));
2223 // d1 = deviceManager.learnDeviceByEntity(e1b);
2224 // assertEquals("Sanity check failed. Should still be same device but " +
2225 // "deviceKeys differs", deviceKey, d1.getDeviceKey());
2226 // dsr1 = new DeviceSyncRepresentation(d1);
2227 // assertEquals("DefaultEntityClass::00:00:00:00:00:01::[2]::",
2229 // assertEquals(2, dsr1.getEntities().size());
2230 // // Entities are ordered by their lastSeen time. e1b should come
2232 // assertEquals(e1, dsr1.getEntities().get(1).asEntity());
2233 // assertEquals(e1b, dsr1.getEntities().get(0).asEntity());
2235 // //**************************************
2236 // // Test 1c: same device with a third entity that does not have a
2237 // // switch port. It should be added to the DeviceSyncRepresentation
2238 // Entity e1c = new Entity(1L, (short)2, 33, null, null, new Date(2000));
2239 // d1 = deviceManager.learnDeviceByEntity(e1c);
2240 // assertEquals("Sanity check failed. Should still be same device but " +
2241 // "deviceKeys differs", deviceKey, d1.getDeviceKey());
2242 // dsr1 = new DeviceSyncRepresentation(d1);
2243 // assertEquals("DefaultEntityClass::00:00:00:00:00:01::[2]::",
2245 // assertEquals(3, dsr1.getEntities().size());
2246 // // Entities are ordered by their lastSeen time
2247 // assertEquals(e1c, dsr1.getEntities().get(2).asEntity());
2248 // assertEquals(e1, dsr1.getEntities().get(1).asEntity());
2249 // assertEquals(e1b, dsr1.getEntities().get(0).asEntity());
2251 // //**************************************
2252 // // Test 1d: same device with a fourth entity that has a different
2253 // // attachment point and that is newer. Device should move and
2254 // // non-attachment point entities should be removed (e1b). Although
2255 // // e1 is non-attachment point it will remain because it has an IP
2256 // Entity e1d = new Entity(1L, (short)2, 33, 4L, 6, new Date(3000));
2257 // d1 = deviceManager.learnDeviceByEntity(e1d);
2258 // assertEquals("Sanity check failed. Should still be same device but " +
2259 // "deviceKeys differs", deviceKey, d1.getDeviceKey());
2260 // dsr1 = new DeviceSyncRepresentation(d1);
2261 // assertEquals("DefaultEntityClass::00:00:00:00:00:01::[2]::",
2263 // assertEquals(3, dsr1.getEntities().size());
2264 // assertEquals(e1, dsr1.getEntities().get(0).asEntity());
2265 // assertEquals(e1c, dsr1.getEntities().get(1).asEntity());
2266 // assertEquals(e1d, dsr1.getEntities().get(2).asEntity());
2271 // //**************************************
2272 // // Test 2: a second device with a different entity class. The
2273 // // mock entity classifier will return an entity class where all
2274 // // fields are keys if the DPID is > 10L
2275 // Entity e2 = new Entity(2L, (short)23, 24, 11L, 1, new Date(0));
2276 // Device d2 = deviceManager.learnDeviceByEntity(e2);
2277 // DeviceSyncRepresentation dsr2 = new DeviceSyncRepresentation(d2);
2278 // assertEquals("Sanity check failed. Device doesn't have the expected " +
2279 // "entity class. Something with the test setup is strange",
2280 // "TestEntityClass", d2.getEntityClass().getName());
2281 // assertEquals("Sanity check failed. Device doesn't have the expected " +
2282 // "entity class. Something with the test setup is strange",
2283 // EnumSet.of(DeviceField.MAC, DeviceField.VLAN,
2284 // DeviceField.SWITCH, DeviceField.PORT),
2285 // d2.getEntityClass().getKeyFields());
2286 // SwitchPort swp = new SwitchPort(11L, 1, null);
2287 // assertEquals("TestEntityClass::00:00:00:00:00:02::[23]::[" +
2288 // swp.toString() + "]::",
2292 // /* interate through all entries in the sync store and return them as
2293 // * list. We don't return the key from the store however, we assert
2294 // * that the key from the store matches the key in the representation.
2295 // * If we have a null value (tombstone) we simply add the null value to
2296 // * the list to return.
2298 // private List<DeviceSyncRepresentation> getEntriesFromStore()
2299 // throws Exception {
2300 // List<DeviceSyncRepresentation> entries =
2301 // new ArrayList<DeviceSyncRepresentation>();
2302 // IClosableIterator<Entry<String, Versioned<DeviceSyncRepresentation>>> iter =
2303 // storeClient.entries();
2305 // while(iter.hasNext()) {
2306 // Entry<String, Versioned<DeviceSyncRepresentation>> entry =
2308 // DeviceSyncRepresentation dsr = entry.getValue().getValue();
2310 // assertEquals(entry.getKey(), dsr.getKey());
2311 // entries.add(dsr);
2314 // if (iter != null)
2321 // * assert whether the given Entity expected is equals to the given
2322 // * SyncEntity actual. This method also compares the times (lastSeen,
2323 // * activeSince). Entity.equals will not do that!
2325 // private static void assertEntityEquals(Entity expected, SyncEntity actual) {
2326 // assertNotNull(actual);
2327 // assertNotNull(expected);
2328 // Entity actualEntity = actual.asEntity();
2329 // assertEquals("entityFields", expected, actualEntity);
2330 // assertEquals("lastSeenTimestamp",
2331 // expected.getLastSeenTimestamp(),
2332 // actualEntity.getLastSeenTimestamp());
2333 // assertEquals("activeSince",
2334 // expected.getActiveSince(), actualEntity.getActiveSince());
2337 // /* This test tests the normal operation as master when we write to the sync
2338 // * store or delete from the store.
2341 // public void testWriteToSyncStore() throws Exception {
2342 // int syncStoreIntervalMs = 50;
2343 // ITopologyService mockTopology = makeMockTopologyAllPortsAp();
2344 // replay(mockTopology);
2345 // deviceManager.topology = mockTopology;
2346 // deviceManager.setSyncStoreWriteInterval(syncStoreIntervalMs);
2348 // Entity e1a = new Entity(1L, (short)2, 3, 4L, 5, new Date(1000));
2349 // e1a.setActiveSince(new Date(0));
2350 // deviceManager.learnDeviceByEntity(e1a);
2352 // //storeClient.put("FooBar", new DeviceSyncRepresentation());
2354 // List<DeviceSyncRepresentation> entries = getEntriesFromStore();
2355 // assertEquals(1, entries.size());
2356 // DeviceSyncRepresentation dsr1 = entries.get(0);
2357 // assertEquals(1, dsr1.getEntities().size());
2358 // assertEntityEquals(e1a, dsr1.getEntities().get(0));
2360 // // Same entity but newer timestamp. Since the device hasn't changed,
2361 // // only the timestamp is updated and the write should be throttled.
2362 // Entity e1b = new Entity(1L, (short)2, 3, 4L, 5, new Date(2000));
2363 // e1b.setActiveSince(new Date(0));
2364 // deviceManager.learnDeviceByEntity(e1a);
2365 // entries = getEntriesFromStore();
2366 // assertEquals(1, entries.size());
2367 // dsr1 = entries.get(0);
2368 // assertEquals(1, dsr1.getEntities().size());
2369 // assertEntityEquals(e1a, dsr1.getEntities().get(0)); //e1a not e1b !!!
2371 // // Wait for the write interval to expire then write again.
2372 // Thread.sleep(syncStoreIntervalMs+5);
2373 // Entity e1c = new Entity(1L, (short)2, 3, 4L, 5, new Date(3000));
2374 // e1c.setActiveSince(new Date(0));
2375 // deviceManager.learnDeviceByEntity(e1c);
2376 // entries = getEntriesFromStore();
2377 // assertEquals(1, entries.size());
2378 // dsr1 = entries.get(0);
2379 // assertEquals(1, dsr1.getEntities().size());
2380 // assertEntityEquals(e1c, dsr1.getEntities().get(0)); // e1c !!
2382 // // Entity for same device but with different IP. should be added
2384 // Entity e1d = new Entity(1L, (short)2, 33, 4L, 5, new Date(4000));
2385 // e1d.setActiveSince(new Date(0));
2386 // deviceManager.learnDeviceByEntity(e1d);
2387 // entries = getEntriesFromStore();
2388 // assertEquals(1, entries.size());
2389 // dsr1 = entries.get(0);
2390 // assertEquals(2, dsr1.getEntities().size());
2391 // assertEntityEquals(e1c, dsr1.getEntities().get(0)); // e1c !!
2392 // assertEntityEquals(e1d, dsr1.getEntities().get(1)); // e1d !!
2394 // // Entity for same device with new switch port ==> moved ==> write
2395 // // update immediately without throttle.
2396 // // Note: the previous entities will still be there because they have
2397 // // IPs (even though they aren't for the current attachment point)
2398 // Entity e1e = new Entity(1L, (short)2, 33, 4L, 6, new Date(5000));
2399 // e1e.setActiveSince(new Date(0));
2400 // deviceManager.learnDeviceByEntity(e1e);
2401 // entries = getEntriesFromStore();
2402 // assertEquals(1, entries.size());
2403 // dsr1 = entries.get(0);
2404 // assertEquals(3, dsr1.getEntities().size());
2405 // assertEntityEquals(e1c, dsr1.getEntities().get(0));
2406 // assertEntityEquals(e1d, dsr1.getEntities().get(1));
2407 // assertEntityEquals(e1e, dsr1.getEntities().get(2));
2409 // // Add a second device
2410 // Entity e2 = new Entity(2L, null, null, 5L, 5, new Date());
2411 // deviceManager.learnDeviceByEntity(e2);
2412 // entries = getEntriesFromStore();
2413 // assertEquals(2, entries.size());
2414 // for (DeviceSyncRepresentation dsr: entries) {
2415 // // This is a kinda ugly way to ensure we have the two
2416 // // devices we need..... but it will work for now
2417 // if (dsr.getKey().contains("::00:00:00:00:00:01::")) {
2418 // assertEquals(3, dsr.getEntities().size());
2419 // assertEntityEquals(e1c, dsr.getEntities().get(0));
2420 // assertEntityEquals(e1d, dsr.getEntities().get(1));
2421 // assertEntityEquals(e1e, dsr.getEntities().get(2));
2422 // } else if (dsr.getKey().contains("::00:00:00:00:00:02::")) {
2423 // assertEquals(1, dsr.getEntities().size());
2424 // assertEntityEquals(e2, dsr.getEntities().get(0));
2426 // fail("Unknown entry in store: " + dsr);
2431 // // Run entity cleanup. Since we've used phony time stamps for
2432 // // device 1 its entities should be cleared and the device should be
2433 // // removed from the store. Device 2 should remain in the store.
2434 // deviceManager.cleanupEntities();
2435 // entries = getEntriesFromStore();
2436 // assertEquals(2, entries.size());
2437 // for (DeviceSyncRepresentation dsr: entries) {
2438 // if (dsr == null) {
2440 // } else if (dsr.getKey().contains("::00:00:00:00:00:02::")) {
2441 // assertEquals(1, dsr.getEntities().size());
2442 // assertEntityEquals(e2, dsr.getEntities().get(0));
2444 // fail("Unknown entry in store: " + dsr);
2450 // private void assertDeviceIps(Integer[] expected, IDevice d) {
2451 // List<Integer> expectedList = Arrays.asList(expected);
2452 // Collections.sort(expectedList);
2453 // List<Integer> actualList = Arrays.asList(d.getIPv4Addresses());
2454 // Collections.sort(actualList);
2455 // assertEquals(expectedList, actualList);
2458 // private IDevice getSingleDeviceFromDeviceManager(long mac) {
2459 // Iterator<? extends IDevice> diter =
2460 // deviceManager.queryDevices(mac, null, null, null, null);
2461 // assertTrue("Query didn't return a device", diter.hasNext());
2462 // IDevice d = diter.next();
2463 // assertFalse("Query returned more than one device", diter.hasNext());
2468 // public void testToMaster() throws Exception {
2469 // int syncStoreWriteIntervalMs = 0;
2470 // int initialSyncStoreConsolidateIntervalMs = 50;
2471 // ITopologyService mockTopology = makeMockTopologyAllPortsAp();
2472 // replay(mockTopology);
2473 // deviceManager.topology = mockTopology;
2474 // // We want an EntityClassifier that has switch/port as key fields
2475 // deviceManager.entityClassifier = new MockEntityClassifier();
2476 // deviceManager.setSyncStoreWriteInterval(syncStoreWriteIntervalMs);
2477 // deviceManager.setInitialSyncStoreConsolidateMs(initialSyncStoreConsolidateIntervalMs);
2479 // // Add Device1 with two entities with two different IPs
2480 // Entity e1a = new Entity(1L, null, 3, 4L, 5, new Date(1000));
2481 // Entity e1b = new Entity(1L, null, 33, 4L, 5, new Date(2000));
2482 // Device d1 = deviceManager.allocateDevice(1L, e1a,
2483 // DefaultEntityClassifier.entityClass);
2484 // d1 = deviceManager.allocateDevice(d1, e1b, -1);
2485 // DeviceSyncRepresentation dsr = new DeviceSyncRepresentation(d1);
2486 // storeClient.put(dsr.getKey(), dsr);
2488 // // Add Device2 with different switch-ports. Only the most recent
2489 // // one should be the attachment point
2490 // Entity e2a = new Entity(2L, null, null, 4L, 4, new Date(1000));
2491 // Entity e2b = new Entity(2L, null, null, 4L, 5, new Date(2000));
2492 // Device d2 = deviceManager.allocateDevice(2L, e2a,
2493 // DefaultEntityClassifier.entityClass);
2494 // d2 = deviceManager.allocateDevice(d2, e2b, -1);
2495 // d2.updateAttachmentPoint(4L, (short)5,
2496 // e2b.getLastSeenTimestamp().getTime());
2497 // SwitchPort swp = new SwitchPort(4L, 5);
2498 // SwitchPort[] aps = d2.getAttachmentPoints();
2500 // assertArrayEquals("Sanity check: should only have AP(4L,5)",
2501 // new SwitchPort[] {swp}, aps);
2502 // dsr = new DeviceSyncRepresentation(d2);
2503 // storeClient.put(dsr.getKey(), dsr);
2505 // // Add a tombstone entry to the store to make sure we don't trip a
2508 // Versioned<DeviceSyncRepresentation> versionedDsr =
2509 // storeClient.get("FooBar");
2510 // storeClient.put("FooBar", versionedDsr);
2512 // deviceManager.getHAListener().transitionToMaster();
2514 // // Query for the Device1. Make sure we have the two IPs we stored.
2515 // IDevice d = getSingleDeviceFromDeviceManager(1L);
2516 // assertDeviceIps(new Integer[] {3, 33}, d);
2517 // assertArrayEquals(new Short[] { Ethernet.VLAN_UNTAGGED }, d.getVlanId());
2518 // swp = new SwitchPort(4L, 5);
2519 // assertArrayEquals(new SwitchPort[] { swp }, d.getAttachmentPoints());
2521 // // Query for Device2. Make sure we only have the more recent AP
2522 // // Query for the Device1. Make sure we have the two IPs we stored.
2523 // d = getSingleDeviceFromDeviceManager(2L);
2524 // assertArrayEquals(new Integer[0], d.getIPv4Addresses());
2525 // assertArrayEquals(new Short[] { Ethernet.VLAN_UNTAGGED }, d.getVlanId());
2526 // swp = new SwitchPort(4L, 5);
2527 // assertArrayEquals(new SwitchPort[] { swp }, d.getAttachmentPoints());
2529 // //----------------------------
2530 // // add another entry device to the store. since device manager is
2531 // // already master we won't read this device and it should be
2532 // // removed from the store by the consolidate task
2533 // Entity e3 = new Entity(3L, null, null, 1L, 1, null);
2534 // dsr = new DeviceSyncRepresentation();
2535 // dsr.setKey("Device3");
2536 // dsr.setEntities(Collections.singletonList(new SyncEntity(e3)));
2537 // storeClient.put(dsr.getKey(), dsr);
2539 // // make sure it's in the store
2540 // List<DeviceSyncRepresentation> entries = getEntriesFromStore();
2541 // boolean found = false;
2542 // for (DeviceSyncRepresentation entry: entries) {
2543 // if (entry!=null && entry.getKey().equals("Device3"))
2546 // assertTrue("Device3 not in store. Entries in store: " + entries, found);
2547 // // make sure it's not in DevManager
2548 // Iterator<? extends IDevice> diter =
2549 // deviceManager.queryDevices(3L, null, null, null, null);
2550 // assertFalse("Device3 found in DeviceManager. Should be there",
2551 // diter.hasNext());
2553 // // Wait for consolidate
2554 // Thread.sleep(initialSyncStoreConsolidateIntervalMs + 5);
2555 // // make sure it's in NOT the store
2556 // entries = getEntriesFromStore();
2558 // for (DeviceSyncRepresentation entry: entries) {
2559 // if (entry!=null && entry.getKey().equals("Device3"))
2562 // assertFalse("Device3 not is still in the store. Entries in store: "
2563 // + entries, found);
2564 // // make sure it's not in DevManager
2565 // diter = deviceManager.queryDevices(3L, null, null, null, null);
2566 // assertFalse("Device3 found in DeviceManager. Should be there",
2567 // diter.hasNext());
2572 // public void testConsolitateStore() throws Exception {
2573 // int syncStoreInternalMs = 0;
2574 // ITopologyService mockTopology = makeMockTopologyAllPortsAp();
2575 // replay(mockTopology);
2576 // deviceManager.topology = mockTopology;
2577 // // We want an EntityClassifier that has switch/port as key fields
2578 // deviceManager.entityClassifier = new MockEntityClassifier();
2579 // deviceManager.setSyncStoreWriteInterval(syncStoreInternalMs);
2581 // // Add Device1 with two entities to store and let device manager
2583 // Entity e1a = new Entity(1L, null, null, 4L, 5, new Date(1000));
2584 // Entity e1b = new Entity(1L, null, 3, 4L, 5, new Date(2000));
2585 // Device d1 = deviceManager.learnDeviceByEntity(e1a);
2586 // deviceManager.learnDeviceByEntity(e1b);
2587 // String dev1Key = DeviceSyncRepresentation.computeKey(d1);
2590 // // Add a second device to the store but do NOT add to device manager
2591 // Entity e2 = new Entity(2L, null, null, 5L, 5, new Date());
2592 // Device d2 = deviceManager.allocateDevice(42L, e2,
2593 // DefaultEntityClassifier.entityClass);
2594 // DeviceSyncRepresentation dsr = new DeviceSyncRepresentation(d2);
2595 // storeClient.put(dsr.getKey(), dsr);
2596 // String dev2Key = DeviceSyncRepresentation.computeKey(d2);
2598 // // Make sure we have two devices in the store
2599 // List<DeviceSyncRepresentation> entries = getEntriesFromStore();
2600 // assertEquals(2, entries.size());
2602 // deviceManager.scheduleConsolidateStoreNow();
2603 // Thread.sleep(25); // give the scheduler time to run the task
2605 // // We should still have two entries, however one of them will be a
2607 // entries = getEntriesFromStore();
2608 // assertEquals(2, entries.size());
2610 // // Device 1 should still be in store
2611 // Versioned<DeviceSyncRepresentation> versioned =
2612 // storeClient.get(dev1Key);
2613 // dsr = versioned.getValue();
2614 // assertNotNull(dsr);
2615 // assertEquals(2, dsr.getEntities().size());
2616 // assertEntityEquals(e1a, dsr.getEntities().get(0));
2617 // assertEntityEquals(e1b, dsr.getEntities().get(1));
2619 // // Device2 should be gone
2620 // versioned = storeClient.get(dev2Key);
2621 // assertNull(versioned.getValue());
2623 // // Run consolitate again. This time we check that tombstones in
2624 // // the store are handled correctly
2625 // deviceManager.scheduleConsolidateStoreNow();
2626 // Thread.sleep(25); // give the scheduler time to run the task
2628 // // Now write a device to the store that doesn't have any switch-port
2629 // // it should be removed
2630 // Entity e3 = new Entity(3L, null, null, null, null, null);
2631 // dsr.setKey("Device3");
2632 // dsr.setEntities(Collections.singletonList(new SyncEntity(e3)));
2633 // storeClient.put(dsr.getKey(), dsr);
2635 // // Run consolitate again. This time we check that tombstones in
2636 // // the store are handled correctly
2637 // deviceManager.scheduleConsolidateStoreNow();
2638 // Thread.sleep(25); // give the scheduler time to run the task
2639 // versioned = storeClient.get("Device3");
2640 // assertNull(versioned.getValue());