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

Comparing projects/cms/source/server/uk/org/iscream/cms/server/client/monitors/Heartbeat__Monitor.java (file contents):
Revision 1.1 by tdb, Mon Mar 5 13:30:34 2001 UTC vs.
Revision 1.23 by tdb, Tue May 21 16:47:16 2002 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.ac.ukc.iscream.client.monitors;
22	>	package uk.org.iscream.cms.server.client.monitors;
23
24		//---IMPORTS---
25		import java.util.HashMap;
26		import java.util.Iterator;
27	<	import uk.ac.ukc.iscream.client.*;
28	<	import uk.ac.ukc.iscream.core.*;
29	<	import uk.ac.ukc.iscream.util.*;
30	<	import uk.ac.ukc.iscream.componentmanager.*;
27	>	import java.util.StringTokenizer;
28	>	import uk.org.iscream.cms.server.client.*;
29	>	import uk.org.iscream.cms.server.core.*;
30	>	import uk.org.iscream.cms.server.util.*;
31	>	import uk.org.iscream.cms.server.componentmanager.*;
32
33		/**
34	<	* This Monitor watches heartbeats
34	>	* This Monitor watches heartbeats.
35	>	* It generates an alert when a heartbeat that is expected
36	>	* does not arrive. Unlike all the other monitors, this one
37	>	* is driven by an event *not* occuring, rather than an
38	>	* event occuring. This means it must be actively checking
39	>	* for missing heartbeat's, and thus has an extra inner class
40	>	* thread.
41		*
42		* @author  $Author$
43		* @version $Id$
44		*/
45	<	public class Heartbeat__Monitor extends Thread implements PluginMonitor {
45	>	public class Heartbeat__Monitor extends MonitorSkeleton {
46
47		//---FINAL ATTRIBUTES---
48
#	Line 24 | Line 51 | public class Heartbeat__Monitor extends Thread impleme
51		*/
52		public final String REVISION = "$Revision$";
53
54	+	/**
55	+	* A description of this monitor
56	+	*/
57		public final String DESC = "Monitors Heartbeats.";
58
59	+	/**
60	+	* The default (used if not configured) period at
61	+	* which to check for old heartbeats. (in seconds)
62	+	*/
63	+	public final int DEFAULT_CHECK_PERIOD = 60;
64	+
65		//---STATIC METHODS---
66
67		//---CONSTRUCTORS---
32	–
33	–	//---PUBLIC METHODS---
68
69	<	public void run() {
70	<	ConfigurationProxy cp = ConfigurationProxy.getInstance();
71	<	while(true) {
72	<	// this cycle period could be done better, maybe ?
73	<	int checkPeriod = Integer.parseInt(cp.getProperty(_name, "Monitor.Heartbeat.checkPeriod"));
74	<
75	<	// perform the checks (use HB hash, although they *should* be the same)
76	<	Iterator i = _hostsHB.keySet().iterator();
43	<	while(i.hasNext()) {
44	<	// get host
45	<	String source = (String) i.next();
46	<	// check it
47	<	analyseHB(source);
48	<	}
49	<
50	<	// wait a while
51	<	try {Thread.sleep(checkPeriod * 1000);} catch (InterruptedException e) {}
52	<	}
69	>	/**
70	>	* Constructs a new Heartbeat monitor, and starts off
71	>	* the worker thread.
72	>	*/
73	>	public Heartbeat__Monitor() {
74	>	super();
75	>	createInitialHosts();
76	>	new HeartbeatWorker().start();
77		}
54	–
55	–	// only use attribute num 0 :)
56	–	public void analyseHB(String source) {
57	–	ConfigurationProxy cp = ConfigurationProxy.getInstance();
58	–	Register reg = (Register) _hostsReg.get(source);
59	–
60	–	// get host's HB interval (seconds)
61	–	int hostHBinterval = Integer.parseInt(cp.getProperty("Host."+source, "TCPUpdateTime"));
62	–	// get host's last HB time (seconds)
63	–	int lastHeartbeat = ((HeartbeatHolder) _hostsHB.get(source)).getLastHeartbeat();
64	–	// time since last heartbeat (seconds)
65	–	int timeSinceLastHB = ((int) (System.currentTimeMillis()/1000)) - lastHeartbeat;
66	–
67	–	// find out the threshold level we're at
68	–	int result = checkAttributeThreshold(timeSinceLastHB, reg);
69	–
70	–	// decide what threshold level we're on, if we've changed, record that
71	–	if (result != reg.getLastThresholdLevel(0)) {
72	–	reg.setLastThresholdLevel(0, result);
73	–	}
74	–
75	–	// as long as this isn't a normal level
76	–	if(reg.getLastThresholdLevel(0) != Alert.thresholdNORMAL) {
77	–	// if the time since the last alert is more than the time for
78	–	// its timeout, fire an alert, escalate the alert
79	–	long timeout = reg.getLastAlertTimeout(0);
80	–	if ((timeout > 0) && (reg.getTimeLastSent(0) > 0)) {
81	–	if((System.currentTimeMillis() - reg.getTimeLastSent(0)) > timeout) {
82	–	int lastAlert = reg.getLastAlertLevel(0);
83	–	reg.escalateAlert(0);
84	–	reg.setTimeLastSent(0, System.currentTimeMillis());
85	–	reg.setLastAlertTimeout(0, reg.getAlertTimeout(reg.getLastAlertLevel(0), 0));
86	–	// -- SEND
87	–	fireAlert(source, timeSinceLastHB, reg, lastAlert);
88	–	}
89	–	// if we don't have a timeout configured...we got STRAIGHT to the next level
90	–	} else {
91	–	int lastAlert = reg.getLastAlertLevel(0);
92	–	reg.escalateAlert(0);
93	–	reg.setTimeLastSent(0, System.currentTimeMillis());
94	–	reg.setLastAlertTimeout(0, reg.getAlertTimeout(reg.getLastAlertLevel(0), 0));
95	–	// -- SEND
96	–	fireAlert(source, timeSinceLastHB, reg, lastAlert);
97	–	}
98	–
99	–	// we must be on ok, check the timeout value for this
100	–	} else {
101	–	// if we were on an OK alert before, then we don't do anything
102	–	// but if we weren't we only set OK, once the timeout of the last
103	–	// alert has occourd
104	–	if (reg.getLastAlertLevel(0) != Alert.alertOK) {
105	–	long timeout = reg.getLastAlertTimeout(0);
106	–	if ((timeout > 0) && (reg.getTimeLastSent(0) > 0)) {
107	–	if ((System.currentTimeMillis() - reg.getTimeLastSent(0)) > timeout) {
108	–	int lastAlert = reg.getLastAlertLevel(0);
109	–	reg.setLastAlertLevel(0, Alert.alertOK);
110	–	reg.setTimeLastSent(0, System.currentTimeMillis());
111	–	reg.setLastAlertTimeout(0, timeout);
112	–	// -- SEND
113	–	fireAlert(source, timeSinceLastHB, reg, lastAlert);
114	–	}
115	–	}
116	–	}
117	–	}
118	–	}
78
79	+	//---PUBLIC METHODS---
80	+
81	+	/**
82	+	* Analyse a packet of data. In this case, this will just
83	+	* register the fact that a heartbeat has arrived.
84	+	*
85	+	* @param packet The packet of data to analyse
86	+	*/
87		public void analysePacket(XMLPacket packet) {
88	<	if (packet.getParam("packet.attributes.type").equals("heartbeat")) {
89	<	String source = packet.getParam("packet.attributes.machine_name");
90	<	if (!_hostsHB.containsKey(source)) {
91	<	_hostsReg.put(source, new Register(source, _name, 1));
125	<	_hostsHB.put(source, new HeartbeatHolder());
88	>	String source = packet.getParam("packet.attributes.machine_name");
89	>	if (!_hosts.containsKey(source)) {
90	>	synchronized(this) {
91	>	_hosts.put(source, new HeartbeatHolder(new Register(source, _name)));
92		}
127	–	HeartbeatHolder lastHeartbeat = (HeartbeatHolder) _hostsReg.get(source);
128	–	lastHeartbeat.setLastHeartbeat((int)System.currentTimeMillis()/1000);
93		}
94	+	HeartbeatHolder lastHeartbeat = (HeartbeatHolder) _hosts.get(source);
95	+	lastHeartbeat.setLastHeartbeat(System.currentTimeMillis()/1000);
96		}
97
98		/**
99		* Overrides the {@link java.lang.Object#toString() Object.toString()}
100		* method to provide clean logging (every class should have this).
101		*
102	<	* This uses the uk.ac.ukc.iscream.util.NameFormat class
102	>	* This uses the uk.org.iscream.cms.server.util.NameFormat class
103		* to format the toString()
104		*
105		* @return the name of this class and its CVS revision
#	Line 154 | Line 120 | public class Heartbeat__Monitor extends Thread impleme
120
121		//---PRIVATE METHODS---
122
123	<	private int checkAttributeThreshold(int timeSinceLastHB, Register reg) {
123	>	/**
124	>	* Checks whether the time since the last heartbeat
125	>	* is beyond the threshold(s).
126	>	*
127	>	* @param timeSinceLastHB a long time since the last heartbeat arrived
128	>	* @param reg the Register for this host
129	>	* @return the level which has been breached, if any
130	>	*/
131	>	private int checkAttributeThreshold(long timeSinceLastHB, Register reg) {
132		for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
133		if (reg.getThreshold(thresholdLevel) != -1.0) {
134	<	if (reg.getThreshold(thresholdLevel) < timeSinceLastHB) {
134	>	if (((long) reg.getThreshold(thresholdLevel)) < timeSinceLastHB) {
135		return thresholdLevel;
136		}
137		}
138		}
139	<	return 0;
139	>	return Alert.thresholdNORMAL;
140		}
141	+
142	+	/**
143	+	* Gets an initial list of hosts from the config
144	+	* and adds a fake set of heartbeats for them.
145	+	* If the hosts don't respond within the timeout
146	+	* period an alert will be raised.
147	+	*
148	+	* The effect of this is to allow us to know about
149	+	* hosts which weren't on when we started up, and
150	+	* will thus never have generated a heartbeat - yet
151	+	* will still want to know they're not responding.
152	+	*/
153	+	private void createInitialHosts() {
154	+	// get the initial list of hosts from the config
155	+	String initialHosts = "";
156	+	try {
157	+	initialHosts = _cp.getProperty(_name, "Monitor.Heartbeat.initialHosts");
158	+	} catch (PropertyNotFoundException e) {
159	+	// just leave initialHosts empty
160	+	_logger.write(Heartbeat__Monitor.this.toString(), Logger.DEBUG, "No initial list of hosts set, defaulting to none.");
161	+	}
162
163	<	private void fireAlert(String source, int timeSinceLastHB, Register reg, int lastAlert) {
164	<	int alertLevel = reg.getLastAlertLevel(0);
165	<	int thresholdLevel = reg.getLastThresholdLevel(0);
166	<	String currentValue = String.valueOf(timeSinceLastHB);
167	<	String attributeName = "Heartbeat";
168	<	String thresholdValue = String.valueOf(reg.getThreshold(thresholdLevel));
169	<	String time = Long.toString(reg.getAlertTimeout(reg.getLastAlertLevel(0), 0) / 1000);
170	<	if (thresholdLevel == Alert.thresholdNORMAL) {
171	<	thresholdValue = "-";
163	>	// parse through the initial hosts adding them
164	>	StringTokenizer st = new StringTokenizer(initialHosts, ";");
165	>	while (st.hasMoreTokens()) {
166	>	String source = st.nextToken();
167	>	// check if they already exist, don't want to add them twice
168	>	if (!_hosts.containsKey(source)) {
169	>	synchronized(this) {
170	>	_hosts.put(source, new HeartbeatHolder(new Register(source, _name)));
171	>	}
172	>	}
173	>	HeartbeatHolder lastHeartbeat = (HeartbeatHolder) _hosts.get(source);
174	>	// set a "fake" heartbeat
175	>	lastHeartbeat.setLastHeartbeat(System.currentTimeMillis()/1000);
176		}
178	–	if (alertLevel == Alert.alertOK) {
179	–	time = "0";
180	–	}
181	–	Alert alert = new Alert(alertLevel, lastAlert, thresholdLevel, source, thresholdValue, currentValue, attributeName, time);
182	–	_alerterQueue.add(alert);
183	–	_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");
177		}
178
179		//---ACCESSOR/MUTATOR METHODS---
180	<
180	>
181	>	/**
182	>	* Returns a reference to the Queue we're getting data
183	>	* from. This is specific to this monitor.
184	>	*
185	>	* @return a reference to a Queue to get data from
186	>	*/
187	>	protected Queue getQueue() {
188	>	return MonitorManager.getInstance().getHeartbeatQueue();
189	>	}
190	>
191		//---ATTRIBUTES---
192
193		/**
#	Line 197 | Line 200 | public class Heartbeat__Monitor extends Thread impleme
200		* be changed to null for utility classes.
201		*/
202		private String _name = "Heartbeat";
203	<
203	>
204		/**
205	<	* This holds a reference to the
203	<	* system logger that is being used.
205	>	* A reference to the configuration proxy in use
206		*/
207	<	private Logger _logger = ReferenceManager.getInstance().getLogger();
207	>	private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
208
209	<	private Queue _alerterQueue = ClientMain._alerterQueue;
209	>	/**
210	>	* A HashMap of hosts, with associated HeartbeatHolder's.
211	>	*/
212	>	private HashMap _hosts = new HashMap();
213
214		/**
215	<	* A reference to the configuration proxy in use
215	>	* A reference to the system logger.
216		*/
217	<	private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
217	>	private Logger _logger = ReferenceManager.getInstance().getLogger();
218
214	–	private HashMap _hostsHB = new HashMap();
215	–	private HashMap _hostsReg = new HashMap();
216	–
219		//---STATIC ATTRIBUTES---
220
221		//---INNER CLASSES---
222	<
222	>
223	>	/**
224	>	* This inner class simply holding some information
225	>	* about a specific host.
226	>	*/
227		private class HeartbeatHolder {
228
229	<	public void setLastHeartbeat(int lastHeartbeat) {
229	>	/**
230	>	* Construct a new HeartbeatHolder.
231	>	*/
232	>	public HeartbeatHolder(Register register) {
233	>	_register = register;
234	>	}
235	>
236	>	/**
237	>	* Set the time of the last heartbeat
238	>	*/
239	>	public void setLastHeartbeat(long lastHeartbeat) {
240		_lastHeartbeat = lastHeartbeat;
241		}
242
243	<	public int getLastHeartbeat() {
243	>	/**
244	>	* Get the time of the last heartbeat
245	>	*/
246	>	public long getLastHeartbeat() {
247		return _lastHeartbeat;
248		}
249
250	<	private int _lastHeartbeat;
251	<	}
252	<
250	>	/**
251	>	* Get the Register
252	>	*/
253	>	public Register getRegister() {
254	>	return _register;
255	>	}
256	>
257	>	/**
258	>	* last heartbeat time
259	>	*/
260	>	private long _lastHeartbeat;
261	>
262	>	/**
263	>	* register ref
264	>	*/
265	>	private Register _register;
266	>	}
267	>
268	>	/**
269	>	* This worker thread just checks all the hosts and then
270	>	* waits a period of time before doing it again. It sends
271	>	* Alerts as required.
272	>	*/
273	>	private class HeartbeatWorker extends Thread {
274	>
275	>	/**
276	>	* The main run method of this worker thread. It simply
277	>	* checks through all the hosts it has stored, running
278	>	* the analyseHB method on each. It then removes any
279	>	* that have passed a FINAL, and waits a (configured)
280	>	* length of time before doing it again.
281	>	*/
282	>	public void run() {
283	>	ConfigurationProxy cp = ConfigurationProxy.getInstance();
284	>	while(true) {
285	>	// this cycle period of this monitor's checks
286	>	int checkPeriod = 0;
287	>	try {
288	>	checkPeriod = Integer.parseInt(cp.getProperty(_name, "Monitor.Heartbeat.checkPeriod"));
289	>	} catch (PropertyNotFoundException e) {
290	>	checkPeriod = DEFAULT_CHECK_PERIOD;
291	>	_logger.write(Heartbeat__Monitor.this.toString(), Logger.WARNING, "Monitor.Heartbeat.checkPeriod value unavailable using default of " + checkPeriod + " seconds");
292	>	} catch (NumberFormatException e) {
293	>	checkPeriod = DEFAULT_CHECK_PERIOD;
294	>	_logger.write(Heartbeat__Monitor.this.toString(), Logger.WARNING, "Erronous Monitor.Heartbeat.checkPeriod value in configuration using default of " + checkPeriod + " seconds");
295	>	}
296	>
297	>	synchronized(Heartbeat__Monitor.this) {
298	>	// perform the checks (use HB hash, although they *should* be the same)
299	>	Iterator i = _hosts.keySet().iterator();
300	>	while(i.hasNext()) {
301	>	// get host
302	>	String source = (String) i.next();
303	>	// check it
304	>	boolean remove = analyseHB(source);
305	>	// remove it if it's passed a FINAL
306	>	if(remove) {
307	>	i.remove();
308	>	}
309	>	}
310	>	}
311	>
312	>	// wait a while
313	>	try {Thread.sleep(checkPeriod * 1000);} catch (InterruptedException e) {}
314	>	}
315	>	}
316	>
317	>	/**
318	>	* Analyses a given host's state, and if need be generates
319	>	* a relevant Alert. Note that it also checks if the last
320	>	* alert sent is FINAL, in which case it returns true to
321	>	* indicate removal of this host.
322	>	*
323	>	* @param source the host to check
324	>	* @return whether this host can be deleted
325	>	*/
326	>	private boolean analyseHB(String source) {
327	>	ConfigurationProxy cp = ConfigurationProxy.getInstance();
328	>	HeartbeatHolder hbHolder = (HeartbeatHolder) _hosts.get(source);
329	>	Register reg = hbHolder.getRegister();
330	>
331	>	// get host's HB interval (seconds)
332	>	// this should always exist, thus we set to 0
333	>	int hostHBinterval = 0;
334	>	try {
335	>	hostHBinterval = Integer.parseInt(cp.getProperty("Host."+source, "Host.TCPUpdateTime"));
336	>	} catch (PropertyNotFoundException e) {
337	>	hostHBinterval = 0;
338	>	_logger.write(Heartbeat__Monitor.this.toString(), Logger.WARNING, "TCPUpdateTime value unavailable using default of " + hostHBinterval + " seconds");
339	>	} catch (NumberFormatException e) {
340	>	hostHBinterval = 0;
341	>	_logger.write(Heartbeat__Monitor.this.toString(), Logger.WARNING, "Erronous TCPUpdateTime value in configuration using default of " + hostHBinterval + " seconds");
342	>	}
343	>
344	>	// get host's last HB time (seconds)
345	>	long lastHeartbeat = hbHolder.getLastHeartbeat();
346	>	// time since last heartbeat (seconds)
347	>	long timeSinceLastHB = (System.currentTimeMillis()/1000) - lastHeartbeat;
348	>	// time since (or until if negative) the expected heartbeat
349	>	long timeSinceExpectedHB = timeSinceLastHB - (long) hostHBinterval;
350	>
351	>	// best do a check in case the expected heartbeat is in the future
352	>	if(timeSinceExpectedHB < 0) {
353	>	timeSinceExpectedHB = 0;
354	>	}
355	>
356	>	// find out the threshold level we're at
357	>	int newThreshold = checkAttributeThreshold(timeSinceExpectedHB, reg);
358	>
359	>	// process the alert
360	>	Heartbeat__Monitor.this.processAlert(newThreshold, "Heartbeat", reg, source, String.valueOf(timeSinceExpectedHB));
361	>
362	>	if(reg.getLastAlertLevel() == Alert.alertFINAL) {
363	>	return true;
364	>	}
365	>	return false;
366	>	}
367	>	}
368		}

Diff Legend

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