poller.java

opennms得相关源码 请大家看看

    private void scheduleExistingServices() throws Exception {
        Category log = ThreadCategory.getInstance(getClass());
        
        int count = scheduleMatchingServices(null);
        
        m_network.recalculateStatus();
        m_network.resetStatusChanged();
        
        // Debug dump pollable network
        //
        if (log.isDebugEnabled()) {
            log.debug("scheduleExistingServices: dumping content of pollable network: ");
            m_network.dump();
        }
        

    }
    
    public void scheduleService(final int nodeId, final String ipAddr, final String svcName) {
        final Category log = ThreadCategory.getInstance(getClass());
        try {
            PollableNode node;
            synchronized (m_network) {
                node = m_network.getNode(nodeId);
                if (node == null) {
                    node = m_network.createNode(nodeId);
                }
            }

            final PollableNode svcNode = node;
            Runnable r = new Runnable() {
                public void run() {
                    int matchCount = scheduleMatchingServices("ifServices.nodeId = "+nodeId+" AND ifServices.ipAddr = '"+ipAddr+"' AND service.serviceName = '"+svcName+"'");
                    if (matchCount > 0) {
                        svcNode.recalculateStatus();
                        svcNode.resetStatusChanged();
                    } else {
                        log.warn("Attempt to schedule service "+nodeId+"/"+ipAddr+"/"+svcName+" found no active service");
                    }
                }
            };
            node.withTreeLock(r);

        } catch (Exception e) {
            log.error("Unable to schedule service "+nodeId+"/"+ipAddr+"/"+svcName, e);
        }
    }
    
    private int scheduleMatchingServices(String criteria) {
        final Category log = ThreadCategory.getInstance();
        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'" +
        (criteria == null ? "" : " AND "+criteria);
       
        
        
        Querier querier = new Querier(m_dbConnectionFactory, sql) {
            public void processRow(ResultSet rs) throws SQLException {
                scheduleService(rs.getInt("nodeId"), rs.getString("ipAddr"), rs.getString("serviceName"), 
                                (Number)rs.getObject("svcLostEventId"), rs.getTimestamp("ifLostService"), 
                                rs.getString("svcLostEventUei"));
            }
        };
        querier.execute();
        
        
        return querier.getCount();

    }

    private void scheduleService(int nodeId, String ipAddr, String serviceName, Number svcLostEventId, Date date, String svcLostUei) {
        Category log = ThreadCategory.getInstance();

        Package pkg = findPackageForService(ipAddr, serviceName);
        if (pkg == null) {
            log.warn("Active service "+serviceName+" on "+ipAddr+" not configured for any package");
            return;
        }
        
        ServiceMonitor monitor = m_pollerConfig.getServiceMonitor(serviceName);
        if (monitor == null) {
            log.info("Could not find service monitor associated with service "+serviceName);
            return;
        }
        
        InetAddress addr;
        try {
            addr = InetAddress.getByName(ipAddr);
        } catch (UnknownHostException e) {
            log.error("Could not convert "+ipAddr+" as an InetAddress "+ipAddr);
            return;
        }
        
        PollableService svc = m_network.createService(nodeId, addr, serviceName);
        PollableServiceConfig pollConfig = new PollableServiceConfig(svc, m_pollerConfig, m_pollOutagesConfig, pkg, m_scheduler);
        svc.setPollConfig(pollConfig);
        synchronized(svc) {
            if (svc.getSchedule() == null) {
                Schedule schedule = new Schedule(svc, pollConfig, m_scheduler);
                svc.setSchedule(schedule);
            }
        }
        
        
        if (svcLostEventId == null) 
            svc.updateStatus(PollStatus.STATUS_UP);
        else {
            svc.updateStatus(PollStatus.STATUS_DOWN);
            
            InitCause causeSetter = new InitCause();
            PollEvent cause = new DbPollEvent(svcLostEventId.intValue(), date);
            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);
            }
        }
        
        svc.schedule();

    }

    private Package findPackageForService(String ipAddr, String serviceName) {
        Enumeration en = m_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) {
        if (!m_pollerConfig.serviceInPackageAndEnabled(serviceName, pkg)) return false;
        
        boolean inPkg = m_pollerConfig.interfaceInPackage(ipAddr, pkg);
        if (inPkg) return true;
        
        if (m_initialized) {
            m_pollerConfig.rebuildPackageIpListMap();
            return m_pollerConfig.interfaceInPackage(ipAddr, pkg);
        }
        
        return false;
    }
    
    public boolean packageIncludesIfAndSvc(Package pkg, String ipAddr, String svcName) {
        Category log = ThreadCategory.getInstance();

        if (!getPollerConfig().serviceInPackageAndEnabled(svcName, pkg)) {
            if (log.isDebugEnabled())
                log.debug("packageIncludesIfAndSvc: address/service: " + ipAddr + "/" + svcName + " not scheduled, service is not enabled or does not exist in package: " + pkg.getName());
            return false;
        }

        // Is the interface in the package?
        //
        if (!getPollerConfig().interfaceInPackage(ipAddr, pkg)) {

            if (m_initialized) {
                getPollerConfig().rebuildPackageIpListMap();
                if (!getPollerConfig().interfaceInPackage(ipAddr, pkg)) {
                    if (log.isDebugEnabled())
                        log.debug("packageIncludesIfAndSvc: interface " + ipAddr + " gained service " + svcName + ", but the interface was not in package: " + pkg.getName());
                    return false;
                }
            } else {
                if (log.isDebugEnabled())
                    log.debug("packageIncludesIfAndSvc: address/service: " + ipAddr + "/" + svcName + " not scheduled, interface does not belong to package: " + pkg.getName());
                return false;
            }
        }
        return true;
    }

    /**
     * @return
     */
    PollerConfig getPollerConfig() {
        return m_pollerConfig;
    }

    /**
     * @param instance
     */
    public void setPollerConfig(PollerConfig pollerConfig) {
        m_pollerConfig = pollerConfig;
    }

    PollOutagesConfig getPollOutagesConfig() {
        return m_pollOutagesConfig;
    }

    public void setPollOutagesConfig(PollOutagesConfig pollOutagesConfig) {
        m_pollOutagesConfig = pollOutagesConfig;
    }

    public EventIpcManager getEventManager() {
        return m_eventMgr;
    }

    public void setEventManager(EventIpcManager eventMgr) {
        m_eventMgr = eventMgr;
    }

    /**
     * @return Returns the m_svcMonitors.
     */
    private Map getServiceMonitors() {
        return getPollerConfig().getServiceMonitors();
    }

    int getServiceIdByName(String svcName) {
        Integer id = (Integer) m_svcNameToId.get(svcName);
        return (id == null ? -1 : id.intValue());
    }

    String getServiceNameById(int svcId) {
        return (String) m_svcIdToName.get(new Integer(svcId));
    }

    /**
     * @param queryMgr
     *            The queryMgr to set.
     */
    void setQueryMgr(QueryManager queryMgr) {
        m_queryMgr = queryMgr;
    }

    /**
     * @return Returns the queryMgr.
     */
    QueryManager getQueryMgr() {
        return m_queryMgr;
    }

    /**
     * @param instance
     */
    public void setDbConnectionFactory(DbConnectionFactory dbConnectionFactory) {
        m_dbConnectionFactory = dbConnectionFactory;
    }

    public Event createEvent(String uei, int nodeId, InetAddress address, String svcName, java.util.Date date) {
        Category log = ThreadCategory.getInstance(getClass());
    
        if (log.isDebugEnabled())
            log.debug("createEvent: uei = " + uei + " nodeid = " + nodeId);
    
        // create the event to be sent
        Event newEvent = new Event();
        newEvent.setUei(uei);
        newEvent.setSource(Poller.EVENT_SOURCE);
        newEvent.setNodeid((long) nodeId);
        if (address != null)
            newEvent.setInterface(address.getHostAddress());
    
        if (svcName != null)
            newEvent.setService(svcName);
    
        try {
            newEvent.setHost(InetAddress.getLocalHost().getHostName());
        } catch (UnknownHostException uhE) {
            newEvent.setHost("unresolved.host");
            log.warn("Failed to resolve local hostname", uhE);
        }
    
        // Set event time
        newEvent.setTime(EventConstants.formatToString(date));
    
        // For node level events (nodeUp/nodeDown) retrieve the
        // node's nodeLabel value and add it as a parm
        if (uei.equals(EventConstants.NODE_UP_EVENT_UEI) || uei.equals(EventConstants.NODE_DOWN_EVENT_UEI)) {
            String nodeLabel = null;
            try {
                nodeLabel = getQueryMgr().getNodeLabel(nodeId);
            } catch (SQLException sqlE) {
                // Log a warning
                log.warn("Failed to retrieve node label for nodeid " + nodeId, sqlE);
            }
    
            if (nodeLabel == null) {
                // This should never happen but if it does just
                // use nodeId for the nodeLabel so that the
                // event description has something to display.
                nodeLabel = String.valueOf(nodeId);
            }
    
            // Add appropriate parms
            Parms eventParms = new Parms();
    
            // Add nodelabel parm
            Parm eventParm = new Parm();
            eventParm.setParmName(EventConstants.PARM_NODE_LABEL);
            Value parmValue = new Value();
            parmValue.setContent(nodeLabel);
            eventParm.setValue(parmValue);
            eventParms.addParm(eventParm);
    
            // Add Parms to the event
            newEvent.setParms(eventParms);
        }
    
        return newEvent;
    }

    public void refreshServicePackages() {
	PollableVisitor visitor = new PollableVisitorAdaptor() {
		public void visitService(PollableService service) {
			service.refreshConfig();
		}
	};
	m_network.visit(visitor);
    }

}