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

Comparing projects/cms/source/server/uk/org/iscream/cms/server/client/MonitorManager.java (file contents):
Revision 1.2 by tdb, Thu Mar 1 16:52:25 2001 UTC vs.
Revision 1.20 by tdb, Fri Jul 25 14:35:29 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.ac.ukc.iscream.client;
22	>	package uk.org.iscream.cms.server.client;
23
24		//---IMPORTS---
25	<	import uk.ac.ukc.iscream.componentmanager.*;
26	<	import uk.ac.ukc.iscream.core.*;
27	<	import uk.ac.ukc.iscream.util.*;
25	>	import uk.org.iscream.cms.server.componentmanager.*;
26	>	import uk.org.iscream.cms.server.core.*;
27	>	import uk.org.iscream.cms.util.*;
28		import java.util.*;
29
30		/**
31		* A manager for the Monitors.
32		*
33	+	* This class starts by loading all the monitors as specificed in the configuration.
34	+	* These monitors should implement the PluginMonitor interface.
35	+	*
36	+	* This class then takes the feed of data coming in over CORBA from
37	+	* the ClientServant queue.  This data is then looked at to determine
38	+	* type.  It then places it into either a data queue, or an other
39	+	* queue, and all data in the the all queue.
40	+	*
41	+	* Monitors then read the data off the queue that they are interested in
42	+	* and process the data accordingly.
43	+	*
44		* @author  $Author$
45		* @version $Id$
46		*/
47	<	class MonitorManager extends Thread{
47	>	public class MonitorManager extends Thread {
48
49		//---FINAL ATTRIBUTES---
50
#	Line 24 | Line 55 | class MonitorManager extends Thread{
55
56		//---STATIC METHODS---
57
58	+	/**
59	+	* Return a reference to the single class.
60	+	* Construct it if it does not already exist, otherwise just return the reference.
61	+	*/
62	+	public synchronized static MonitorManager getInstance() {
63	+	if (_instance == null){
64	+	_instance = new MonitorManager();
65	+	}
66	+	return _instance;
67	+	}
68	+
69		//---CONSTRUCTORS---
70
71	<	public MonitorManager(Queue queue) {
72	<	_queue = queue;
71	>	/**
72	>	* Constructs a new MonitorManager.
73	>	* This initialises all the queues and loads
74	>	* all the Monitors that have been specified in the configuration
75	>	*/
76	>	private MonitorManager() {
77	>	// set our name
78	>	setName("client.MonitorManager");
79	>
80	>	_queue = ClientMain._monitorQueue;
81	>	_qID = _queue.getQueue();
82	>	_logger.write(toString(), Logger.SYSINIT, "Initialising");
83	>	_logger.write(toString(), Logger.SYSMSG, "Creating monitor pipeline for plugin monitors ...");
84	>
85	>	// get the config proxy
86	>	ConfigurationProxy cp = ConfigurationProxy.getInstance();
87	>
88	>	// get the configuration for our outgoing queue's
89	>
90	>	// see if these Queue's need a size limit
91	>	try {
92	>	int queueSizeLimit = Integer.parseInt(cp.getProperty(_name, "Queue.SizeLimit"));
93	>	String queueRemoveAlgorithm = cp.getProperty(_name, "Queue.RemoveAlgorithm");
94	>	int algorithm = StringUtils.getStringPos(queueRemoveAlgorithm, Queue.algorithms);
95	>	if(algorithm != -1) {
96	>	_logger.write(toString(), Logger.DEBUG, "Starting 3 Queues with size limit of "+queueSizeLimit+", using remove algorithm "+queueRemoveAlgorithm);
97	>	// we have valid values, so lets start it.
98	>	_dataQueue = new Queue(queueSizeLimit, algorithm);
99	>	_otherQueue = new Queue(queueSizeLimit, algorithm);
100	>	_allQueue = new Queue(queueSizeLimit, algorithm);
101	>	}
102	>	else {
103	>	_logger.write(toString(), Logger.WARNING, "Bad Queue Algorithm configuration, not known: "+queueRemoveAlgorithm);
104	>	// just don't activate a limit
105	>	_dataQueue = new Queue();
106	>	_otherQueue = new Queue();
107	>	_allQueue = new Queue();
108	>	}
109	>	} catch (PropertyNotFoundException e) {
110	>	_logger.write(toString(), Logger.DEBUG, "Optional config not set: "+e);
111	>	// just don't activate a limit
112	>	_dataQueue = new Queue();
113	>	_otherQueue = new Queue();
114	>	_allQueue = new Queue();
115	>	} catch (NumberFormatException e) {
116	>	_logger.write(toString(), Logger.WARNING, "Bad Queue SizeLimit configuration: "+e);
117	>	// just don't activate a limit
118	>	_dataQueue = new Queue();
119	>	_otherQueue = new Queue();
120	>	_allQueue = new Queue();
121	>	}
122	>
123	>	// startup monitors on these queues
124	>	try {
125	>	// try to get the interval, if this fails, we won't start up the monitor
126	>	int queueMonitorInterval = Integer.parseInt(cp.getProperty(_name, "Queue.MonitorInterval"));
127	>	_dataQueue.startMonitor(queueMonitorInterval*1000, ClientMain._monitorQueue, _name + " DataQueue");
128	>	_otherQueue.startMonitor(queueMonitorInterval*1000, ClientMain._monitorQueue, _name + " OtherQueue");
129	>	_allQueue.startMonitor(queueMonitorInterval*1000, ClientMain._monitorQueue, _name + " AllQueue");
130	>	} catch (PropertyNotFoundException e) {
131	>	_logger.write(toString(), Logger.WARNING, "failed to find queue monitor config, disabling. " + e);
132	>	}
133	>
134	>	// get the configuration for this plug-in setup
135	>	String pluginsPackage, pluginsList;
136	>	try {
137	>	pluginsPackage = cp.getProperty(_name, "Monitor.PluginsPackage");
138	>	pluginsList = cp.getProperty(_name, "Monitor.Plugins");
139	>	} catch(PropertyNotFoundException e) {
140	>	_logger.write(toString(), Logger.WARNING, "Unable to get required configuration, Monitor's will not be activated: "+e);
141	>	// setting these will ensure we don't build a pipeline
142	>	pluginsPackage = "";
143	>	pluginsList = "";
144	>	}
145	>
146	>	StringTokenizer st = new StringTokenizer(pluginsList, ";");
147	>
148	>	while(st.hasMoreTokens()) {
149	>	String className = pluginsPackage + "." + st.nextToken() + _suffix;
150	>	_logger.write(toString(), Logger.DEBUG, "Attempting to create plugin: "+className);
151	>
152	>	// Create an instance of the specified PluginMonitor to include
153	>	// within the monitorPipe.  Add it to the monitorPipeline
154	>	try {
155	>	PluginMonitor pm = (PluginMonitor)ClassLoader.getSystemClassLoader().loadClass(className).newInstance();
156	>	_monitorPipeline.add(pm);
157	>	_logger.write(toString(), Logger.DEBUG, "Added monitor: "+className+" ("+pm.getDescription()+")");
158	>	}
159	>	catch (InstantiationException e){
160	>	_logger.write(toString(), Logger.ERROR, "Failed to instantiate "+className+" to the plugin monitor pipeline.");
161	>	_logger.write(toString(), Logger.ERROR, e.getMessage());
162	>	}
163	>	catch (Exception e){
164	>	_logger.write(toString(), Logger.ERROR, "Failed to add "+className+" to the plugin monitor pipeline.");
165	>	_logger.write(toString(), Logger.ERROR, e.toString());
166	>	}
167	>	}
168	>	_logger.write(toString(), Logger.SYSMSG, "The monitor pipeline has been set up with "+_monitorPipeline.size()+" plugin monitors.");
169		}
170
171		//---PUBLIC METHODS---
172
173	+	/**
174	+	* Runs the MonitorManager.  This reads data from the
175	+	* inbound queue (from the ClientServant).  And passes
176	+	* it into the appropriate queue for processing by the monitor
177	+	* threads.
178	+	*/
179		public void run() {
36	–	LinkedList monitors = setupMonitors();
37	–	int qID = _queue.getQueue();
180		boolean run=true;
181	+
182	+	// keep these out here, saves recreating the object
183	+	String xml = null;
184		while(run) {
40	–	// attempt to get some data from the Queue
41	–	String xml = "";
185		try {
186	<	xml = (String) _queue.get(qID);
186	>	xml = (String) _queue.get(_qID);
187		}
188		catch(InvalidQueueException e) {
189		_logger.write(toString(), Logger.ERROR, "Queue failure: "+e);
#	Line 50 | Line 193 | class MonitorManager extends Thread{
193		XMLPacket packet = null;
194
195		try {
196	<	XMLPacketMaker xmlPacketMaker = new XMLPacketMaker(xml);
54	<	packet = xmlPacketMaker.createXMLPacket();
196	>	packet = _xmlCache.getXMLPacket(xml);
197		} catch(InvalidXMLException e) {
198		_logger.write(toString(), Logger.ERROR, "Invalid XML: "+e);
199		// skip the rest of this loop iteration
200		continue;
201		}
202	<
203	<	//send to monitors
204	<	Iterator i = monitors.iterator();
205	<	while(i.hasNext()) {
206	<	((Monitor) i.next()).analysePacket(packet);
202	>
203	>	if(packet == null) {
204	>	_logger.write(toString(), Logger.WARNING, "Got a null packet when parsing: "+xml);
205	>	// skip to next packet
206	>	continue;
207		}
208
209	<	// is that all ?
209	>	// examine the packet and place it in the relevant outgoing queue
210	>	if(packet.getParam("packet.attributes.type") != null &&
211	>	packet.getParam("packet.attributes.type").equals("data")) {
212	>	_dataQueue.add(packet);
213	>	}
214	>	else {
215	>	_otherQueue.add(packet);
216	>	}
217	>	// always add to all queue
218	>	_allQueue.add(packet);
219		}
220		}
221
#	Line 72 | Line 223 | class MonitorManager extends Thread{
223		* Overrides the {@link java.lang.Object#toString() Object.toString()}
224		* method to provide clean logging (every class should have this).
225		*
226	<	* This uses the uk.ac.ukc.iscream.util.FormatName class
226	>	* This uses the uk.org.iscream.cms.util.FormatName class
227		* to format the toString()
228		*
229		* @return the name of this class and its CVS revision
#	Line 85 | Line 236 | class MonitorManager extends Thread{
236		}
237
238		//---PRIVATE METHODS---
88	–
89	–	// this should be changed to do something a bit
90	–	// more interesting :)
91	–	private LinkedList setupMonitors() {
92	–	LinkedList monitors = new LinkedList();
93	–	// add monitors - this should use config/reflection...
94	–	monitors.add(new uk.ac.ukc.iscream.client.monitors.CPU__Monitor());
95	–	return monitors;
96	–	}
239
240		//---ACCESSOR/MUTATOR METHODS---
241	<
241	>
242	>	/**
243	>	* Allows Monitors to obtain
244	>	* the queue of data packets
245	>	*/
246	>	public Queue getDataQueue() {
247	>	return _dataQueue;
248	>	}
249	>
250	>	/**
251	>	* Allows Monitors to obtain
252	>	* the queue of all other packets
253	>	*/
254	>	public Queue getOtherQueue() {
255	>	return _otherQueue;
256	>	}
257	>
258	>	/**
259	>	* In case a Monitor wants more
260	>	* than one type of packet,
261	>	* this queue can be obtained.
262	>	*/
263	>	public Queue getAllQueue() {
264	>	return _allQueue;
265	>	}
266	>
267		//---ATTRIBUTES---
268
269		/**
#	Line 117 | Line 284 | class MonitorManager extends Thread{
284		private Logger _logger = ReferenceManager.getInstance().getLogger();
285
286		/**
287	<	* A reference to our QUeue
287	>	* A reference to the reference manager in use
288		*/
289	+	private ReferenceManager _refman = ReferenceManager.getInstance();
290	+
291	+	/**
292	+	* A reference to our incoming Queue
293	+	*/
294		private Queue _queue;
295	<
295	>
296	>	/**
297	>	* Our incoming queue ID
298	>	*/
299	>	private int _qID;
300	>
301	>	/**
302	>	* file name suffix for plugin monitor classes:
303	>	*/
304	>	private final String _suffix = "__Monitor";
305	>
306	>	/**
307	>	* LinkedList for holding the PluginMonitor objects (the pipeline).
308	>	*/
309	>	private LinkedList _monitorPipeline = new LinkedList();
310	>
311	>	/**
312	>	* Outgoing data Queue
313	>	*/
314	>	private Queue _dataQueue;
315	>
316	>	/**
317	>	* Outgoing other Queue
318	>	*/
319	>	private Queue _otherQueue;
320	>
321	>	/**
322	>	* Outgoing ALL Queue
323	>	*/
324	>	private Queue _allQueue;
325	>
326	>	/**
327	>	* A reference to the XMLCache in use
328	>	*/
329	>	private XMLCache _xmlCache = XMLCache.getInstance();
330	>
331		//---STATIC ATTRIBUTES---
332	+
333	+	/**
334	+	* A reference to the single instance of this class
335	+	*/
336	+	private static MonitorManager _instance;
337
338		}

Diff Legend

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