ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/cms/source/server/uk/org/iscream/cms/server/client/monitors/Memory__Monitor.java

Comparing projects/cms/source/server/uk/org/iscream/cms/server/client/monitors/Memory__Monitor.java (file contents):
Revision 1.4 by tdb, Wed Mar 14 23:25:29 2001 UTC vs.
Revision 1.13 by tdb, Wed Feb 5 16:43:45 2003 UTC

#	Line 1 | Line 1
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.client.monitors;
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.client.*;
28	<	import uk.org.iscream.core.*;
29	<	import uk.org.iscream.util.*;
30	<	import uk.org.iscream.componentmanager.*;
27	>	import uk.org.iscream.cms.server.client.*;
28	>	import uk.org.iscream.cms.server.core.*;
29	>	import uk.org.iscream.cms.util.*;
30	>	import uk.org.iscream.cms.server.componentmanager.*;
31
32		/**
33		* This Monitor watches the Memory for all machines
#	Line 24 | Line 44 | public class Memory__Monitor extends MonitorSkeleton {
44		*/
45		public final String REVISION = "$Revision$";
46
47	+	/**
48	+	* A description of this monitor
49	+	*/
50		public final String DESC = "Monitors Memory.";
51
52		//---STATIC METHODS---
#	Line 31 | Line 54 | public class Memory__Monitor extends MonitorSkeleton {
54		//---CONSTRUCTORS---
55
56		//---PUBLIC METHODS---
57	<
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	<	if (packet.getParam("packet.attributes.type").equals("data")) {
66	<	String source = packet.getParam("packet.attributes.machine_name");
67	<	if (!_hosts.containsKey(source)) {
68	<	_hosts.put(source, new Register(source, _name));
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	<
81	<	Register reg = (Register) _hosts.get(source);
82	<
83	<	// find out the threshold level we're at
84	<	String attributeName = "Memory In Use %";
85	<
86	<	// get the packet data
48	<	double memoryTotal, memoryFree;
49	<	try {
50	<	String total = packet.getParam("packet.memory.total");
51	<	String free = packet.getParam("packet.memory.free");
52	<	if(total==null || free==null) {
53	<	throw new NumberFormatException("Memory data invalid");
54	<	}
55	<	memoryTotal = Double.parseDouble(total);
56	<	memoryFree = Double.parseDouble(free);
57	<	} catch (NumberFormatException e) {
58	<	_logger.write(this.toString(), Logger.WARNING, "Received packet from "+source+" with bad memory information: "+e);
59	<	// don't try to continue and process
60	<	return;
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	<
89	<	// percentage of memory in use
90	<	double memoryInUse = (1-(memoryFree / memoryTotal)) * 100;
91	<	int newThreshold = checkAttributeThreshold(memoryInUse, reg);
66	<
67	<	// format the memoryInUse to a String
68	<	NumberFormat nf = NumberFormat.getInstance();
69	<	nf.setMaximumFractionDigits(2);
70	<	nf.setMinimumFractionDigits(2);
71	<	String strMemoryInUse = nf.format(memoryInUse);
72	<
73	<	processAlert(newThreshold, attributeName, reg, source, strMemoryInUse);
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.util.NameFormat class
162	>	* This uses the uk.org.iscream.cms.util.NameFormat class
163		* to format the toString()
164		*
165		* @return the name of this class and its CVS revision
#	Line 98 | Line 179 | public class Memory__Monitor extends MonitorSkeleton {
179		}
180
181		//---PRIVATE METHODS---
182	<
183	<	private int checkAttributeThreshold(double memoryInUse, Register reg) {
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(((double) reg.getThreshold(thresholdLevel)) < memoryInUse) {
201	<	return thresholdLevel;
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
#	Line 129 | Line 244 | public class Memory__Monitor extends MonitorSkeleton {
244		* A reference to the configuration proxy in use
245		*/
246		private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
247	<
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---

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines