collectableservice.java

来自「opennms得相关源码 请大家看看」· Java 代码 · 共 614 行 · 第 1/2 页

//
// This file is part of the OpenNMS(R) Application.
//
// OpenNMS(R) is Copyright (C) 2002-2003 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.
//
// Modifications:
//
// 2003 Jan 31: Cleaned up some unused imports.
//
// 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.collectd;

import java.io.File;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

import org.apache.log4j.Category;
import org.opennms.core.utils.ThreadCategory;
import org.opennms.netmgt.EventConstants;
import org.opennms.netmgt.config.DataCollectionConfigFactory;
import org.opennms.netmgt.config.PollOutagesConfigFactory;
import org.opennms.netmgt.config.CollectdConfigFactory;
import org.opennms.netmgt.config.collectd.Parameter;
import org.opennms.netmgt.config.collectd.Service;
import org.opennms.netmgt.eventd.EventIpcManagerFactory;
import org.opennms.netmgt.poller.monitors.IPv4NetworkInterface;
import org.opennms.netmgt.scheduler.ReadyRunnable;
import org.opennms.netmgt.scheduler.Scheduler;
import org.opennms.netmgt.utils.EventProxy;
import org.opennms.netmgt.xml.event.Event;
import org.opennms.netmgt.xml.event.Log;

/**
 * <P>
 * The CollectableService class ...
 * </P>
 * 
 * @author <A HREF="mailto:[e-mail]">Mike Davidson </A>
 * @author <A HREF="http://www.opennms.org/">OpenNMS </A>
 * 
 */
final class CollectableService extends IPv4NetworkInterface implements ReadyRunnable {
    /**
     * Interface's parent node identifier
     */
    private int m_nodeId;

    /**
     * The package information for this interface/service pair
     */
    private org.opennms.netmgt.config.collectd.Package m_package;

    /**
     * The service informaion for this interface/service pair
     */
    private final Service m_service;

    /**
     * Last known/current status
     */
    private int m_status;

    /**
     * The last time data collection ocurred
     */
    private long m_lastCollectionTime;

    /**
     * The last time the collector was scheduled for collection.
     */
    private long m_lastScheduledCollectionTime;

    /**
     * The scheduler for collectd
     */
    private final Scheduler m_scheduler;

    /**
     * Service updates
     */
    private CollectorUpdates m_updates;

    /**
     * The event proxy
     */
    private EventProxy m_proxy;

    /**
     * 
     */
    private static final boolean ABORT_COLLECTION = true;

    /**
     * The map of collection parameters
     */
    private static Map m_properties = new TreeMap();

    private ServiceCollector m_collector;

    /**
     * The key used to lookup the service properties that are passed to the
     * monitor.
     */
    private final String m_svcPropKey;

    /**
     * The map of service parameters. These parameters are mapped by the
     * composite key <em>(package name, service name)</em>.
     */
    private static Map SVC_PROP_MAP = Collections.synchronizedMap(new TreeMap());

    /**
     * Constructs a new instance of a CollectableService object.
     * 
     * @param dbNodeId
     *            The database identifier key for the interfaces' node
     * @param address
     *            InetAddress of the interface to collect from
     * @param svcName
     *            Service name
     * @param pkg
     *            The package containing parms for this collectable service.
     * 
     */
    CollectableService(int dbNodeId, InetAddress address, String svcName, org.opennms.netmgt.config.collectd.Package pkg) {
        super(address);
        m_nodeId = dbNodeId;
        m_package = pkg;
        m_status = ServiceCollector.COLLECTION_SUCCEEDED;

        m_scheduler = Collectd.getInstance().getScheduler();
        m_collector = Collectd.getInstance().getServiceCollector(svcName);
        m_updates = new CollectorUpdates();

        m_lastScheduledCollectionTime = 0L;
        m_lastCollectionTime = 0L;

        // find the service matching the name
        // m
        Service svc = null;
        Enumeration esvc = m_package.enumerateService();
        while (esvc.hasMoreElements()) {
            Service s = (Service) esvc.nextElement();
            if (s.getName().equalsIgnoreCase(svcName)) {
                svc = s;
                break;
            }
        }
        if (svc == null)
            throw new RuntimeException("Service name not part of package!");

        // save reference to the service
        m_service = svc;

        // add property list for this service/package combination if
        // it doesn't already exist in the service property map
        //
        m_svcPropKey = m_package.getName() + "." + m_service.getName();
        synchronized (SVC_PROP_MAP) {
            if (!SVC_PROP_MAP.containsKey(m_svcPropKey)) {
                Map m = Collections.synchronizedMap(new TreeMap());
                Enumeration ep = m_service.enumerateParameter();
                while (ep.hasMoreElements()) {
                    Parameter p = (Parameter) ep.nextElement();
                    m.put(p.getKey(), p.getValue());
                }

                SVC_PROP_MAP.put(m_svcPropKey, m);
            }
        }

        m_proxy = new EventProxy() {
            public void send(Event e) {
                EventIpcManagerFactory.getInstance().getManager().sendNow(e);
            }

            public void send(Log log) {
                EventIpcManagerFactory.getInstance().getManager().sendNow(log);
            }
        };

    }

    /**
     * Returns node identifier
     */
    public int getNodeId() {
        return m_nodeId;
    }

    /**
     * Set node nodentifier
     */
    public void setNodeId(int nodeId) {
        m_nodeId = nodeId;
    }

    /**
     * Returns the service name
     */
    public String getServiceName() {
        return m_service.getName();
    }

    /**
     * Returns the package name
     */
    public String getPackageName() {
        return m_package.getName();
    }

    /**
     * Returns updates object
     */
    public CollectorUpdates getCollectorUpdates() {
        return m_updates;
    }

	/**
	* Uses the existing package name to try and re-obtain the package from the collectd config factory.
	* Should be called when the collect config has been reloaded.
	*/
	public void refreshPackage() {
		org.opennms.netmgt.config.collectd.Package refreshedPackage=CollectdConfigFactory.getInstance().getPackage(this.getPackageName());
		if(refreshedPackage!=null) {
			this.m_package=refreshedPackage;
		}
	}


    /**
     * This method is used to evaluate the status of this interface and service
     * pair. If it is time to run the collection again then a value of true is
     * returned. If the interface is not ready then a value of false is
     * returned.
     */
    public boolean isReady() {
        boolean ready = false;

        if (!Collectd.getInstance().isSchedulingCompleted())
            return false;

        if (m_service.getInterval() < 1) {
            ready = true;
        } else {
            ready = ((m_service.getInterval() - (System.currentTimeMillis() - m_lastScheduledCollectionTime)) < 1);
        }

        return ready;
    }

    /**
     * Generate event and send it to eventd via the event proxy.
     * 
     * uei Universal event identifier of event to generate.
     */
    private void sendEvent(String uei) {
        Category log = ThreadCategory.getInstance(getClass());
        Event event = new Event();
        event.setUei(uei);
        event.setNodeid((long) m_nodeId);
        event.setInterface(m_address.getHostAddress());
        event.setService("SNMP");
        event.setSource("OpenNMS.Collectd");
        try {
            event.setHost(InetAddress.getLocalHost().getHostAddress());
        } catch (UnknownHostException ex) {
            event.setHost("unresolved.host");
        }

        event.setTime(EventConstants.formatToString(new java.util.Date()));

        // Send the event
        //
        try {
            EventIpcManagerFactory.getInstance().getManager().sendNow(event);