client/monitors/Memory__Monitor.java

/* 
 * i-scream central monitoring system
 * http://www.i-scream.org.uk
 * Copyright (C) 2000-2002 i-scream
 * 
 * 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.
 */

//---PACKAGE DECLARATION---
package uk.org.iscream.cms.server.client.monitors;

//---IMPORTS---
import java.util.HashMap;
import java.text.NumberFormat;
import uk.org.iscream.cms.server.client.*;
import uk.org.iscream.cms.server.core.*;
import uk.org.iscream.cms.server.util.*;
import uk.org.iscream.cms.server.componentmanager.*;

/**
 * This Monitor watches the Memory for all machines
 *
 * @author  $Author: tdb $
 * @version $Id: Memory__Monitor.java,v 1.11 2002/05/21 16:47:16 tdb Exp $
 */
public class Memory__Monitor extends MonitorSkeleton {

//---FINAL ATTRIBUTES---

    /**
     * The current CVS revision of this class
     */
    public final String REVISION = "$Revision: 1.11 $";
    
    /**
     * A description of this monitor
     */
    public final String DESC = "Monitors Memory.";
    
//---STATIC METHODS---

//---CONSTRUCTORS---

//---PUBLIC METHODS---
    
    /**
     * Analyse a packet of data, and generate an alert if
     * necessary.
     *
     * @param packet the XMLPacket to analyse
     */
    public void analysePacket(XMLPacket packet) {
        String source = packet.getParam("packet.attributes.machine_name");
        if (!_hosts.containsKey(source)) {
            _hosts.put(source, new Register(source, _name));
        }

        Register reg = (Register) _hosts.get(source);

        // get the packet data
        double memoryTotal, memoryFree, memoryCache;
        try {
            String total = packet.getParam("packet.memory.total");
            String free = packet.getParam("packet.memory.free");
            if(total==null || free==null) {
                throw new NumberFormatException("Memory data invalid or not supplied");
            }
            memoryTotal = Double.parseDouble(total);
            memoryFree = Double.parseDouble(free);
            // get hold of the cache data.. default to 0
            memoryCache = 0.0;
            String cache = packet.getParam("packet.memory.cache");
            if(cache != null) {
                memoryCache = Double.parseDouble(cache);
            }
        } catch (NumberFormatException e) {
            _logger.write(this.toString(), Logger.WARNING, "Received packet from "+source+" with bad memory information: "+e);
            // don't try to continue and process
            return;
        }

        boolean useValue = false;
        try {
           String option = _cp.getProperty("Host." + source, "Monitor." + _name + ".thresholdMeasure");
           if (option.equals("VALUE")) {
               useValue = true;
           }
        } catch (PropertyNotFoundException e) {
            // we default to percentage
        }
        
        boolean useCache = false;
        try {
           int useCacheAsFree = Integer.parseInt(_cp.getProperty("Host." + source, "Monitor." + _name + ".useCacheAsFree"));
           useCache = (useCacheAsFree == 1);
        } catch (PropertyNotFoundException e) {
            // we default to false
        } catch (NumberFormatException e) {
            // we default to false
        }
        
        // this  bit determines if the memory check is a % check
        // or a kb check
        String type;
        double curValue;
        int newThreshold;
        if(useValue) {
            // kb memory available
            if(useCache) {
                // NOTE: we take cache as being "probably free" for this check
                curValue = memoryFree + memoryCache;
            } else {
                curValue = memoryFree;
            }
            // negate check
            newThreshold = checkAttributeThreshold(curValue, reg, true);
            type = "kb";
        } else {
            // % memory in use
            if(useCache) {
                // NOTE: we take cache as being "probably free" for this check
                curValue = (1 - ((memoryFree + memoryCache) / memoryTotal)) * 100;
            } else {
                curValue = (1 - (memoryFree / memoryTotal)) * 100;
            }
            // normal check
            newThreshold = checkAttributeThreshold(curValue, reg, false);
            type = "%";
        }

        // format the memoryInUse to a String
        NumberFormat nf = NumberFormat.getInstance();
        nf.setMaximumFractionDigits(2);
        nf.setMinimumFractionDigits(2);
        String strCurValue = nf.format(curValue);
        
        // set the attributeName nicely
        String attributeName = type + " Memory in use";
        if(useCache) {
            attributeName += " (ex. cache)";
        }
        
        processAlert(newThreshold, attributeName, reg, source, strCurValue);
    }

    /**
     * Overrides the {@link java.lang.Object#toString() Object.toString()}
     * method to provide clean logging (every class should have this).
     *
     * This uses the uk.org.iscream.cms.server.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---
    
    /**
     * Checks a piece of current data, and returns the
     * threshold it breaches, if any.
     *
     * The option to negate the check can be used in
     * situations where being *below* the threshold
     * is an 'alertable' situation. In this specific
     * case, we'd do this with kb disk checks.
     *
     * @param value the current value
     * @param reg the Register for the host
     * @param negateCheck whether to negate the check
     * @return the threshold level breached, if any
     */
    private int checkAttributeThreshold(double value, Register reg, boolean negateCheck) {
        for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
            if (reg.getThreshold(thresholdLevel) != -1.0) {
                if(!negateCheck) {
                    // normal check - has the value gone *over* the threshold
                    if(((double) reg.getThreshold(thresholdLevel)) < value) {
                        return thresholdLevel;
                    }
                }
                else {
                    // negated check - has the value gone *under* the threshold
                    if(((double) reg.getThreshold(thresholdLevel)) > value) {
                        return thresholdLevel;
                    }
                }
            }
        }
        return Alert.thresholdNORMAL;
    }

//---ACCESSOR/MUTATOR METHODS---
    
    /**
     * Returns a reference to a specific Queue for this
     * monitor. This Queue returns only the data packets
     * (based on type) that we want too look at.
     *
     * @return a reference to a Queue
     */
    protected Queue getQueue() {
        return MonitorManager.getInstance().getDataQueue();
    }

//---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 = "Memory";
    
    /**
     * A reference to the configuration proxy in use
     */
    private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
    
    /**
     * A HashMap of Registers (or groups of Registers), one
     * for each host we're monitoring.
     */
    private HashMap _hosts = new HashMap();

//---STATIC ATTRIBUTES---

}
Revision:	1.12
Committed:	Tue May 28 17:11:01 2002 UTC (21 years, 11 months ago) by tdb
Branch:	MAIN
Changes since 1.11:	+38 -9 lines
Log Message:	Added support for taking "cache" memory as being free, for the purpose of generating alerts. This is useful on platforms such as FreeBSD and linux where the OS holds on to free'd memory as cache.
#	Content
1	/*
2	* i-scream central monitoring system
3	* http://www.i-scream.org.uk
4	* Copyright (C) 2000-2002 i-scream
5	*
6	* This program is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU General Public License
8	* as published by the Free Software Foundation; either version 2
9	* of the License, or (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19	*/
20
21	//---PACKAGE DECLARATION---
22	package uk.org.iscream.cms.server.client.monitors;
23
24	//---IMPORTS---
25	import java.util.HashMap;
26	import java.text.NumberFormat;
27	import uk.org.iscream.cms.server.client.*;
28	import uk.org.iscream.cms.server.core.*;
29	import uk.org.iscream.cms.server.util.*;
30	import uk.org.iscream.cms.server.componentmanager.*;
31
32	/**
33	* This Monitor watches the Memory for all machines
34	*
35	* @author $Author: tdb $
36	* @version $Id: Memory__Monitor.java,v 1.11 2002/05/21 16:47:16 tdb Exp $
37	*/
38	public class Memory__Monitor extends MonitorSkeleton {
39
40	//---FINAL ATTRIBUTES---
41
42	/**
43	* The current CVS revision of this class
44	*/
45	public final String REVISION = "$Revision: 1.11 $";
46
47	/**
48	* A description of this monitor
49	*/
50	public final String DESC = "Monitors Memory.";
51
52	//---STATIC METHODS---
53
54	//---CONSTRUCTORS---
55
56	//---PUBLIC METHODS---
57
58	/**
59	* Analyse a packet of data, and generate an alert if
60	* necessary.
61	*
62	* @param packet the XMLPacket to analyse
63	*/
64	public void analysePacket(XMLPacket packet) {
65	String source = packet.getParam("packet.attributes.machine_name");
66	if (!_hosts.containsKey(source)) {
67	_hosts.put(source, new Register(source, _name));
68	}
69
70	Register reg = (Register) _hosts.get(source);
71
72	// get the packet data
73	double memoryTotal, memoryFree, memoryCache;
74	try {
75	String total = packet.getParam("packet.memory.total");
76	String free = packet.getParam("packet.memory.free");
77	if(total==null \|\| free==null) {
78	throw new NumberFormatException("Memory data invalid or not supplied");
79	}
80	memoryTotal = Double.parseDouble(total);
81	memoryFree = Double.parseDouble(free);
82	// get hold of the cache data.. default to 0
83	memoryCache = 0.0;
84	String cache = packet.getParam("packet.memory.cache");
85	if(cache != null) {
86	memoryCache = Double.parseDouble(cache);
87	}
88	} catch (NumberFormatException e) {
89	_logger.write(this.toString(), Logger.WARNING, "Received packet from "+source+" with bad memory information: "+e);
90	// don't try to continue and process
91	return;
92	}
93
94	boolean useValue = false;
95	try {
96	String option = _cp.getProperty("Host." + source, "Monitor." + _name + ".thresholdMeasure");
97	if (option.equals("VALUE")) {
98	useValue = true;
99	}
100	} catch (PropertyNotFoundException e) {
101	// we default to percentage
102	}
103
104	boolean useCache = false;
105	try {
106	int useCacheAsFree = Integer.parseInt(_cp.getProperty("Host." + source, "Monitor." + _name + ".useCacheAsFree"));
107	useCache = (useCacheAsFree == 1);
108	} catch (PropertyNotFoundException e) {
109	// we default to false
110	} catch (NumberFormatException e) {
111	// we default to false
112	}
113
114	// this bit determines if the memory check is a % check
115	// or a kb check
116	String type;
117	double curValue;
118	int newThreshold;
119	if(useValue) {
120	// kb memory available
121	if(useCache) {
122	// NOTE: we take cache as being "probably free" for this check
123	curValue = memoryFree + memoryCache;
124	} else {
125	curValue = memoryFree;
126	}
127	// negate check
128	newThreshold = checkAttributeThreshold(curValue, reg, true);
129	type = "kb";
130	} else {
131	// % memory in use
132	if(useCache) {
133	// NOTE: we take cache as being "probably free" for this check
134	curValue = (1 - ((memoryFree + memoryCache) / memoryTotal)) * 100;
135	} else {
136	curValue = (1 - (memoryFree / memoryTotal)) * 100;
137	}
138	// normal check
139	newThreshold = checkAttributeThreshold(curValue, reg, false);
140	type = "%";
141	}
142
143	// format the memoryInUse to a String
144	NumberFormat nf = NumberFormat.getInstance();
145	nf.setMaximumFractionDigits(2);
146	nf.setMinimumFractionDigits(2);
147	String strCurValue = nf.format(curValue);
148
149	// set the attributeName nicely
150	String attributeName = type + " Memory in use";
151	if(useCache) {
152	attributeName += " (ex. cache)";
153	}
154
155	processAlert(newThreshold, attributeName, reg, source, strCurValue);
156	}
157
158	/**
159	* Overrides the {@link java.lang.Object#toString() Object.toString()}
160	* method to provide clean logging (every class should have this).
161	*
162	* This uses the uk.org.iscream.cms.server.util.NameFormat class
163	* to format the toString()
164	*
165	* @return the name of this class and its CVS revision
166	*/
167	public String toString() {
168	return FormatName.getName(
169	_name,
170	getClass().getName(),
171	REVISION);
172	}
173
174	/**
175	* return the String representation of what the monitor does
176	*/
177	public String getDescription(){
178	return DESC;
179	}
180
181	//---PRIVATE METHODS---
182
183	/**
184	* Checks a piece of current data, and returns the
185	* threshold it breaches, if any.
186	*
187	* The option to negate the check can be used in
188	* situations where being below the threshold
189	* is an 'alertable' situation. In this specific
190	* case, we'd do this with kb disk checks.
191	*
192	* @param value the current value
193	* @param reg the Register for the host
194	* @param negateCheck whether to negate the check
195	* @return the threshold level breached, if any
196	*/
197	private int checkAttributeThreshold(double value, Register reg, boolean negateCheck) {
198	for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
199	if (reg.getThreshold(thresholdLevel) != -1.0) {
200	if(!negateCheck) {
201	// normal check - has the value gone over the threshold
202	if(((double) reg.getThreshold(thresholdLevel)) < value) {
203	return thresholdLevel;
204	}
205	}
206	else {
207	// negated check - has the value gone under the threshold
208	if(((double) reg.getThreshold(thresholdLevel)) > value) {
209	return thresholdLevel;
210	}
211	}
212	}
213	}
214	return Alert.thresholdNORMAL;
215	}
216
217	//---ACCESSOR/MUTATOR METHODS---
218
219	/**
220	* Returns a reference to a specific Queue for this
221	* monitor. This Queue returns only the data packets
222	* (based on type) that we want too look at.
223	*
224	* @return a reference to a Queue
225	*/
226	protected Queue getQueue() {
227	return MonitorManager.getInstance().getDataQueue();
228	}
229
230	//---ATTRIBUTES---
231
232	/**
233	* This is the friendly identifier of the
234	* component this class is running in.
235	* eg, a Filter may be called "filter1",
236	* If this class does not have an owning
237	* component, a name from the configuration
238	* can be placed here. This name could also
239	* be changed to null for utility classes.
240	*/
241	private String _name = "Memory";
242
243	/**
244	* A reference to the configuration proxy in use
245	*/
246	private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
247
248	/**
249	* A HashMap of Registers (or groups of Registers), one
250	* for each host we're monitoring.
251	*/
252	private HashMap _hosts = new HashMap();
253
254	//---STATIC ATTRIBUTES---
255
256	}