ViewVC Help

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

root/i-scream/projects/cms/source/host/c++/SysMon.cpp

Comparing projects/cms/source/host/c++/SysMon.cpp (file contents):
Revision 1.2 by ab11, Mon Mar 5 12:38:35 2001 UTC vs.
Revision 1.9 by tdb, Sat May 18 18:15:56 2002 UTC

#	Line 1 | Line 1
1	+	/*
2	+	* i-scream central monitoring system
3	+	* Copyright (C) 2000-2002 i-scream
4	+	*
5	+	* This program is free software; you can redistribute it and/or
6	+	* modify it under the terms of the GNU General Public License
7	+	* as published by the Free Software Foundation; either version 2
8	+	* of the License, or (at your option) any later version.
9	+	*
10	+	* This program is distributed in the hope that it will be useful,
11	+	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	+	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13	+	* GNU General Public License for more details.
14	+	*
15	+	* You should have received a copy of the GNU General Public License
16	+	* along with this program; if not, write to the Free Software
17	+	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18	+	*/
19	+
20		#include "SysMon.h"
21
22		SysMon::SysMon( Config config, int printDebug){
#	Line 11 | Line 30 | SysMon::SysMon( Config config, int printDebug){
30		// setup some standard variables
31		sequence = 0; // no packets sent yet
32
14	–	// get our values from config
15	–
16	–
33		// setup our arrays
34		titlepointer = 0;
35	<	for ( int i=0; i < 40; i++ ){
35	>	for ( int i=0; i < max_titles; i++ ){
36		titles[i] = "";
37		values[i] = "";
38		}
#	Line 28 | Line 44 | SysMon::SysMon( Config config, int printDebug){
44		int SysMon::collect(){
45		if ( debug == 1 ){
46		std::cout << "SysMon::collect()\n";
47	<	}
47	>	} // if
48
49		// say we have checked again
50		checks++;
51
52		// collect the system data and place it in an array of strings.
53		// presume that the data is all formtted correctly.
54	<	char input[2048];
54	>
55		if ( debug == 1 ){
56		std::cout << "SysMon::collect::ipipestream\n";
57		}
58	<	ipipestream p("statgrab.pl");
58	>
59	>	p = new SubPipe("./statgrab.pl");
60
61		// get the output into input from statgrab
62	<	while ( p.getline (input, 2048) ){
63	<	// find the first non-whitespace char in input
64	<	string sinput = input;
62	>	string sinput;
63	>	while ( p->getLine(&sinput) == 0 ){
64	>
65	>	if ( titlepointer == max_titles ){
66	>	std::cout << "WARNING: Max Titles reached, skipping remaining" << endl;
67	>	std::cout << "Try recompiling with a value greater than the current (" << max_titles << ")" << endl;
68	>	titlepointer--;
69	>	break;
70	>	} // if
71	>
72		// locate the first white space
73		int found = sinput.find(" ",0);
74		if ( found == string::npos ){
75		// error
76		if ( debug == 1 ){
77		std::cout << "SysMon::collect::Parse error from statgrab.pl\n";
78	<	}
78	>	} // if
79		} else {
80		int gotTitle = 0;
81		// now use the array of titles and values
82	<	for ( int i = 0; i < 60; i++ ){
82	>	for ( int i = 0; i < max_titles; i++ ){
83		// check against the array value
84		if ( titles[i] == sinput.substr(0,found) ){
85		// is the one we are looking for.
86		if ( debug == 2 ){
87		std::cout << "SysMon::collect::Found Value\n";
88	<
89	<	}
88	>	} // if debug
89	>
90		gotTitle = 1;
91		// now modify the data in the arrays if they are numbers
92	<	int * end;
69	<	char *buffer;
70	<	// buffer = sinput.substr(found+1, sinput.length());
71	<	double dbl = 0; // strtod((char *) sinput.substr(found+1, sinput.length()), &end);
72	<	if ( dbl == 0 ){
73	<	// error? we aren't so sure. check the position
74	<	// of end.
75	<	if ( *end == sinput.length()-1 ){
76	<	// was the end.. ok
77	<
78	<	} // if
79	<	} else {
80	<	// must have worked!
81	<	double dbl2 = 0; //strtod(values[i], &end);
82	<	dbl2 += dbl;
83	<	char *buffer;
84	<	int precision = 5;
85	<	int decimal, sign;
86	<	buffer = ecvt (dbl2, precision, &decimal, &sign);
87	<	} // if
88	<	} // if
92	>	} // if (titles[i])
93		} // for
94	+
95		// did we find this title? if not add it
96		if ( gotTitle == 0 ){
97		// didnt
98		if ( debug == 1 ){
99	<	std::cout << "SysMon::collect::Adding New Value\n";
100	<	std::cout << "'" << sinput.substr(0,found) << "'\n";
101	<	std::cout << "'" <<  sinput.substr(found+1, sinput.length()) << "'\n";
102	<	}
99	>	std::cout << "SysMon::collect::Adding New Value\n";
100	>	std::cout << "'" << sinput.substr(0,found) << "' : ";
101	>	std::cout << "'" <<  sinput.substr(found+1, sinput.length()) << "'\n";
102	>	} // if
103		titles[titlepointer] = sinput.substr(0,found);
104		values[titlepointer] = sinput.substr(found+1, sinput.length());
105		titlepointer++;
#	Line 104 | Line 109 | int SysMon::collect(){
109
110		} // while
111
112	<	// delete p;
112	>	// delete the pointer to free up memory
113	>	delete p;
114
115		if ( debug == 1 ){
116		std::cout << "SysMon::collect::Parse from StatGrab finished\n";
117	<	}
117	>	} // if
118
113	–	// alert?
114	–	// return 1;
115	–
119		// return sucessful
120		return 0;
121
122		} // collect
123
124	+	void SysMon::clearData(){
125	+
126	+	titlepointer = 0;
127	+	for ( int i=0; i < max_titles; i++ ){
128	+	titles[i] = "";
129	+	values[i] = "";
130	+	} // for
131	+
132	+	return;
133	+
134	+	} // clearData
135	+
136	+
137		string SysMon::getData(){
138
139		if ( debug == 1 ){
140		std::cout << "SysMon::getData()\n";
141	<	}
141	>	} // if
142
143		// create an xml object
144		XMLFormatter xml = XMLFormatter();
145
146	<	int i=0;
146	>	if ( debug == 1 ){
147	>	std::cout << "SysMon::getData::Sorting " << titlepointer << " elements\n";
148	>	} // if
149	>
150	>	// firstly sort the data.
151	>	// simple bubble sort
152	>	int flag = 1;
153	>	while ( flag == 1 ){
154	>	flag = 0;
155	>	for ( int i=1; i<=titlepointer; i++ ){
156	>	if (titles[i-1].compare(titles[i]) > 0 ){
157	>	// swap them
158	>	string temp;
159	>	temp = titles[i-1];
160	>	titles[i-1] = titles[i];
161	>	titles[i] = temp;
162	>	// now do the values
163	>	temp = values[i-1];
164	>	values[i-1] = values[i];
165	>	values[i] = temp;
166	>	// say we have changed something
167	>	flag = 1;
168	>	}  // if
169	>	} // for
170	>	} // while
171	>
172	>	/* used to check the array has sorted correctly
173	>	for ( int i=0; i < titlepointer; i++ ){
174	>	std::cout << titles[i] << endl;
175	>	}
176	>	*/
177	>
178	>	// work through each one of the titles in turn and
179	>	// work out their levels.
180	>
181		int count = 0;
182	<	int finished = 0;
183	<	string root = "packet.";
184	<	string level = root;
182	>	string currentLevel = "packet";
183	>	string currentLevels[10];
184	>	int currentLevelint = 0;
185	>	int retryCount = 0;
186		string attributes = "";
187	<	string attr = "";
188	<	// while (  i < titlepointer ){
138	<	// hard coding
139	<	while ( i < 10 ){
140	<	finished = 0;
141	<	count = 0;
142	<	attr = "";
143	<	while ( finished != 1 ){
144	<	count++;
145	<	if ( count > 10 ){
146	<	// don't do more than 10 times.. its probably not gonna work!
147	<	finished = 1;
148	<	}
149	<
150	<	// do for each item
151	<	int where = titles[i].find(level,0);
152	<
153	<	// where now contains the position of 'level'
154	<	if ( where != string::npos ){
155	<	// we found it, now check the size to see if this is the final level
156	<	// grab the end bit a look for .'s
157	<	string end = titles[i].substr(level.length(), titles[i].length()-level.length() );
158	<
159	<	// now end should contain "something.something" etc
160	<	// look to find a . in there that means more to traverse
161	<	// but check for 'attributes' tags...
162	<
163	<	where = end.find("attributes.",0);
164	<	if ( where != string::npos ){
165	<	// is an attribute
166	<	// need to check that there are no more levels above this one
167	<
168	<
169	<
170	<	/*
171	<
172	<	// where points to the start of attributes
173	<	int start = 0;
174	<	if ( level.find(".",start) < where-1 ){
175	<	start = level.find(".", start);
176	<	} // if
177	<
178	<	// start points to the thing to apply the attributes to.
179	<	// need to take the level upto before this point
180	<	string needLevel = end.substr(0,start-2);
181	<	std::cout << "needlevel " << needLevel << endl;
182	<
183	<	// now we need to find the level we are at
184	<	while (( needLevel.length() > 0 ) && (needLevel.find(".",0) != string::npos ) ){
185	<	int got = needLevel.find(".",0);
186	<	if ( got != string::npos ){
187	<	// we need to grab up until the .
188	<	xml.addNest(needLevel.substr(0,got));
189	<	level += needLevel.substr(0,got);
190	<	level += ".";
191	<	std::cout << "Adding Nest " << needLevel.substr(0,got) << endl;
192	<	needLevel = needLevel.substr(got+1, needLevel.length()-(got+1));
193	<	} // if
194	<	std::cout << "needlevel " << needLevel << endl;
195	<	} // while
196	<
197	<	// add the final nest
198	<	xml.addNest(needLevel);
199	<	level += needLevel;
200	<	level += ".";
201	<	std::cout << "Adding Nest " << needLevel << endl;
202	<
203	<	*/
204	<
205	<	// now write out the variable
206	<	xml.addElement(end, values[i]);
207	<	finished = 1;
208	<
209	<	} else {
210	<	if ( where == 0 ){
211	<	// this is something we care about.
212	<	// it has an attribute tab, and thus we want to add it
213	<	// to the tag one lower than this (hopefully level!)
214	<
215	<	// attributes = attributes + mount
216	<	attributes += end.substr(where+11, end.length()-(where+11));
217	<	// attributes = attributes + mount="
218	<	attributes += "=\"";
219	<	// attributes = attributes + mount="/dev
220	<	attributes += values[i];
221	<	// attributes = attributes + mount="/dev"
222	<	attributes += "\" ";
223	<	} else {
224	<	// need to check if we are the last element before
225	<	// an attribute tag, so we want to get up to this tag first
226	<	while ( end.find(".",0) != string::npos ){
227	<
228	<	where = end.find(".",0);
229	<	string newNest = end.substr(0,where);
230	<	xml.addNest(newNest);
231	<	level += newNest;
232	<	level += ".";
233	<	// redefine end
234	<	end = end.substr(where+1, end.length()-(where+1));
235	<	} // while
236	<
237	<
238	<	xml.addElement(end, values[i]);
239	<	finished = 1;
240	<	} // if where == 0
241	<	} // if attribute tags
187	>	int isAttrib = 0;
188	>	string attributeLevel = "";
189
190	<
190	>	// init that array quickly ;)
191	>	for ( int i=0; i< 10; i++ ){
192	>	currentLevels[i] = "";
193	>	} // for
194
195	<
196	<	} else { // if doesn't contains level
197	<
248	<	// we need to move one back and try again, until we are all the way
249	<	// back to "packet."
250	<	// go about it by closing nests
251	<
252	<	while ( level.length() > root.length() ){
253	<	// need to close one nest and locate the next . from the end (hassle)
254	<	int start = 0;
255	<	if ( level.find(".",start) != string::npos ){
256	<	start = level.find(".", start);
257	<	} // if
258	<	// should now have the last .
259	<	xml.closeNest();
260	<	level = level.substr(0, start+1);
261	<	}
262	<
263	<	} // if contains level
264	<
265	<	} // while
266	<	i++;
267	<	} // while
195	>	if ( debug == 1 ){
196	>	std::cout << "SysMon::getData::Starting while\n";
197	>	} // if
198
199	<
200	<
201	<
202	<
203	<
204	<
199	>	while ( count <= titlepointer ){
200	>
201	>	if ( debug == 1 ){
202	>	std::cout << "Processing: " << titles[count] << endl;
203	>	} // if
204	>
205	>	retryCount++;
206	>
207	>	currentLevel = "";
208	>	for ( int i=0; i<currentLevelint; i++ ){
209	>	if (( currentLevel != "" ) && ( i != currentLevelint )){
210	>	currentLevel += ".";
211	>	} // if
212	>	currentLevel += currentLevels[i];
213	>	} // for
214	>
215	>	// set the title into a variable
216	>	string currentTitle = titles[count];
217	>
218	>	// make an array of strings to hold the levels
219	>	string levels[10];
220	>	for ( int i=0; i< 10; i++ ){
221	>	levels[i] = "";
222	>	} // for
223	>	int level = 0;
224	>
225	>
226	>	// firstly find the first .
227	>	int dotPosition = currentTitle.find(".");
228	>
229	>	while ( dotPosition != string::npos ){
230	>
231	>	levels[level] = currentTitle.substr(0,dotPosition);
232	>
233	>	// now remove this bit
234	>	currentTitle = currentTitle.substr(dotPosition+1);
235	>
236	>	// now find the position of the next dot
237	>	dotPosition = currentTitle.find(".");
238	>
239	>	// increment level etc
240	>	level++;
241	>
242	>	// we already are at 'packet' level because of
243	>	// the outer packet tags, get rif of it , only
244	>	// first one mind!
245	>	if ( levels[0] == "packet" ){
246	>	level--;
247	>	} // if
248	>
249	>	} // while dotPosition
250	>
251	>	// now grab the value title
252	>	levels[level] = currentTitle;
253	>
254	>	// now have the levels and the level depth.
255	>	// check it against the last one, reconstruct a
256	>	// level string
257	>
258	>	// only do this if the 2nd to last string is not
259	>	// atrribute
260	>	string newLevelString = "";
261	>
262	>	if ( level > 0 ){
263	>	if ( levels[level-1] != "attributes" ){
264	>	// say it isn't an attribute, but write out
265	>	// the attribute first if the last one was
266	>	if ( attributeLevel != "" ){
267	>	xml.addElement(attributeLevel,attributes,"");
268	>	if ( debug == 1 ){
269	>	std::cout << "Adding Element + attributes" << endl;
270	>	} // if
271	>
272	>	} // if
273	>	isAttrib = 0;
274	>	attributeLevel = "";
275	>	attributes = "";
276	>
277	>	for ( int i=0; i < level; i++ ){
278	>	newLevelString += levels[i];
279	>	if ( i != level-1 ){
280	>	newLevelString += ".";
281	>	} // if
282	>	} // for
283	>	} // if levels[level]
284	>
285	>	else
286	>
287	>	{
288	>	// we need to add to the attributes
289	>	level -= 2;
290	>	for ( int i=0; i < level; i++ ){
291	>	newLevelString += levels[i];
292	>	if ( i != level-1 ){
293	>	newLevelString += ".";
294	>	} // if
295	>	} // for
296	>
297	>	isAttrib = 1;
298	>	if ( attributeLevel == "" ){
299	>	// set this attribute to be the level
300	>	attributeLevel = levels[level];
301	>	} else {
302	>	if ( levels[level] != attributeLevel ){
303	>	// arrg! its a different level!
304	>	if ( attributeLevel != levels[level] ){
305	>	xml.addElement(attributeLevel,attributes,"");
306	>	if ( debug == 1 ){
307	>	std::cout << "Adding Element + attributes1" << endl;
308	>	} // if
309	>	attributeLevel = "";
310	>	attributes = "";
311	>	count++;
312	>	} // if
313	>	if ( count == titlepointer ){
314	>	xml.addElement(attributeLevel,attributes,"");
315	>	if ( debug == 1 ){
316	>	std::cout << "Adding Element + attributes2" << endl;
317	>	} // if
318	>	attributeLevel = "";
319	>	attributes = "";
320	>	count++;
321	>	} // if
322	>	} // if
323	>	} // if else
324	>
325	>	} // else attributes
326	>	} // if level > 1
327	>	else {
328	>	if ( count == titlepointer ){
329	>	if ( attributeLevel != "" ){
330	>	xml.addElement(attributeLevel,attributes,"");
331	>	if ( debug == 1 ){
332	>	std::cout << "Adding Element + attributes3" << endl;
333	>	} // if
334	>	attributeLevel = "";
335	>	attributes = "";
336	>	count++;
337	>	} // if
338	>	} // if
339	>
340	>
341	>	for ( int i=0; i < level; i++ ){
342	>	newLevelString += levels[i];
343	>	if ( i != level-1 ){
344	>	newLevelString += ".";
345	>	} // if
346	>	} // for
347	>	} // if level == 1
348	>
349	>	// check if it is the same
350	>	if ( newLevelString == currentLevel ){
351	>	// it is the same level, just add this as another element
352	>	if ( isAttrib ){
353	>	attributes += levels[level+2];
354	>	attributes += "=\"";
355	>	attributes += values[count];
356	>	attributes += "\" ";
357	>
358	>	} else {
359	>	xml.addElement(levels[level],  values[count]);
360	>	count++;
361	>	if ( debug == 1 ){
362	>	std::cout << "Adding Element" << endl;
363	>	} // if
364	>	} // if
365	>
366	>	} else {
367	>	// gotta change it
368	>
369	>	while( newLevelString.find(currentLevel) == string::npos ){
370	>
371	>	if ( currentLevelint <= 0 ){
372	>	break;
373	>	} // if
374	>
375	>	// back up atleast one level...
376	>	xml.closeNest();
377	>	if ( debug == 1 ){
378	>	std::cout << "Closing Nest" << endl;
379	>	} // if
380	>	// remove the last item
381	>	currentLevelint--;
382	>
383	>	currentLevel = "";
384	>	for ( int i=0; i<currentLevelint; i++ ){
385	>	currentLevel += currentLevels[i];
386	>	if ( i != currentLevelint-1 ){
387	>	currentLevel += ".";
388	>	} // if
389	>	} // for
390	>
391	>	} // while
392	>
393	>
394	>	while ( newLevelString != currentLevel ){
395	>
396	>	// now got to a level which we like.
397	>	currentLevels[currentLevelint] = levels[currentLevelint];
398	>
399	>	// add in one more level and restart the loop
400	>	xml.addNest(levels[currentLevelint]);
401	>	if ( debug == 1 ){
402	>	std::cout << "Adding nest " << levels[currentLevelint] << endl;
403	>	} // if
404	>
405	>	// set this to be the top level of the new level
406	>	currentLevelint++;
407	>
408	>	currentLevel = "";
409	>	for ( int i=0; i<currentLevelint; i++ ){
410	>	currentLevel += currentLevels[i];
411	>	if ( i != currentLevelint-1 ){
412	>	currentLevel += ".";
413	>	} // if
414	>	} // for
415	>
416	>	} // while
417	>
418	>
419	>	} // if
420	>
421	>	if ( debug == 1 ){
422	>	std::cout << "Retrying Main While" << endl;
423	>	} // if
424	>
425	>	if ( retryCount > 10 ){
426	>	count++;
427	>	if ( debug == 1 ){
428	>	std::cout << "Tried too many times" << endl;
429	>	} // if
430	>	retryCount = 0;
431	>	} // if
432	>
433	>	} // while
434	>
435	>	if ( debug == 1 ){
436	>	std::cout << "\n";
437	>	} // if
438	>
439		// return the string
440		return xml.returnXML();
441

Diff Legend

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