client/monitors/CPU__Monitor.java

//---PACKAGE DECLARATION---
package uk.ac.ukc.iscream.client.monitors;

//---IMPORTS---
import java.util.HashMap;
import uk.ac.ukc.iscream.client.*;
import uk.ac.ukc.iscream.core.*;
import uk.ac.ukc.iscream.util.*;
import uk.ac.ukc.iscream.componentmanager.*;

/**
 * This Monitor watches the CPU load for all machines
 *
 * @author  $Author: ajm4 $
 * @version $Id: CPU__Monitor.java,v 1.10 2001/03/02 03:59:25 ajm4 Exp $
 */
public class CPU__Monitor implements PluginMonitor {

//---FINAL ATTRIBUTES---

    /**
     * The current CVS revision of this class
     */
    public final String REVISION = "$Revision: 1.10 $";
    
    public final String DESC = "Monitors CPU.";
    
//---STATIC METHODS---

//---CONSTRUCTORS---

//---PUBLIC METHODS---

    public void analysePacket(XMLPacket packet) {
        if (packet.getParam("packet.attributes.type").equals("data")) {
            String source = packet.getParam("packet.attributes.machine_name");
            if (!_hosts.containsKey(source)) {
                _hosts.put(source, new Register(source, _name, _attributes.length));
            }
            
            Register reg = (Register) _hosts.get(source);
            for(int attributeNum = 0; attributeNum < _attributes.length; attributeNum++) {
                // find out the threshold level we're at
                int result = checkAttributeThreshold(packet.getParam(_attributes[attributeNum]), reg);
                
                // decide what threshold level we're on, if we've changed, record that
                if (result != reg.getLastThresholdLevel(attributeNum)) {
                    reg.setLastThresholdLevel(attributeNum, result);
                }
                // as long as this isn't a normal level
                if(reg.getLastThresholdLevel(attributeNum) != Alert.thresholdNORMAL) {
                    // if the time since the last alert is more than the time for
                    // its timeout, fire an alert, escalate the alert
                    long timeout = reg.getAlertTimeout(reg.getLastAlertLevel(attributeNum), attributeNum);
                    if ((timeout > 0) && (reg.getTimeLastSent(attributeNum) > 0)) {
                        if((System.currentTimeMillis() - reg.getTimeLastSent(attributeNum)) > timeout) {
                            reg.escalateAlert(attributeNum);
                            reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
                            fireAlert(reg, packet, attributeNum);
                        }
                    // if we don't have a timeout configured...we got STRAIGHT to the next level
                    } else {
                        reg.escalateAlert(attributeNum);
                        reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
                        fireAlert(reg, packet, attributeNum);
                    }
                        
                // we must be on ok, check the timeout value for this
                } else {
                    // if we were on an OK alert before, then we don't do anything
                    // but if we weren't we only set OK, once the timout of the last 
                    // alert has occourd
                    if (reg.getLastAlertLevel(attributeNum) != Alert.alertOK) {
                        long timeout = reg.getAlertTimeout(reg.getLastAlertLevel(attributeNum), attributeNum);
                        if ((timeout > 0) && (reg.getTimeLastSent(attributeNum) > 0)) {
                            if ((System.currentTimeMillis() - reg.getTimeLastSent(attributeNum)) > timeout) {
                                reg.setLastAlertLevel(attributeNum, Alert.alertOK);
                                reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
                                fireAlert(reg, packet, attributeNum);
                            }
                        } else {
                            reg.setLastAlertLevel(attributeNum, Alert.alertOK);
                            reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
                            fireAlert(reg, packet, attributeNum);
                        }
                    }
                }
            }
        }
    }

    /**
     * Overrides the {@link java.lang.Object#toString() Object.toString()}
     * method to provide clean logging (every class should have this).
     *
     * This uses the uk.ac.ukc.iscream.util.NameFormat class
     * to format the toString()
     *
     * @return the name of this class and its CVS revision
     */
    public String toString() {
        return FormatName.getName(
            _name,
            getClass().getName(),
            REVISION);
    }

    /**
     * return the String representation of what the monitor does
     */
    public String getDescription(){
        return DESC;
    }

//---PRIVATE METHODS---

    private int checkAttributeThreshold(String attributeString, Register reg) {
        for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
            if (reg.getThreshold(thresholdLevel) != -1.0) {
                if(attributeString != null) {
                    try {
                        double attribute = Double.parseDouble(attributeString);
                        if (reg.getThreshold(thresholdLevel) < attribute) return thresholdLevel;
                    } catch (NumberFormatException e) {
                        // we got some duff data in the packet, but we shouldn't have
                        _logger.write(toString(), Logger.DEBUG, "possible errenous packet data, should be double value - " + attributeString);
                    }
                }
            }
        }
        return 0;
    }

    private void fireAlert(Register reg, XMLPacket packet, int attributeNum) {
        int alertLevel = reg.getLastAlertLevel(attributeNum);
        int thresholdLevel = reg.getLastThresholdLevel(attributeNum);
        String source = packet.getParam("packet.attributes.machine_name");
        String currentValue = packet.getParam(_attributes[attributeNum]);
        String attributeName = _attributeNames[attributeNum];
        String thresholdValue = Double.toString(reg.getThreshold(thresholdLevel));
        String time = Long.toString(reg.getAlertTimeout(reg.getLastAlertLevel(attributeNum), attributeNum) / 1000);
        if (thresholdLevel == Alert.thresholdNORMAL) {
            thresholdValue = "-";
        }
        if (alertLevel == Alert.alertOK) {
            time = "0";
        }
        Alert alert = new Alert(alertLevel, thresholdLevel, source, thresholdValue, currentValue, attributeName, time);
        _alerterQueue.add(alert);
        _logger.write(toString(), Logger.DEBUG, "Fired alert for source:" + source + " at alert level:" + Alert.alertLevels[alertLevel] + " on:" + attributeName + " for threshold level:" + Alert.thresholdLevels[thresholdLevel] + " at:" +  currentValue + " exceeding threshold of:" +thresholdValue + " next alert sent in:" + time + "secs");
    }

//---ACCESSOR/MUTATOR METHODS---

//---ATTRIBUTES---

    /**
     * This is the friendly identifier of the
     * component this class is running in.
     * eg, a Filter may be called "filter1",
     * If this class does not have an owning
     * component,  a name from the configuration
     * can be placed here.  This name could also
     * be changed to null for utility classes.
     */
    private String _name = "CPU";

    /**
     * This holds a reference to the
     * system logger that is being used.
     */
    private Logger _logger = ReferenceManager.getInstance().getLogger();
    
    private Queue _alerterQueue = ClientMain._alerterQueue;
    
    /**
     * A reference to the configuration proxy in use
     */
    private ConfigurationProxy _cp = ConfigurationProxy.getInstance();

    private HashMap _hosts = new HashMap();

    private String[] _attributes = { "packet.cpu.user", "packet.cpu.kernel", "packet.cpu.iowait", "packet.cpu.swap" };
    private String[] _attributeNames = {"User CPU", "Kernel CPU", "I/O Wait CPU", "Swap CPU"};

//---STATIC ATTRIBUTES---

}
Revision:	1.11
Committed:	Sun Mar 4 02:41:16 2001 UTC (23 years, 3 months ago) by ajm
Branch:	MAIN
Changes since 1.10:	+82 -46 lines
Log Message:	Revamped monitoring and alert fireing mechanism. Now takes account of timing of last alerts. Now uses threshold value a guide to how quickly alerts should be escalated.
#	User	Rev	Content
1	tdb	1.1	//---PACKAGE DECLARATION---
2			package uk.ac.ukc.iscream.client.monitors;
3
4			//---IMPORTS---
5	ajm	1.9	import java.util.HashMap;
6	tdb	1.1	import uk.ac.ukc.iscream.client.*;
7			import uk.ac.ukc.iscream.core.*;
8			import uk.ac.ukc.iscream.util.*;
9			import uk.ac.ukc.iscream.componentmanager.*;
10
11			/**
12			* This Monitor watches the CPU load for all machines
13			*
14	ajm	1.10	* @author $Author: ajm4 $
15	ajm	1.11	* @version $Id: CPU__Monitor.java,v 1.10 2001/03/02 03:59:25 ajm4 Exp $
16	tdb	1.1	*/
17	ajm	1.6	public class CPU__Monitor implements PluginMonitor {
18	tdb	1.1
19			//---FINAL ATTRIBUTES---
20
21			/**
22			* The current CVS revision of this class
23			*/
24	ajm	1.11	public final String REVISION = "$Revision: 1.10 $";
25	tdb	1.1
26			public final String DESC = "Monitors CPU.";
27
28			//---STATIC METHODS---
29
30			//---CONSTRUCTORS---
31
32			//---PUBLIC METHODS---
33
34			public void analysePacket(XMLPacket packet) {
35	ajm	1.7	if (packet.getParam("packet.attributes.type").equals("data")) {
36	tdb	1.8	String source = packet.getParam("packet.attributes.machine_name");
37	ajm	1.9	if (!_hosts.containsKey(source)) {
38	ajm	1.11	_hosts.put(source, new Register(source, _name, _attributes.length));
39	ajm	1.2	}
40	ajm	1.9
41			Register reg = (Register) _hosts.get(source);
42	ajm	1.11	for(int attributeNum = 0; attributeNum < _attributes.length; attributeNum++) {
43			// find out the threshold level we're at
44			int result = checkAttributeThreshold(packet.getParam(_attributes[attributeNum]), reg);
45
46			// decide what threshold level we're on, if we've changed, record that
47			if (result != reg.getLastThresholdLevel(attributeNum)) {
48			reg.setLastThresholdLevel(attributeNum, result);
49			}
50			// as long as this isn't a normal level
51			if(reg.getLastThresholdLevel(attributeNum) != Alert.thresholdNORMAL) {
52			// if the time since the last alert is more than the time for
53			// its timeout, fire an alert, escalate the alert
54			long timeout = reg.getAlertTimeout(reg.getLastAlertLevel(attributeNum), attributeNum);
55			if ((timeout > 0) && (reg.getTimeLastSent(attributeNum) > 0)) {
56			if((System.currentTimeMillis() - reg.getTimeLastSent(attributeNum)) > timeout) {
57			reg.escalateAlert(attributeNum);
58			reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
59			fireAlert(reg, packet, attributeNum);
60			}
61			// if we don't have a timeout configured...we got STRAIGHT to the next level
62			} else {
63			reg.escalateAlert(attributeNum);
64			reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
65			fireAlert(reg, packet, attributeNum);
66			}
67
68			// we must be on ok, check the timeout value for this
69			} else {
70			// if we were on an OK alert before, then we don't do anything
71			// but if we weren't we only set OK, once the timout of the last
72			// alert has occourd
73			if (reg.getLastAlertLevel(attributeNum) != Alert.alertOK) {
74			long timeout = reg.getAlertTimeout(reg.getLastAlertLevel(attributeNum), attributeNum);
75			if ((timeout > 0) && (reg.getTimeLastSent(attributeNum) > 0)) {
76			if ((System.currentTimeMillis() - reg.getTimeLastSent(attributeNum)) > timeout) {
77			reg.setLastAlertLevel(attributeNum, Alert.alertOK);
78			reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
79			fireAlert(reg, packet, attributeNum);
80			}
81			} else {
82			reg.setLastAlertLevel(attributeNum, Alert.alertOK);
83			reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
84			fireAlert(reg, packet, attributeNum);
85			}
86			}
87			}
88			}
89	ajm	1.2	}
90	tdb	1.1	}
91
92			/**
93			* Overrides the {@link java.lang.Object#toString() Object.toString()}
94			* method to provide clean logging (every class should have this).
95			*
96			* This uses the uk.ac.ukc.iscream.util.NameFormat class
97			* to format the toString()
98			*
99			* @return the name of this class and its CVS revision
100			*/
101			public String toString() {
102			return FormatName.getName(
103			_name,
104			getClass().getName(),
105			REVISION);
106			}
107
108			/**
109	ajm	1.11	* return the String representation of what the monitor does
110	tdb	1.1	*/
111			public String getDescription(){
112			return DESC;
113			}
114
115			//---PRIVATE METHODS---
116
117	ajm	1.11	private int checkAttributeThreshold(String attributeString, Register reg) {
118			for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
119			if (reg.getThreshold(thresholdLevel) != -1.0) {
120			if(attributeString != null) {
121			try {
122			double attribute = Double.parseDouble(attributeString);
123			if (reg.getThreshold(thresholdLevel) < attribute) return thresholdLevel;
124			} catch (NumberFormatException e) {
125			// we got some duff data in the packet, but we shouldn't have
126			_logger.write(toString(), Logger.DEBUG, "possible errenous packet data, should be double value - " + attributeString);
127			}
128	ajm	1.9	}
129			}
130			}
131			return 0;
132			}
133
134	ajm	1.11	private void fireAlert(Register reg, XMLPacket packet, int attributeNum) {
135			int alertLevel = reg.getLastAlertLevel(attributeNum);
136			int thresholdLevel = reg.getLastThresholdLevel(attributeNum);
137			String source = packet.getParam("packet.attributes.machine_name");
138			String currentValue = packet.getParam(_attributes[attributeNum]);
139			String attributeName = _attributeNames[attributeNum];
140			String thresholdValue = Double.toString(reg.getThreshold(thresholdLevel));
141			String time = Long.toString(reg.getAlertTimeout(reg.getLastAlertLevel(attributeNum), attributeNum) / 1000);
142			if (thresholdLevel == Alert.thresholdNORMAL) {
143			thresholdValue = "-";
144			}
145			if (alertLevel == Alert.alertOK) {
146			time = "0";
147			}
148			Alert alert = new Alert(alertLevel, thresholdLevel, source, thresholdValue, currentValue, attributeName, time);
149	ajm	1.2	_alerterQueue.add(alert);
150	ajm	1.11	_logger.write(toString(), Logger.DEBUG, "Fired alert for source:" + source + " at alert level:" + Alert.alertLevels[alertLevel] + " on:" + attributeName + " for threshold level:" + Alert.thresholdLevels[thresholdLevel] + " at:" + currentValue + " exceeding threshold of:" +thresholdValue + " next alert sent in:" + time + "secs");
151	ajm	1.2	}
152
153	tdb	1.1	//---ACCESSOR/MUTATOR METHODS---
154
155			//---ATTRIBUTES---
156
157			/**
158			* This is the friendly identifier of the
159			* component this class is running in.
160			* eg, a Filter may be called "filter1",
161			* If this class does not have an owning
162			* component, a name from the configuration
163			* can be placed here. This name could also
164			* be changed to null for utility classes.
165			*/
166	ajm	1.11	private String _name = "CPU";
167	tdb	1.1
168			/**
169			* This holds a reference to the
170			* system logger that is being used.
171			*/
172			private Logger _logger = ReferenceManager.getInstance().getLogger();
173	ajm	1.2
174	ajm	1.11	private Queue _alerterQueue = ClientMain._alerterQueue;
175	ajm	1.2
176			/**
177	ajm	1.11	* A reference to the configuration proxy in use
178	ajm	1.2	*/
179	ajm	1.11	private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
180	ajm	1.9
181			private HashMap _hosts = new HashMap();
182
183			private String[] _attributes = { "packet.cpu.user", "packet.cpu.kernel", "packet.cpu.iowait", "packet.cpu.swap" };
184			private String[] _attributeNames = {"User CPU", "Kernel CPU", "I/O Wait CPU", "Swap CPU"};
185	tdb	1.1
186			//---STATIC ATTRIBUTES---
187
188			}