@Test
public void testPolling() throws Exception {
m_pollerConfig.setNodeOutageProcessingEnabled(false);
// create a poll anticipator
PollAnticipator anticipator = new PollAnticipator();
// register it with the interfaces services
MockInterface iface = m_network.getInterface(1, "192.168.1.2");
iface.addAnticipator(anticipator);
//
// first ensure that polls are working while it is up
//
// anticipate three polls on all the interfaces services
anticipator.anticipateAllServices(iface);
anticipator.anticipateAllServices(iface);
anticipator.anticipateAllServices(iface);
// start the poller
startDaemons();
// wait for the polls to occur while its up... 1 poll per second plus
// overhead
assertEquals(0, anticipator.waitForAnticipated(4500L).size());
}
// test open outages for unmanaged services
@Test
public void testReparentCausesStatusChange() {
m_pollerConfig.setNodeOutageProcessingEnabled(true);
MockNode node1 = m_network.getNode(1);
MockNode node2 = m_network.getNode(2);
MockInterface dotOne = m_network.getInterface(1, "192.168.1.1");
MockInterface dotTwo = m_network.getInterface(1, "192.168.1.2");
MockInterface dotThree = m_network.getInterface(2, "192.168.1.3");
//
// Plan to bring down both nodes except the reparented interface
// the node owning the interface should be up while the other is down
// after reparenting we should got the old owner go down while the other
// comes up.
//
anticipateDown(node2);
anticipateDown(dotOne);
// bring down both nodes but bring iface back up
node1.bringDown();
node2.bringDown();
dotTwo.bringUp();
Event reparentEvent = MockEventUtil.createReparentEvent("Test", "192.168.1.2", 1, 2);
startDaemons();
verifyAnticipated(2000);
m_db.reparentInterface(dotTwo.getIpAddr(), dotTwo.getNodeId(), node2.getNodeId());
dotTwo.moveTo(node2);
resetAnticipated();
anticipateDown(node1, true);
anticipateUp(node2, true);
anticipateDown(dotThree, true);
m_eventMgr.sendEventToListeners(reparentEvent);
verifyAnticipated(20000);
}
@Test
public void testInterfaceWithNoCriticalService() {
m_pollerConfig.setNodeOutageProcessingEnabled(true);
MockInterface iface = m_network.getInterface(3, "192.168.1.4");
MockService svc = iface.getService("SMTP");
MockService otherService = iface.getService("HTTP");
startDaemons();
anticipateDown(iface);
iface.bringDown();
verifyAnticipated(8000);
anticipateUp(iface);
anticipateDown(otherService, true);
svc.bringUp();
verifyAnticipated(8000);
}
// test open outages for unmanaged services
@Test
public void testUnmangedWithOpenOutageAtStartup() {
// before we start we need to initialize the database
// create an outage for the service
MockService svc = m_network.getService(1, "192.168.1.1", "SMTP");
MockInterface iface = m_network.getInterface(1, "192.168.1.2");
Event svcLostEvent = MockEventUtil.createNodeLostServiceEvent("Test", svc);
m_db.writeEvent(svcLostEvent);
createOutages(svc, svcLostEvent);
Event ifaceDownEvent = MockEventUtil.createInterfaceDownEvent("Test", iface);
m_db.writeEvent(ifaceDownEvent);
createOutages(iface, ifaceDownEvent);
// mark the service as unmanaged
m_db.setServiceStatus(svc, 'U');
m_db.setInterfaceStatus(iface, 'U');
// assert that we have an open outage
assertEquals(1, m_db.countOpenOutagesForService(svc));
assertEquals(1, m_db.countOutagesForService(svc));
assertEquals(iface.getServices().size(), m_db.countOutagesForInterface(iface));
assertEquals(iface.getServices().size(), m_db.countOpenOutagesForInterface(iface));
startDaemons();
// assert that we have no open outages
assertEquals(0, m_db.countOpenOutagesForService(svc));
assertEquals(1, m_db.countOutagesForService(svc));
assertEquals(0, m_db.countOpenOutagesForInterface(iface));
assertEquals(iface.getServices().size(), m_db.countOutagesForInterface(iface));
}
// what about scheduled outages?
@Test
public void testDontPollDuringScheduledOutages() {
long start = System.currentTimeMillis();
MockInterface iface = m_network.getInterface(1, "192.168.1.2");
m_pollerConfig.addScheduledOutage(
m_pollerConfig.getPackage("TestPackage"),
"TestOutage",
start,
start + 5000,
iface.getIpAddr());
MockUtil.println("Begin Outage");
startDaemons();
long now = System.currentTimeMillis();
sleep(3000 - (now - start));
MockUtil.println("End Outage");
assertEquals(0, iface.getPollCount());
sleep(5000);
assertTrue(0 < iface.getPollCount());
}
// interfaceReparented: EventConstants.INTERFACE_REPARENTED_EVENT_UEI
@Test
public void testInterfaceReparented() throws Exception {
m_assertLevel = null;
m_pollerConfig.setNodeOutageProcessingEnabled(true);
MockNode node1 = m_network.getNode(1);
MockNode node2 = m_network.getNode(2);
assertNotNull("Node 1 should have 192.168.1.1", node1.getInterface("192.168.1.1"));
assertNotNull("Node 1 should have 192.168.1.2", node1.getInterface("192.168.1.2"));
assertNull("Node 2 should not yet have 192.168.1.2", node2.getInterface("192.168.1.2"));
assertNotNull("Node 2 should have 192.168.1.3", node2.getInterface("192.168.1.3"));
MockInterface dotTwo = m_network.getInterface(1, "192.168.1.2");
MockInterface dotThree = m_network.getInterface(2, "192.168.1.3");
Event reparentEvent = MockEventUtil.createReparentEvent("Test", "192.168.1.2", 1, 2);
// we are going to reparent to node 2 so when we bring down its only
// current interface we expect an interface down not the whole node.
anticipateDown(dotThree);
startDaemons();
final int waitTime = 2000;
final int verifyTime = 2000;
sleep(waitTime);
// move the reparented interface and send a reparented event
dotTwo.moveTo(node2);
m_db.reparentInterface(dotTwo.getIpAddr(), node1.getNodeId(), node2.getNodeId());
// send the reparent event to the daemons
m_eventMgr.sendEventToListeners(reparentEvent);
sleep(waitTime);
// now bring down the other interface on the new node
// System.err.println("Bring Down:"+node2Iface);
dotThree.bringDown();
verifyAnticipated(verifyTime);
resetAnticipated();
anticipateDown(node2);
// System.err.println("Bring Down:"+reparentedIface);
dotTwo.bringDown();
sleep(waitTime);
verifyAnticipated(verifyTime);
node1 = m_network.getNode(1);
node2 = m_network.getNode(2);
assertNotNull("Node 1 should still have 192.168.1.1", node1.getInterface("192.168.1.1"));
assertNull("Node 1 should no longer have 192.168.1.2", node1.getInterface("192.168.1.2"));
assertNotNull("Node 2 should now have 192.168.1.2", node2.getInterface("192.168.1.2"));
assertNotNull("Node 2 should still have 192.168.1.3", node2.getInterface("192.168.1.3"));
}