// test whole node down
@Test
public void testNodeOutageProcessingEnabled() throws Exception {
m_pollerConfig.setNodeOutageProcessingEnabled(true);
MockNode node = m_network.getNode(1);
// start the poller
startDaemons();
resetAnticipated();
anticipateDown(node);
// brind down the node (duh)
node.bringDown();
// make sure the correct events are recieved
verifyAnticipated(10000);
resetAnticipated();
anticipateUp(node);
// bring the node back up
node.bringUp();
// make sure the up events are received
verifyAnticipated(10000);
}
@Test
public void testNodeGainedServiceWhileNodeDownAndServiceUp() {
startDaemons();
MockNode node = m_network.getNode(4);
MockService svc = m_network.getService(4, "192.168.1.6", "SNMP");
anticipateDown(node);
node.bringDown();
verifyAnticipated(5000);
resetAnticipated();
anticipateUp(node);
anticipateDown(svc, true);
MockService newSvc = m_network.addService(4, "192.168.1.6", "SMTP");
m_db.writeService(newSvc);
Event e = MockEventUtil.createNodeGainedServiceEvent("Test", newSvc);
m_eventMgr.sendEventToListeners(e);
sleep(5000);
System.err.println(m_db.getOutages());
verifyAnticipated(8000);
}
// nodeLabelChanged: EventConstants.NODE_LABEL_CHANGED_EVENT_UEI
@Test
public void testNodeLabelChanged() {
MockNode element = m_network.getNode(1);
String newLabel = "NEW LABEL";
Event event = element.createNodeLabelChangedEvent(newLabel);
m_pollerConfig.setNodeOutageProcessingEnabled(false);
PollAnticipator poll = new PollAnticipator();
element.addAnticipator(poll);
poll.anticipateAllServices(element);
startDaemons();
// wait until after the first poll of the services
poll.waitForAnticipated(1000L);
assertEquals("Router", m_poller.getNetwork().getNode(1).getNodeLabel());
// now delete the node and send a nodeDeleted event
element.setLabel(newLabel);
m_eventMgr.sendEventToListeners(event);
assertEquals(newLabel, m_poller.getNetwork().getNode(1).getNodeLabel());
}
@Test
public void testBug709() {
m_pollerConfig.setNodeOutageProcessingEnabled(true);
MockNode node = m_network.getNode(2);
MockService icmpService = m_network.getService(2, "192.168.1.3", "ICMP");
MockService httpService = m_network.getService(2, "192.168.1.3", "HTTP");
// start the poller
startDaemons();
//
// Bring Down the HTTP service and expect nodeLostService Event
//
resetAnticipated();
anticipateDown(httpService);
// bring down the HTTP service
httpService.bringDown();
verifyAnticipated(10000);
//
// Bring Down the ICMP (on the only interface on the node) now expect
// nodeDown
// only.
//
resetAnticipated();
anticipateDown(node);
// bring down the ICMP service
icmpService.bringDown();
// make sure the down events are received
// verifyAnticipated(10000);
sleep(5000);
//
// Bring up both the node and the httpService at the same time. Expect
// both a nodeUp and a nodeRegainedService
//
resetAnticipated();
// the order matters here
anticipateUp(httpService);
anticipateUp(node);
// bring up all the services on the node
node.bringUp();
// make sure the down events are received
verifyAnticipated(10000);
}
@Before
@Override
public void setUp() throws Exception {
super.setUp();
m_notif = m_notificationManager.getNotification("nodeDown");
MockNode node = m_network.getNode(1);
Event nodeDownEvent = node.createDownEvent();
m_params = m_eventProcessor.buildParameterMap(m_notif, nodeDownEvent, 1);
m_commands = new String[] {"email"};
}
private void testSendNodeGainedServices(
int nodeid, String nodeLabel, String ipAddr, String... svcNames) {
assertNotNull(svcNames);
assertTrue(svcNames.length > 0);
MockNode node = m_network.addNode(nodeid, nodeLabel);
m_db.writeNode(node);
MockInterface iface = m_network.addInterface(nodeid, ipAddr);
m_db.writeInterface(iface);
List<MockService> services = new ArrayList<MockService>();
for (String svcName : svcNames) {
MockService svc = m_network.addService(nodeid, ipAddr, svcName);
m_db.writeService(svc);
m_pollerConfig.addService(svc);
services.add(svc);
}
MockVisitor gainSvcSender =
new MockVisitorAdapter() {
public void visitService(MockService svc) {
Event event = MockEventUtil.createNodeGainedServiceEvent("Test", svc);
m_eventMgr.sendEventToListeners(event);
}
};
node.visit(gainSvcSender);
MockService svc1 = services.get(0);
PollAnticipator anticipator = new PollAnticipator();
svc1.addAnticipator(anticipator);
anticipator.anticipateAllServices(svc1);
StringBuffer didNotOccur = new StringBuffer();
for (MockService service : anticipator.waitForAnticipated(10000)) {
didNotOccur.append(service.toString());
}
StringBuffer unanticipatedStuff = new StringBuffer();
for (MockService service : anticipator.unanticipatedPolls()) {
unanticipatedStuff.append(service.toString());
}
assertEquals(unanticipatedStuff.toString(), "", didNotOccur.toString());
anticipateDown(svc1);
svc1.bringDown();
verifyAnticipated(10000);
}
// 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 to see that node lost/regained service events come in
@Test
public void testNodeOutageProcessingDisabled() throws Exception {
m_pollerConfig.setNodeOutageProcessingEnabled(false);
MockNode node = m_network.getNode(1);
startDaemons();
resetAnticipated();
anticipateServicesDown(node);
node.bringDown();
verifyAnticipated(10000);
resetAnticipated();
anticipateServicesUp(node);
node.bringUp();
verifyAnticipated(10000);
}
// 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"));
}