pollablestest.java

opennms得相关源码 请大家看看

            public int networkCount;
            public void visitService(PollableService s) {
                svcCount++;
            }
            public void visitInterface(PollableInterface iface) {
                ifCount++;
            }
            public void visitNode(PollableNode node) {
                nodeCount++;
            }
            public void visitElement(PollableElement element) {
                elementCount++;
            }
            public void visitContainer(PollableContainer container) {
                containerCount++;
            }
            public void visitNetwork(PollableNetwork n) {
                networkCount++;
            }
        };
        Counter counter = new Counter();
        m_network.visit(counter);
        assertEquals(10, counter.svcCount);
        assertEquals(5, counter.ifCount);
        assertEquals(3, counter.nodeCount);
        assertEquals(1, counter.networkCount);
        assertEquals(19, counter.elementCount);
        assertEquals(9, counter.containerCount);
    }
    
    public void testDeleteService() {

        pDot1Icmp.delete();
        
        assertDeleted(pDot1Icmp);
        assertNotDeleted(pDot1);
        assertNotDeleted(pNode1);
        
        pDot1Smtp.delete();
        
        assertDeleted(pDot1Smtp);
        assertDeleted(pDot1);
        assertNotDeleted(pNode1);
        
        pDot2Smtp.delete();
        
        assertDeleted(pDot2Smtp);
        assertNotDeleted(pDot2);
        assertNotDeleted(pNode1);
        
        pDot2Icmp.delete();
        
        assertDeleted(pDot2Icmp);
        assertDeleted(pDot2);
        assertDeleted(pNode1);
        
    }
    
    private void assertDeleted(PollableService svc) {
        assertTrue(svc.isDeleted());
        assertNull(m_network.getService(svc.getNodeId(), svc.getAddress(), svc.getSvcName()));
    }

    private void assertNotDeleted(PollableService svc) {
        assertFalse(svc.isDeleted());
        assertNotNull(m_network.getService(svc.getNodeId(), svc.getAddress(), svc.getSvcName()));
    }

    private void assertDeleted(PollableInterface iface) {
        assertTrue(iface.isDeleted());
        assertNull(m_network.getInterface(iface.getNodeId(), iface.getAddress()));
    }

    private void assertNotDeleted(PollableInterface iface) {
        assertFalse(iface.isDeleted());
        assertNotNull(m_network.getInterface(iface.getNodeId(), iface.getAddress()));
    }

    private void assertDeleted(PollableNode node) {
        assertTrue(node.isDeleted());
        assertNull(m_network.getNode(node.getNodeId()));
    }

    private void assertNotDeleted(PollableNode node) {
        assertFalse(node.isDeleted());
        assertNotNull(m_network.getNode(node.getNodeId()));
    }

    public void testDeleteInterface() throws Exception {
        
        pDot1.delete();
        
        assertDeleted(pDot1Icmp);
        assertDeleted(pDot1Smtp);
        assertDeleted(pDot1);
        assertNotDeleted(pDot2);
        assertNotDeleted(pNode1);
        
        pDot2.delete();
        
        assertDeleted(pDot2Icmp);
        assertDeleted(pDot2Smtp);
        assertDeleted(pDot2);;
        assertDeleted(pNode1);
        
    }
    
    public void testDeleteNode() throws Exception {
        InetAddress dot1 = InetAddress.getByName("192.168.1.1");
        InetAddress dot2 = InetAddress.getByName("192.168.1.2");
        
        pNode1.delete();
        
        assertDeleted(pDot1Icmp);
        assertDeleted(pDot1Smtp);
        assertDeleted(pDot1);
        assertDeleted(pDot2Icmp);
        assertDeleted(pDot2Smtp);
        assertDeleted(pDot2);
        assertDeleted(pNode1);
    }
    
    public void testDeleteServiceStatus() {
        anticipateDown(mDot1);

        mDot1Icmp.bringDown();
        
        pDot1Icmp.doPoll();
        
        m_network.processStatusChange(new Date());
        
        verifyAnticipated();
        
        mDot1.removeService(mDot1Icmp);
        
        anticipateUp(mDot1);
        
        pDot1Icmp.delete();
        
        m_network.processStatusChange(new Date());
        
        verifyAnticipated();
        
        
        
    }
    
    public void testDowntimeDelete() {
        pDot3Http.getSchedule().schedule();
        
        m_scheduler.next();
        
        assertTime(0);
        assertNotDeleted(pDot3Http);
        
        m_scheduler.next();
        
        assertTime(2000);
        assertNotDeleted(pDot3Http);
        
        anticipateDown(mDot3Http);
        
        mDot3Http.bringDown();
        
        m_scheduler.next();
        
        assertTime(4000);
        assertNotDeleted(pDot3Http);
        
        verifyAnticipated();
        
        m_scheduler.next();
        
        assertTime(4500);
        assertNotDeleted(pDot3Http);
        
        m_anticipator.anticipateEvent(MockUtil.createServiceEvent("Test", EventConstants.DELETE_SERVICE_EVENT_UEI, mDot3Http));
        
        m_scheduler.next();
        
        assertTime(5000);
        
        verifyAnticipated();
        
        
    }
    
    public void testReparentInterface()  {
        InetAddress address = pDot1.getAddress();
        pDot1.reparentTo(pNode2);
        
        assertNull(m_network.getInterface(1, address));
        assertNotNull(m_network.getInterface(2, address));
        assertEquals(2, pDot1.getNodeId());
        assertSame(pNode2, pDot1.getNode());
    }
    
    public void testReparentOutages() {
        // create some outages in the database
        mDot1.bringDown();
        
        pDot1Icmp.doPoll();
        pNode1.processStatusChange(new Date());
        
        mDot1.bringUp();
        
        pDot1Icmp.doPoll();
        pNode1.processStatusChange(new Date());
        
        final String ifOutageOnNode1 = "select * from outages where nodeId = 1 and ipAddr = '192.168.1.1'";
        final String ifOutageOnNode2 = "select * from outages where nodeId = 2 and ipAddr = '192.168.1.1'";
        
        m_eventMgr.finishProcessingEvents();

        assertEquals(2, m_db.countRows(ifOutageOnNode1));
        assertEquals(0, m_db.countRows(ifOutageOnNode2));
        
        pDot1.reparentTo(pNode2);
        
        assertEquals(0, m_db.countRows(ifOutageOnNode1));
        assertEquals(2, m_db.countRows(ifOutageOnNode2));

    }
    
    public void testReparentStatusChanges() {
        

        //
        // 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(mNode2);
        anticipateDown(mDot1);

        // bring down both nodes but bring iface back up
        mNode1.bringDown();
        mNode2.bringDown();
        mDot2.bringUp();

        Date d = new Date();
        pDot1Icmp.doPoll();
        m_network.processStatusChange(new Date());
        pDot2Icmp.doPoll();
        m_network.processStatusChange(new Date());
        pDot3Icmp.doPoll();
        m_network.processStatusChange(new Date());
        
        verifyAnticipated();

        m_db.reparentInterface(mDot2.getIpAddr(), mDot2.getNodeId(), mNode2.getNodeId());
        mDot2.moveTo(mNode2);

        resetAnticipated();
        anticipateDown(mNode1);
        anticipateUp(mNode2);
        anticipateDown(mDot3);

        pDot2.reparentTo(pNode2);
        
        verifyAnticipated();

    }
    
    public void testStatus() throws Exception {
        PollableVisitor updater = new PollableVisitorAdaptor() {
            public void visitElement(PollableElement e) {
                e.updateStatus(PollStatus.STATUS_DOWN);
            }
        };
        m_network.visit(updater);
        PollableVisitor downChecker = new PollableVisitorAdaptor() {
            public void visitElement(PollableElement e) {
                assertEquals(PollStatus.STATUS_DOWN, e.getStatus());
                assertEquals(true, e.isStatusChanged());
            }
        };
        m_network.visit(downChecker);
        m_network.resetStatusChanged();
        PollableVisitor statusChangedChecker = new PollableVisitorAdaptor() {
            public void visitElement(PollableElement e) {
                assertEquals(false, e.isStatusChanged());
            }
        };
        m_network.visit(statusChangedChecker);
        
        pDot1Icmp.updateStatus(PollStatus.STATUS_UP);
        m_network.recalculateStatus();
        
        PollableVisitor upChecker = new PollableVisitorAdaptor() {
            public void visitNode(PollableNode node) {
                if (node == pDot1Icmp.getNode())
                    assertUp(node);
                else
                    assertDown(node);
            }
            public void visitInterface(PollableInterface iface) {
                if (iface == pDot1Icmp.getInterface())
                    assertUp(iface);
                else
                    assertDown(iface);
            }
            public void visitService(PollableService s) {
                if (s == pDot1Icmp)
                    assertUp(s);
                else
                    assertDown(s);
            }
        };
        m_network.visit(upChecker);
    }
    
    public void testInterfaceStatus() throws Exception {
        
        
        pDot2Smtp.updateStatus(PollStatus.STATUS_DOWN);
        m_network.recalculateStatus();
        
        assertDown(pDot2Smtp);
        assertUp(pDot2Smtp.getInterface());
        
        pDot2Smtp.updateStatus(PollStatus.STATUS_UP);
        m_network.recalculateStatus();
        
        assertUp(pDot2Smtp);
        assertUp(pDot2Smtp.getInterface());
        
        pDot2Icmp.updateStatus(PollStatus.STATUS_DOWN);
        m_network.recalculateStatus();
        
        assertDown(pDot2Icmp);
        assertDown(pDot2Icmp.getInterface());
        
    }

    public void testFindMemberWithDescendent() throws Exception {

        assertSame(pNode1, m_network.findMemberWithDescendent(pDot1Icmp));
        assertSame(pDot1, pNode1.findMemberWithDescendent(pDot1Icmp));
        assertSame(pDot1Icmp, pDot1.findMemberWithDescendent(pDot1Icmp));
        
        // pDot1Icmp is not a descendent of pNode2
        assertNull(pNode2.findMemberWithDescendent(pDot1Icmp));
        
        
    }
    

    public void testPropagateUnresponsive() throws Exception {

        pDot1Smtp.updateStatus(PollStatus.STATUS_UNRESPONSIVE);
        pDot1Icmp.updateStatus(PollStatus.STATUS_UNRESPONSIVE);
        m_network.recalculateStatus();
        
        assertUp(pDot1);
        
    }
    
    public void testPollUnresponsive() {
        m_pollContext.setServiceUnresponsiveEnabled(true);
        
        anticipateUnresponsive(mDot1);
        
        mDot1.bringUnresponsive();
            
        pDot1Smtp.doPoll();
        
        m_network.processStatusChange(new Date());
        
        pDot1Icmp.doPoll();
        
        m_network.processStatusChange(new Date());

        assertUp(pDot1);
        verifyAnticipated();
        
        anticipateResponsive(mDot1);
        
        mDot1.bringUp();
        
        pDot1Smtp.doPoll();
        
        m_network.processStatusChange(new Date());
        
        pDot1Icmp.doPoll();
        
        m_network.processStatusChange(new Date());

        assertUp(pDot1);
        verifyAnticipated();
        
    }
    
    public void testPollUnresponsiveWithOutage() {
        m_pollContext.setServiceUnresponsiveEnabled(true);
        
        anticipateUnresponsive(mDot1);
        
        mDot1.bringUnresponsive();
            
        pDot1Smtp.doPoll();
        
        m_network.processStatusChange(new Date());
        
        pDot1Icmp.doPoll();
        
        m_network.processStatusChange(new Date());

        assertUp(pDot1);
        verifyAnticipated();
        
        anticipateDown(mDot1);
        
        mDot1.bringDown();
        
        pDot1Smtp.doPoll();
        
        m_network.processStatusChange(new Date());
        
        verifyAnticipated();
        
        anticipateUp(mDot1);
        
        mDot1.bringUp();
        
        pDot1Icmp.doPoll();
        
        m_network.processStatusChange(new Date());
        
        verifyAnticipated();
        
        anticipateUnresponsive(mDot1);