pollablestest.java

opennms得相关源码 请大家看看

//
// This file is part of the OpenNMS(R) Application.
//
// OpenNMS(R) is Copyright (C) 2004-2005 The OpenNMS Group, Inc.  All rights reserved.
// OpenNMS(R) is a derivative work, containing both original code, included code and modified
// code that was published under the GNU General Public License. Copyrights for modified 
// and included code are below.
//
// OpenNMS(R) is a registered trademark of The OpenNMS Group, Inc.
//
// Original code base Copyright (C) 1999-2001 Oculan Corp.  All rights reserved.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// For more information contact:
// OpenNMS Licensing       <[e-mail]>
//     http://www.opennms.org/
//     http://www.opennms.com/
//
package org.opennms.netmgt.poller.pollables;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.Properties;

import junit.framework.TestCase;

import org.opennms.netmgt.EventConstants;
import org.opennms.netmgt.config.DbConnectionFactory;
import org.opennms.netmgt.config.PollOutagesConfig;
import org.opennms.netmgt.config.PollerConfig;
import org.opennms.netmgt.config.poller.Package;
import org.opennms.netmgt.mock.EventAnticipator;
import org.opennms.netmgt.mock.MockDatabase;
import org.opennms.netmgt.mock.MockElement;
import org.opennms.netmgt.mock.MockEventIpcManager;
import org.opennms.netmgt.mock.MockInterface;
import org.opennms.netmgt.mock.MockMonitor;
import org.opennms.netmgt.mock.MockNetwork;
import org.opennms.netmgt.mock.MockNode;
import org.opennms.netmgt.mock.MockPollerConfig;
import org.opennms.netmgt.mock.MockService;
import org.opennms.netmgt.mock.MockUtil;
import org.opennms.netmgt.mock.MockVisitor;
import org.opennms.netmgt.mock.MockVisitorAdapter;
import org.opennms.netmgt.mock.OutageAnticipator;
import org.opennms.netmgt.poller.mock.MockPollContext;
import org.opennms.netmgt.poller.mock.MockScheduler;
import org.opennms.netmgt.poller.mock.MockTimer;
import org.opennms.netmgt.scheduler.Schedule;
import org.opennms.netmgt.scheduler.ScheduleTimer;
import org.opennms.netmgt.utils.Querier;
import org.opennms.netmgt.xml.event.Event;

/**
 * Represents a PollablesTest 
 *
 * @author brozow
 */
public class PollablesTest extends TestCase {

    private PollableNetwork m_network;
    private MockPollContext m_pollContext;
    private MockNetwork m_mockNetwork;
    private MockDatabase m_db;
    private EventAnticipator m_anticipator;
    private MockEventIpcManager m_eventMgr;
    private MockNode mNode1;
    private MockInterface mDot1;
    private MockInterface mDot2;
    private MockNode mNode2;
    private MockService mDot1Smtp;
    private MockService mDot1Icmp;
    private MockService mDot2Smtp;
    private MockService mDot2Icmp;
    private MockInterface mDot3;
    private MockService mDot3Http;
    private MockService mDot3Icmp;
    private PollableNode pNode1;
    private PollableInterface pDot1;
    private PollableService pDot1Smtp;
    private PollableService pDot1Icmp;
    private PollableInterface pDot2;
    private PollableService pDot2Smtp;
    private PollableService pDot2Icmp;
    private PollableNode pNode2;
    private PollableInterface pDot3;
    private PollableService pDot3Http;
    private PollableService pDot3Icmp;
    private OutageAnticipator m_outageAnticipator;
    private MockPollerConfig m_pollerConfig;
    
    private MockScheduler m_scheduler;
    private MockTimer m_timer;
    
    private int m_lockCount = 0;
    

    public static void main(String[] args) {
        junit.textui.TestRunner.run(PollablesTest.class);
    }

    private class MockPollConfig implements PollConfig {
        PollableService m_service;
        MockMonitor m_monitor;
        Properties m_properties = new Properties();
        Package m_package;
        
        public MockPollConfig(MockNetwork network, PollableService service) {
            m_service = service;
            m_monitor = new MockMonitor(network, m_service.getSvcName());
            m_package = new Package();
            m_package.setName("Fake");
        }

        public PollStatus poll() {
            return PollStatus.getPollStatus(m_monitor.poll(m_service.getNetInterface(), m_properties, m_package));
        }
        
        
        public long getCurrentTime() {
            return System.currentTimeMillis();
        }

        public void refresh() {
            // TODO Auto-generated method stub
            
        }
    }
    /*
     * @see TestCase#setUp()
     */
    protected void setUp() throws Exception {
        super.setUp();
        
        MockUtil.println("------------ Begin Test "+getName()+" --------------------------");
        
        MockUtil.setupLogging();
        MockUtil.resetLogLevel();
        
        m_lockCount = 0;
        
        m_mockNetwork = new MockNetwork();
        m_mockNetwork.addNode(1, "Router");
        m_mockNetwork.addInterface("192.168.1.1");
        m_mockNetwork.addService("ICMP");
        m_mockNetwork.addService("SMTP");
        m_mockNetwork.addInterface("192.168.1.2");
        m_mockNetwork.addService("ICMP");
        m_mockNetwork.addService("SMTP");
        m_mockNetwork.addNode(2, "Server");
        m_mockNetwork.addInterface("192.168.1.3");
        m_mockNetwork.addService("ICMP");
        m_mockNetwork.addService("HTTP");
        m_mockNetwork.addNode(3, "Firewall");
        m_mockNetwork.addInterface("192.168.1.4");
        m_mockNetwork.addService("SMTP");
        m_mockNetwork.addService("HTTP");
        m_mockNetwork.addInterface("192.168.1.5");
        m_mockNetwork.addService("SMTP");
        m_mockNetwork.addService("HTTP");

        m_db = new MockDatabase();
        m_db.populate(m_mockNetwork);
        
        
        m_anticipator = new EventAnticipator();
        m_outageAnticipator = new OutageAnticipator(m_db);

        
        m_eventMgr = new MockEventIpcManager();
        m_eventMgr.setEventWriter(m_db);
        m_eventMgr.setEventAnticipator(m_anticipator);
        m_eventMgr.addEventListener(m_outageAnticipator);
        
        m_pollContext = new MockPollContext();
        m_pollContext.setDatabase(m_db);
        m_pollContext.setCriticalServiceName("ICMP");
        m_pollContext.setNodeProcessingEnabled(true);
        m_pollContext.setPollingAllIfCritServiceUndefined(true);
        m_pollContext.setServiceUnresponsiveEnabled(true);
        m_pollContext.setEventMgr(m_eventMgr);
        m_pollContext.setMockNetwork(m_mockNetwork);
        
        m_pollerConfig = new MockPollerConfig();
        m_pollerConfig.setNodeOutageProcessingEnabled(true);
        m_pollerConfig.setCriticalService("ICMP");
        m_pollerConfig.addPackage("TestPackage");
        m_pollerConfig.addDowntime(100L, 0L, 500L, false);
        m_pollerConfig.addDowntime(200L, 500L, 1500L, false);
        m_pollerConfig.addDowntime(500L, 1500L, -1L, true);
        m_pollerConfig.setDefaultPollInterval(1000L);
        m_pollerConfig.populatePackage(m_mockNetwork);
        m_pollerConfig.addPackage("TestPkg2");
        m_pollerConfig.addDowntime(500L, 0L, 1000L, false);
        m_pollerConfig.addDowntime(500L, 1000L, -1L, true);
        m_pollerConfig.setDefaultPollInterval(2000L);
        m_pollerConfig.addService(m_mockNetwork.getService(2, "192.168.1.3", "HTTP"));
        
        m_timer = new MockTimer();
        m_scheduler = new MockScheduler(m_timer);
        m_network = createPollableNetwork(m_db, m_scheduler, m_pollerConfig, m_pollerConfig, m_pollContext);
        
        // set members to make the tests easier
        
        mNode1 = m_mockNetwork.getNode(1);
        mDot1 = mNode1.getInterface("192.168.1.1");
        mDot1Smtp = mDot1.getService("SMTP");
        mDot1Icmp = mDot1.getService("ICMP");
        mDot2 = mNode1.getInterface("192.168.1.2");
        mDot2Smtp = mDot2.getService("SMTP");
        mDot2Icmp = mDot2.getService("ICMP");
        
        mNode2 = m_mockNetwork.getNode(2);
        mDot3 = mNode2.getInterface("192.168.1.3");
        mDot3Http = mDot3.getService("HTTP");
        mDot3Icmp = mDot3.getService("ICMP");
        
        assignPollableMembers(m_network);
        
    }

    private void assignPollableMembers(PollableNetwork pNetwork) throws UnknownHostException {
        pNode1 = pNetwork.getNode(1);
        pDot1 = pNode1.getInterface(InetAddress.getByName("192.168.1.1"));
        pDot1Smtp = pDot1.getService("SMTP");
        pDot1Icmp = pDot1.getService("ICMP");
        pDot2 = pNode1.getInterface(InetAddress.getByName("192.168.1.2"));
        pDot2Smtp = pDot2.getService("SMTP");
        pDot2Icmp = pDot2.getService("ICMP");
        
        pNode2 = pNetwork.getNode(2);
        pDot3 = pNode2.getInterface(InetAddress.getByName("192.168.1.3"));
        pDot3Http = pDot3.getService("HTTP");
        pDot3Icmp = pDot3.getService("ICMP");
    }
    
    static class InitCause extends PollableVisitorAdaptor {
        private PollEvent m_cause;

        public void setCause(PollEvent cause) {
            m_cause = cause;
        }
        
        public void visitElement(PollableElement element) {
            if (!element.hasOpenOutage())
                element.setCause(m_cause);
        }
    }

    static private PollableNetwork createPollableNetwork(final DbConnectionFactory db, final ScheduleTimer scheduler, final PollerConfig pollerConfig, final PollOutagesConfig pollOutageConfig, PollContext pollContext) throws UnknownHostException {
        
        final PollableNetwork pNetwork = new PollableNetwork(pollContext);
        
        String sql = "select ifServices.nodeId as nodeId, ifServices.ipAddr as ipAddr, ifServices.serviceId as serviceId, service.serviceName as serviceName, outages.svcLostEventId as svcLostEventId, events.eventUei as svcLostEventUei, outages.ifLostService as ifLostService, outages.ifRegainedService as ifRegainedService " +
                "from ifServices " +
                "join service on ifServices.serviceId = service.serviceId " +
                "left outer join outages on " +
                "ifServices.nodeId = outages.nodeId and " +
                "ifServices.ipAddr = outages.ipAddr and " +
                "ifServices.serviceId = outages.serviceId and " +
                "ifRegainedService is null " +
                "left outer join events on outages.svcLostEventId = events.eventid " +
                "where ifServices.status = 'A'";

        final InitCause causeSetter = new InitCause();
        
        Querier querier = new Querier(db, sql) {
            public void processRow(ResultSet rs) throws SQLException {
                int nodeId = rs.getInt("nodeId");
                String ipAddr = rs.getString("ipAddr");
                String serviceName = rs.getString("serviceName");
                Package pkg = findPackageForService(ipAddr, serviceName);
                if (pkg == null) {
                    MockUtil.println("No package for service "+serviceName+" with ipAddr "+ipAddr);
                    return;
                }
                
                try {
                    
                    PollableService svc = pNetwork.createService(nodeId, InetAddress.getByName(ipAddr), serviceName);
                    PollableServiceConfig pollConfig = new PollableServiceConfig(svc, pollerConfig, pollOutageConfig, pkg, scheduler);
                    svc.setPollConfig(pollConfig);
                    synchronized (svc) {
                        if (svc.getSchedule() == null) {
                            Schedule schedule = new Schedule(svc, pollConfig, scheduler);
                            svc.setSchedule(schedule);
                        }
                    }

                    Number svcLostEventId = (Number)rs.getObject("svcLostEventId");
                    //MockUtil.println("svcLostEventId for "+svc+" is "+svcLostEventId);
                    if (svcLostEventId == null) 
                        svc.updateStatus(PollStatus.STATUS_UP);
                    else {
                        svc.updateStatus(PollStatus.STATUS_DOWN);
                    
                        Date date = rs.getTimestamp("ifLostService");
                        PollEvent cause = new DbPollEvent(svcLostEventId.intValue(), date);
                        String svcLostUei = rs.getString("svcLostEventUei");
                        causeSetter.setCause(cause);

                        if (EventConstants.NODE_LOST_SERVICE_EVENT_UEI.equals(svcLostUei)) {
                            svc.visit(causeSetter);
                        } else if (EventConstants.INTERFACE_DOWN_EVENT_UEI.equals(svcLostUei)) {
                            svc.getInterface().visit(causeSetter);
                        } else if (EventConstants.NODE_DOWN_EVENT_UEI.equals(svcLostUei)) {
                            svc.getNode().visit(causeSetter);
                        }
                    }
                    
                    // schedule.schedule();
                    //MockUtil.println("Created Pollable Service "+svc+" with package "+pkg.getName());
                } catch (UnknownHostException e) {
                    // in 'real life' I would just log this and contine with the others
                    throw new RuntimeException("Error converting "+ipAddr+" to an InetAddress", e);
                }
            }
            private Package findPackageForService(String ipAddr, String serviceName) {
                Enumeration en = pollerConfig.enumeratePackage();
                Package lastPkg = null;
                while (en.hasMoreElements()) {
                    Package pkg = (Package)en.nextElement();
                    if (pollableServiceInPackage(ipAddr, serviceName, pkg))
                        lastPkg = pkg;
                }
                return lastPkg;
                
            }
            private boolean pollableServiceInPackage(String ipAddr, String serviceName, Package pkg) {
                return (pollerConfig.serviceInPackageAndEnabled(serviceName, pkg)
                        && pollerConfig.interfaceInPackage(ipAddr, pkg));
            }


        };
        querier.execute();

        pNetwork.recalculateStatus();
        pNetwork.resetStatusChanged();
        return pNetwork;
    }

    /*
     * @see TestCase#tearDown()
     */
    protected void tearDown() throws Exception {
        super.tearDown();
        m_eventMgr.finishProcessingEvents();
        assertTrue("Unexpected WARN or ERROR msgs in Log!", MockUtil.noWarningsOrHigherLogged());
        m_db.drop();
    }
    
    public void testCreateNode() {
        int nodeId = 99;
        PollableNode node = m_network.createNode(nodeId);
        assertNotNull("node is null", node);

        assertEquals(99, node.getNodeId());
        assertEquals(node, m_network.getNode(nodeId));
        
        assertEquals(m_network, node.getNetwork());
    }
    
    public void testCreateInterface() throws UnknownHostException {
        int nodeId = 99;
        InetAddress addr = InetAddress.getByName("192.168.1.99");

        PollableInterface iface = m_network.createInterface(nodeId, addr);
        assertNotNull("iface is null", iface);
        assertEquals(addr, iface.getAddress());
        assertEquals(nodeId, iface.getNodeId());
        assertEquals(iface, m_network.getInterface(nodeId, addr));

        PollableNode node = iface.getNode();
        assertNotNull("node is null", node);
        assertEquals(nodeId, node.getNodeId());
        assertEquals(node, m_network.getNode(nodeId));
        
        assertEquals(m_network, iface.getNetwork());
    }
    
    public void testCreateService() throws Exception {
        int nodeId = 99;
        InetAddress addr = InetAddress.getByName("192.168.1.99");
        String svcName = "HTTP-99";
        
        PollableService svc = m_network.createService(nodeId, addr, svcName);
        assertNotNull("svc is null", svc);
        assertEquals(svcName, svc.getSvcName());
        assertEquals(addr, svc.getAddress());
        assertEquals(nodeId, svc.getNodeId());
        assertEquals(svc, m_network.getService(nodeId, addr, svcName));
        
        PollableInterface iface = svc.getInterface();
        assertNotNull("iface is null", iface);
        assertEquals(addr, iface.getAddress());
        assertEquals(nodeId, iface.getNodeId());
        assertEquals(iface, m_network.getInterface(nodeId, addr));
        
        PollableNode node = svc.getNode();
        assertNotNull("node is null", node);
        assertEquals(nodeId, node.getNodeId());
        assertEquals(node, m_network.getNode(nodeId));
        
        assertEquals(m_network, svc.getNetwork());
        
    }
    
    public void testVisit() {
        class Counter extends PollableVisitorAdaptor {
            public int svcCount;
            public int ifCount;
            public int nodeCount;
            public int elementCount;
            public int containerCount;