Esempio n. 1
0
  @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());
  }
Esempio n. 2
0
  // 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);
  }
Esempio n. 3
0
  @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);
  }
Esempio n. 4
0
  // 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));
  }
Esempio n. 5
0
  // 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());
  }
Esempio n. 6
0
  // 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"));
  }