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/Disk__Monitor.java

Comparing projects/cms/source/server/uk/org/iscream/cms/server/client/monitors/Disk__Monitor.java (file contents):
Revision 1.5 by ajm, Thu Mar 22 00:59:13 2001 UTC vs.
Revision 1.23 by tdb, Thu Feb 10 17:36:00 2005 UTC

#	Line 1 | Line 1
1	+	/*
2	+	* i-scream central monitoring system
3	+	* http://www.i-scream.org
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.util.ArrayList;
26	>	import java.util.HashSet;
27		import java.util.Set;
28		import java.util.Iterator;
29		import java.text.NumberFormat;
30	<	import uk.org.iscream.client.*;
31	<	import uk.org.iscream.core.*;
32	<	import uk.org.iscream.util.*;
33	<	import uk.org.iscream.componentmanager.*;
30	>	import uk.org.iscream.cms.server.client.*;
31	>	import uk.org.iscream.cms.server.core.*;
32	>	import uk.org.iscream.cms.util.*;
33	>	import uk.org.iscream.cms.server.componentmanager.*;
34
35		/**
36		* This Monitor watches the Disks for all machines
#	Line 27 | Line 47 | public class Disk__Monitor extends MonitorSkeleton {
47		*/
48		public final String REVISION = "$Revision$";
49
50	+	/**
51	+	* A description of this monitor
52	+	*/
53		public final String DESC = "Monitors all host disks.";
54
55		//---STATIC METHODS---
#	Line 34 | Line 57 | public class Disk__Monitor extends MonitorSkeleton {
57		//---CONSTRUCTORS---
58
59		//---PUBLIC METHODS---
60	<
60	>
61	>	/**
62	>	* Analyse a packet of data, and generate an alert if
63	>	* necessary.
64	>	*
65	>	* @param packet the XMLPacket to analyse
66	>	*/
67		public void analysePacket(XMLPacket packet) {
68	<	if (packet.getParam("packet.attributes.type").equals("data")) {
69	<	String source = packet.getParam("packet.attributes.machine_name");
70	<	if (!_hosts.containsKey(source)) {
71	<	_hosts.put(source, new HashMap());
72	<	}
73	<
74	<	HashMap diskRegisters = (HashMap) _hosts.get(source);
75	<
76	<	// a tempory holder for all the disk attributes we find
77	<	ArrayList disks = new ArrayList();
49	<
50	<	// unfortunatly we need to check the whole packet
51	<	// to find the disks, and then get the data attributes
52	<	Set packetSet = packet.getSet();
53	<	Iterator i = packetSet.iterator();
54	<	while (i.hasNext()) {
55	<	String dataKey = (String) i.next();
56	<	if(dataKey.startsWith("packet.disk.p")) {
57	<	if(!disks.contains(dataKey)) {
58	<	String diskNumber = "";
59	<
60	<	// pos is after "packet.disk.p"
61	<	int pos = 13;
62	<	while (dataKey.charAt(pos) != '.') {
63	<	diskNumber = diskNumber + dataKey.charAt(pos);
64	<	pos++;
65	<	}
66	<
67	<	// add the disk to our list, with the packet data
68	<
69	<	// used (we won't use this value - but we need it to forget about it ;)
70	<	disks.add("packet.disk.p" + diskNumber + ".attributes.used");
71	<
72	<	// device
73	<	disks.add("packet.disk.p" + diskNumber + ".attributes.name");
74	<	String device = packet.getParam("packet.disk.p" + diskNumber + ".attributes.name");
75	<	// mount point
76	<	disks.add("packet.disk.p" + diskNumber + ".attributes.mount");
77	<	String mount = packet.getParam("packet.disk.p" + diskNumber + ".attributes.mount");
68	>	String source = packet.getParam("packet.attributes.machine_name");
69	>	if(!checkBooleanConfig("Host." + source, "Monitor." + _name + ".enable")) {
70	>	return;
71	>	}
72	>	if (!_hosts.containsKey(source)) {
73	>	_hosts.put(source, new HashMap());
74	>	}
75	>	if (!_hostsInode.containsKey(source)) {
76	>	_hostsInode.put(source, new HashMap());
77	>	}
78
79	<	// these next two will be used to calculate the %age
80	<	// total
81	<	disks.add("packet.disk.p" + diskNumber + ".attributes.kbytes");
82	<	String total = packet.getParam("packet.disk.p" + diskNumber + ".attributes.kbytes");
83	<	// available
84	<	disks.add("packet.disk.p" + diskNumber + ".attributes.avail");
85	<	String avail = packet.getParam("packet.disk.p" + diskNumber + ".attributes.avail");
79	>	HashMap diskRegisters = (HashMap) _hosts.get(source);
80	>	HashMap diskInodeRegisters = (HashMap) _hostsInode.get(source);
81	>
82	>	// key prefix
83	>	String keyPrefix = "packet.disk.p";
84	>
85	>	// a temporary holder for all the disk attributes we find
86	>	HashSet disks = new HashSet();
87
88	<	// *** now process this disk ***
88	>	// unfortunatly we need to check the whole packet
89	>	// to find the disks, and then get the data attributes
90	>	Set packetSet = packet.getSet();
91	>	Iterator i = packetSet.iterator();
92	>	while (i.hasNext()) {
93	>	String dataKey = (String) i.next();
94	>	if(dataKey.startsWith(keyPrefix)) {
95	>	// pos is after "packet.disk.p"
96	>	int pos = keyPrefix.length();
97	>	String diskNumber = dataKey.substring(pos, dataKey.indexOf('.', pos));
98	>	String thisDisk = keyPrefix.concat(diskNumber);
99	>
100	>	if(!disks.contains(thisDisk)) {
101	>	// add the disk to our list
102	>	disks.add(thisDisk);
103
104	<	// check if we've seen this disk before on a previous run
105	<	// if not, we need to create a register for it
106	<	if(!diskRegisters.containsKey(diskNumber)) {
107	<	diskRegisters.put(diskNumber, new Register(source, _name, mount));
93	<	}
104	>	// device
105	>	String device = packet.getParam(thisDisk + ".attributes.name");
106	>	// mount point
107	>	String mount = packet.getParam(thisDisk + ".attributes.mount");
108
109	<	// get the register for this disk
110	<	Register reg = (Register) diskRegisters.get(diskNumber);
109	>	// these next two will be used to calculate the %age
110	>	// total
111	>	String total = packet.getParam(thisDisk + ".attributes.total");
112	>	// available
113	>	String avail = packet.getParam(thisDisk + ".attributes.avail");
114	>
115	>	String totalInodes = packet.getParam(thisDisk + ".attributes.totalinodes");
116	>	String availInodes = packet.getParam(thisDisk + ".attributes.freeinodes");
117
118	<	// get the packet data
119	<	double diskTotal, diskAvail;
120	<	try {
121	<
122	<	if(total==null || avail==null) {
123	<	throw new NumberFormatException("Disk data invalid");
124	<	}
125	<	diskTotal = Double.parseDouble(total);
126	<	diskAvail = Double.parseDouble(avail);
127	<	} catch (NumberFormatException e) {
128	<	_logger.write(this.toString(), Logger.WARNING, "Received packet from "+source+" with bad disk information: "+e);
129	<	// don't try to continue and process, try next disk
130	<	break;
118	>	// *** now process this disk ***
119	>
120	>	// check if we've seen this disk before on a previous run
121	>	// if not, we need to create a register for it
122	>	//   nb. use the mount as the key as this is unlikely to change,
123	>	//       unlike diskNumber which could easily change
124	>	//         (diskNumber is based on the order of df's output!)
125	>	if(!diskRegisters.containsKey(mount)) {
126	>	diskRegisters.put(mount, new Register(source, _name, mount));
127	>	}
128	>	if(!diskInodeRegisters.containsKey(mount)) {
129	>	diskInodeRegisters.put(mount, new Register(source, _nameInode, mount));
130	>	}
131	>
132	>	// get the register for this disk
133	>	Register reg = (Register) diskRegisters.get(mount);
134	>	Register regInode = (Register) diskInodeRegisters.get(mount);
135	>
136	>	// get the packet data
137	>	double diskTotal, diskAvail;
138	>	long diskInodeTotal, diskInodeAvail;
139	>	try {
140	>
141	>	if(total==null || avail==null || totalInodes==null || availInodes==null) {
142	>	throw new NumberFormatException("Disk data invalid");
143		}
144	<
145	<	boolean useValue = false;
144	>	diskTotal = Double.parseDouble(total);
145	>	diskAvail = Double.parseDouble(avail);
146	>	diskInodeTotal = Long.parseLong(totalInodes);
147	>	diskInodeAvail = Long.parseLong(availInodes);
148	>	} catch (NumberFormatException e) {
149	>	_logger.write(this.toString(), Logger.WARNING, "Received packet from "+source+" with bad disk information: "+e);
150	>	// don't try to continue and process, try next disk
151	>	break;
152	>	}
153	>
154	>	boolean useValue = false;
155	>	boolean useValueInode = false;
156	>	try {
157	>	// try looking for a mount-point specific thresholdMeasure first
158	>	String option = _cp.getProperty("Host." + source, "Monitor." + _name + "." + mount + ".thresholdMeasure");
159	>	if (option.equals("VALUE")) {
160	>	useValue = true;
161	>	}
162	>	option = _cp.getProperty("Host." + source, "Monitor." + _nameInode + "." + mount + ".thresholdMeasure");
163	>	if (option.equals("VALUE")) {
164	>	useValueInode = true;
165	>	}
166	>	} catch (PropertyNotFoundException e) {
167		try {
168	+	// now look for a more general thresholdMeasure
169		String option = _cp.getProperty("Host." + source, "Monitor." + _name + ".thresholdMeasure");
170		if (option.equals("VALUE")) {
171		useValue = true;
172	<	}
173	<	} catch (PropertyNotFoundException e) {
174	<	// we default to percentage
172	>	}
173	>	option = _cp.getProperty("Host." + source, "Monitor." + _nameInode + ".thresholdMeasure");
174	>	if (option.equals("VALUE")) {
175	>	useValueInode = true;
176	>	}
177	>	} catch (PropertyNotFoundException f) {
178	>	// we default to percentage in any case
179		}
122	–
123	–	// this  bit determines if the disk check is a % check
124	–	// or a kb check
125	–	double diskInUse;
126	–	String type;
127	–	if(useValue) {
128	–	// kb disk in use
129	–	diskInUse = diskTotal - diskAvail;
130	–	type = "kb";
131	–	} else {
132	–	// % disk in use
133	–	diskInUse = (1 - (diskAvail / diskTotal)) * 100;
134	–	type = "%";
135	–	}
136	–
137	–
138	–
139	–	int newThreshold = checkAttributeThreshold(diskInUse, reg);
140	–
141	–	// format the memoryInUse to a String
142	–	NumberFormat nf = NumberFormat.getInstance();
143	–	nf.setMaximumFractionDigits(2);
144	–	nf.setMinimumFractionDigits(2);
145	–	String strDiskInUse = nf.format(diskInUse);
146	–
147	–	// say which disk had the problem
148	–	String attributeName = "Disk in use " + type + " on " + mount + " (" + device + ")";
149	–
150	–	processAlert(newThreshold, attributeName, reg, source, strDiskInUse);
180		}
181	+
182	+	// this  bit determines if the disk check is a % check
183	+	// or a byte check
184	+	String type;
185	+	double curValue;
186	+	int newThreshold;
187	+	if(useValue) {
188	+	// byte disk available
189	+	curValue = diskAvail;
190	+	// negate check
191	+	newThreshold = checkAttributeThreshold(curValue, reg, true);
192	+	type = "bytes";
193	+	} else {
194	+	// % disk in use
195	+	curValue = (1 - ((double)diskAvail / (double)diskTotal)) * 100;
196	+	// normal check
197	+	newThreshold = checkAttributeThreshold(curValue, reg, false);
198	+	type = "%";
199	+	}
200	+
201	+	String typeInode;
202	+	double curValueInode;
203	+	int newThresholdInode;
204	+	if(useValueInode) {
205	+	// inodes available
206	+	curValueInode = diskInodeAvail;
207	+	// negate check
208	+	newThresholdInode = checkAttributeThreshold(curValueInode, regInode, true);
209	+	typeInode = "count";
210	+	} else {
211	+	// % inodes in use
212	+	curValueInode = (1 - ((double)diskInodeAvail / (double)diskInodeTotal)) * 100;
213	+	// normal check
214	+	newThresholdInode = checkAttributeThreshold(curValueInode, regInode, false);
215	+	typeInode = "%";
216	+	}
217	+
218	+	// format the diskInUse to a String
219	+	NumberFormat nf = NumberFormat.getInstance();
220	+	nf.setMaximumFractionDigits(2);
221	+	nf.setMinimumFractionDigits(2);
222	+	String strCurValue = nf.format(curValue);
223	+	String strCurValueInode = nf.format(curValueInode);
224	+
225	+	// say which disk had the problem
226	+	String attributeName = "Disk in use " + type + " on " + mount + " (" + device + ")";
227	+	String attributeNameInode = "Disk inodes in use " + type + " on " + mount + " (" + device +")";
228	+
229	+	processAlert(newThreshold, attributeName, reg, source, strCurValue);
230	+	processAlert(newThresholdInode, attributeNameInode, regInode, source, strCurValueInode);
231		}
232		}
233		}
#	Line 158 | Line 237 | public class Disk__Monitor extends MonitorSkeleton {
237		* Overrides the {@link java.lang.Object#toString() Object.toString()}
238		* method to provide clean logging (every class should have this).
239		*
240	<	* This uses the uk.org.iscream.util.NameFormat class
240	>	* This uses the uk.org.iscream.cms.util.NameFormat class
241		* to format the toString()
242		*
243		* @return the name of this class and its CVS revision
#	Line 178 | Line 257 | public class Disk__Monitor extends MonitorSkeleton {
257		}
258
259		//---PRIVATE METHODS---
260	<
261	<	private int checkAttributeThreshold(double diskInUse, Register reg) {
260	>
261	>	/**
262	>	* Checks a piece of current data, and returns the
263	>	* threshold it breaches, if any.
264	>	*
265	>	* The option to negate the check can be used in
266	>	* situations where being *below* the threshold
267	>	* is an 'alertable' situation. In this specific
268	>	* case, we'd do this with kb disk checks.
269	>	*
270	>	* @param value the current value
271	>	* @param reg the Register for the host
272	>	* @param negateCheck whether to negate the check
273	>	* @return the threshold level breached, if any
274	>	*/
275	>	private int checkAttributeThreshold(double value, Register reg, boolean negateCheck) {
276		for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
277		if (reg.getThreshold(thresholdLevel) != -1.0) {
278	<	if(((double) reg.getThreshold(thresholdLevel)) < diskInUse) {
279	<	return thresholdLevel;
278	>	if(!negateCheck) {
279	>	// normal check - has the value gone *over* the threshold
280	>	if(((double) reg.getThreshold(thresholdLevel)) < value) {
281	>	return thresholdLevel;
282	>	}
283		}
284	+	else {
285	+	// negated check - has the value gone *under* the threshold
286	+	if(((double) reg.getThreshold(thresholdLevel)) > value) {
287	+	return thresholdLevel;
288	+	}
289	+	}
290		}
291		}
292		return Alert.thresholdNORMAL;
293		}
294
295		//---ACCESSOR/MUTATOR METHODS---
296	<
296	>
297	>	/**
298	>	* Returns a reference to a specific Queue for this
299	>	* monitor. This Queue returns only the data packets
300	>	* (based on type) that we want too look at.
301	>	*
302	>	* @return a reference to a Queue
303	>	*/
304	>	protected Queue getQueue() {
305	>	return MonitorManager.getInstance().getDataQueue();
306	>	}
307	>
308		//---ATTRIBUTES---
309
310		/**
#	Line 206 | Line 319 | public class Disk__Monitor extends MonitorSkeleton {
319		private String _name = "Disk";
320
321		/**
322	+	* Inodes have the name "DiskInode" in the
323	+	* configuration.
324	+	*/
325	+	private String _nameInode = "DiskInode";
326	+
327	+	/**
328		* A reference to the configuration proxy in use
329		*/
330		private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
331	<
331	>
332	>	/**
333	>	* A HashMap of Registers (or groups of Registers), one
334	>	* for each host we're monitoring.
335	>	*/
336		private HashMap _hosts = new HashMap();
337	+
338	+	/**
339	+	* A HashMap of Registers (or groups of Registers), one
340	+	* for each host we're monitoring (inodes).
341	+	*/
342	+	private HashMap _hostsInode = new HashMap();
343
344		//---STATIC ATTRIBUTES---
345

Diff Legend

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