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.8 by ab11, Tue Mar 27 00:04:30 2001 UTC

#	Line 11 | Line 11 | SysMon::SysMon( Config config, int printDebug){
11		// setup some standard variables
12		sequence = 0; // no packets sent yet
13
14	–	// get our values from config
15	–
16	–
14		// setup our arrays
15		titlepointer = 0;
16	<	for ( int i=0; i < 40; i++ ){
16	>	for ( int i=0; i < max_titles; i++ ){
17		titles[i] = "";
18		values[i] = "";
19		}
#	Line 28 | Line 25 | SysMon::SysMon( Config config, int printDebug){
25		int SysMon::collect(){
26		if ( debug == 1 ){
27		std::cout << "SysMon::collect()\n";
28	<	}
28	>	} // if
29
30		// say we have checked again
31		checks++;
32
33		// collect the system data and place it in an array of strings.
34		// presume that the data is all formtted correctly.
35	<	char input[2048];
35	>
36		if ( debug == 1 ){
37		std::cout << "SysMon::collect::ipipestream\n";
38		}
39	<	ipipestream p("statgrab.pl");
39	>
40	>	p = new SubPipe("./statgrab.pl");
41
42		// get the output into input from statgrab
43	<	while ( p.getline (input, 2048) ){
44	<	// find the first non-whitespace char in input
45	<	string sinput = input;
43	>	string sinput;
44	>	while ( p->getLine(&sinput) == 0 ){
45	>
46	>	if ( titlepointer == max_titles ){
47	>	std::cout << "WARNING: Max Titles reached, skipping remaining" << endl;
48	>	std::cout << "Try recompiling with a value greater than the current (" << max_titles << ")" << endl;
49	>	titlepointer--;
50	>	break;
51	>	} // if
52	>
53		// locate the first white space
54		int found = sinput.find(" ",0);
55		if ( found == string::npos ){
56		// error
57		if ( debug == 1 ){
58		std::cout << "SysMon::collect::Parse error from statgrab.pl\n";
59	<	}
59	>	} // if
60		} else {
61		int gotTitle = 0;
62		// now use the array of titles and values
63	<	for ( int i = 0; i < 60; i++ ){
63	>	for ( int i = 0; i < max_titles; i++ ){
64		// check against the array value
65		if ( titles[i] == sinput.substr(0,found) ){
66		// is the one we are looking for.
67		if ( debug == 2 ){
68		std::cout << "SysMon::collect::Found Value\n";
69	<
70	<	}
69	>	} // if debug
70	>
71		gotTitle = 1;
72		// now modify the data in the arrays if they are numbers
73	<	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
73	>	} // if (titles[i])
74		} // for
75	+
76		// did we find this title? if not add it
77		if ( gotTitle == 0 ){
78		// didnt
79		if ( debug == 1 ){
80	<	std::cout << "SysMon::collect::Adding New Value\n";
81	<	std::cout << "'" << sinput.substr(0,found) << "'\n";
82	<	std::cout << "'" <<  sinput.substr(found+1, sinput.length()) << "'\n";
83	<	}
80	>	std::cout << "SysMon::collect::Adding New Value\n";
81	>	std::cout << "'" << sinput.substr(0,found) << "' : ";
82	>	std::cout << "'" <<  sinput.substr(found+1, sinput.length()) << "'\n";
83	>	} // if
84		titles[titlepointer] = sinput.substr(0,found);
85		values[titlepointer] = sinput.substr(found+1, sinput.length());
86		titlepointer++;
#	Line 104 | Line 90 | int SysMon::collect(){
90
91		} // while
92
93	<	// delete p;
93	>	// delete the pointer to free up memory
94	>	delete p;
95
96		if ( debug == 1 ){
97		std::cout << "SysMon::collect::Parse from StatGrab finished\n";
98	<	}
98	>	} // if
99
113	–	// alert?
114	–	// return 1;
115	–
100		// return sucessful
101		return 0;
102
103		} // collect
104
105	+	void SysMon::clearData(){
106	+
107	+	titlepointer = 0;
108	+	for ( int i=0; i < max_titles; i++ ){
109	+	titles[i] = "";
110	+	values[i] = "";
111	+	} // for
112	+
113	+	return;
114	+
115	+	} // clearData
116	+
117	+
118		string SysMon::getData(){
119
120		if ( debug == 1 ){
121		std::cout << "SysMon::getData()\n";
122	<	}
122	>	} // if
123
124		// create an xml object
125		XMLFormatter xml = XMLFormatter();
126
127	<	int i=0;
127	>	if ( debug == 1 ){
128	>	std::cout << "SysMon::getData::Sorting " << titlepointer << " elements\n";
129	>	} // if
130	>
131	>	// firstly sort the data.
132	>	// simple bubble sort
133	>	int flag = 1;
134	>	while ( flag == 1 ){
135	>	flag = 0;
136	>	for ( int i=1; i<=titlepointer; i++ ){
137	>	if (titles[i-1].compare(titles[i]) > 0 ){
138	>	// swap them
139	>	string temp;
140	>	temp = titles[i-1];
141	>	titles[i-1] = titles[i];
142	>	titles[i] = temp;
143	>	// now do the values
144	>	temp = values[i-1];
145	>	values[i-1] = values[i];
146	>	values[i] = temp;
147	>	// say we have changed something
148	>	flag = 1;
149	>	}  // if
150	>	} // for
151	>	} // while
152	>
153	>	/* used to check the array has sorted correctly
154	>	for ( int i=0; i < titlepointer; i++ ){
155	>	std::cout << titles[i] << endl;
156	>	}
157	>	*/
158	>
159	>	// work through each one of the titles in turn and
160	>	// work out their levels.
161	>
162		int count = 0;
163	<	int finished = 0;
164	<	string root = "packet.";
165	<	string level = root;
163	>	string currentLevel = "packet";
164	>	string currentLevels[10];
165	>	int currentLevelint = 0;
166	>	int retryCount = 0;
167		string attributes = "";
168	<	string attr = "";
169	<	// 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
168	>	int isAttrib = 0;
169	>	string attributeLevel = "";
170
171	<
171	>	// init that array quickly ;)
172	>	for ( int i=0; i< 10; i++ ){
173	>	currentLevels[i] = "";
174	>	} // for
175
176	<
177	<	} else { // if doesn't contains level
178	<
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
176	>	if ( debug == 1 ){
177	>	std::cout << "SysMon::getData::Starting while\n";
178	>	} // if
179
180	<
181	<
182	<
183	<
184	<
185	<
180	>	while ( count <= titlepointer ){
181	>
182	>	if ( debug == 1 ){
183	>	std::cout << "Processing: " << titles[count] << endl;
184	>	} // if
185	>
186	>	retryCount++;
187	>
188	>	currentLevel = "";
189	>	for ( int i=0; i<currentLevelint; i++ ){
190	>	if (( currentLevel != "" ) && ( i != currentLevelint )){
191	>	currentLevel += ".";
192	>	} // if
193	>	currentLevel += currentLevels[i];
194	>	} // for
195	>
196	>	// set the title into a variable
197	>	string currentTitle = titles[count];
198	>
199	>	// make an array of strings to hold the levels
200	>	string levels[10];
201	>	for ( int i=0; i< 10; i++ ){
202	>	levels[i] = "";
203	>	} // for
204	>	int level = 0;
205	>
206	>
207	>	// firstly find the first .
208	>	int dotPosition = currentTitle.find(".");
209	>
210	>	while ( dotPosition != string::npos ){
211	>
212	>	levels[level] = currentTitle.substr(0,dotPosition);
213	>
214	>	// now remove this bit
215	>	currentTitle = currentTitle.substr(dotPosition+1);
216	>
217	>	// now find the position of the next dot
218	>	dotPosition = currentTitle.find(".");
219	>
220	>	// increment level etc
221	>	level++;
222	>
223	>	// we already are at 'packet' level because of
224	>	// the outer packet tags, get rif of it , only
225	>	// first one mind!
226	>	if ( levels[0] == "packet" ){
227	>	level--;
228	>	} // if
229	>
230	>	} // while dotPosition
231	>
232	>	// now grab the value title
233	>	levels[level] = currentTitle;
234	>
235	>	// now have the levels and the level depth.
236	>	// check it against the last one, reconstruct a
237	>	// level string
238	>
239	>	// only do this if the 2nd to last string is not
240	>	// atrribute
241	>	string newLevelString = "";
242	>
243	>	if ( level > 0 ){
244	>	if ( levels[level-1] != "attributes" ){
245	>	// say it isn't an attribute, but write out
246	>	// the attribute first if the last one was
247	>	if ( attributeLevel != "" ){
248	>	xml.addElement(attributeLevel,attributes,"");
249	>	if ( debug == 1 ){
250	>	std::cout << "Adding Element + attributes" << endl;
251	>	} // if
252	>
253	>	} // if
254	>	isAttrib = 0;
255	>	attributeLevel = "";
256	>	attributes = "";
257	>
258	>	for ( int i=0; i < level; i++ ){
259	>	newLevelString += levels[i];
260	>	if ( i != level-1 ){
261	>	newLevelString += ".";
262	>	} // if
263	>	} // for
264	>	} // if levels[level]
265	>
266	>	else
267	>
268	>	{
269	>	// we need to add to the attributes
270	>	level -= 2;
271	>	for ( int i=0; i < level; i++ ){
272	>	newLevelString += levels[i];
273	>	if ( i != level-1 ){
274	>	newLevelString += ".";
275	>	} // if
276	>	} // for
277	>
278	>	isAttrib = 1;
279	>	if ( attributeLevel == "" ){
280	>	// set this attribute to be the level
281	>	attributeLevel = levels[level];
282	>	} else {
283	>	if ( levels[level] != attributeLevel ){
284	>	// arrg! its a different level!
285	>	if ( attributeLevel != levels[level] ){
286	>	xml.addElement(attributeLevel,attributes,"");
287	>	if ( debug == 1 ){
288	>	std::cout << "Adding Element + attributes1" << endl;
289	>	} // if
290	>	attributeLevel = "";
291	>	attributes = "";
292	>	count++;
293	>	} // if
294	>	if ( count == titlepointer ){
295	>	xml.addElement(attributeLevel,attributes,"");
296	>	if ( debug == 1 ){
297	>	std::cout << "Adding Element + attributes2" << endl;
298	>	} // if
299	>	attributeLevel = "";
300	>	attributes = "";
301	>	count++;
302	>	} // if
303	>	} // if
304	>	} // if else
305	>
306	>	} // else attributes
307	>	} // if level > 1
308	>	else {
309	>	if ( count == titlepointer ){
310	>	if ( attributeLevel != "" ){
311	>	xml.addElement(attributeLevel,attributes,"");
312	>	if ( debug == 1 ){
313	>	std::cout << "Adding Element + attributes3" << endl;
314	>	} // if
315	>	attributeLevel = "";
316	>	attributes = "";
317	>	count++;
318	>	} // if
319	>	} // if
320	>
321	>
322	>	for ( int i=0; i < level; i++ ){
323	>	newLevelString += levels[i];
324	>	if ( i != level-1 ){
325	>	newLevelString += ".";
326	>	} // if
327	>	} // for
328	>	} // if level == 1
329	>
330	>	// check if it is the same
331	>	if ( newLevelString == currentLevel ){
332	>	// it is the same level, just add this as another element
333	>	if ( isAttrib ){
334	>	attributes += levels[level+2];
335	>	attributes += "=\"";
336	>	attributes += values[count];
337	>	attributes += "\" ";
338	>
339	>	} else {
340	>	xml.addElement(levels[level],  values[count]);
341	>	count++;
342	>	if ( debug == 1 ){
343	>	std::cout << "Adding Element" << endl;
344	>	} // if
345	>	} // if
346	>
347	>	} else {
348	>	// gotta change it
349	>
350	>	while( newLevelString.find(currentLevel) == string::npos ){
351	>
352	>	if ( currentLevelint <= 0 ){
353	>	break;
354	>	} // if
355	>
356	>	// back up atleast one level...
357	>	xml.closeNest();
358	>	if ( debug == 1 ){
359	>	std::cout << "Closing Nest" << endl;
360	>	} // if
361	>	// remove the last item
362	>	currentLevelint--;
363	>
364	>	currentLevel = "";
365	>	for ( int i=0; i<currentLevelint; i++ ){
366	>	currentLevel += currentLevels[i];
367	>	if ( i != currentLevelint-1 ){
368	>	currentLevel += ".";
369	>	} // if
370	>	} // for
371	>
372	>	} // while
373	>
374	>
375	>	while ( newLevelString != currentLevel ){
376	>
377	>	// now got to a level which we like.
378	>	currentLevels[currentLevelint] = levels[currentLevelint];
379	>
380	>	// add in one more level and restart the loop
381	>	xml.addNest(levels[currentLevelint]);
382	>	if ( debug == 1 ){
383	>	std::cout << "Adding nest " << levels[currentLevelint] << endl;
384	>	} // if
385	>
386	>	// set this to be the top level of the new level
387	>	currentLevelint++;
388	>
389	>	currentLevel = "";
390	>	for ( int i=0; i<currentLevelint; i++ ){
391	>	currentLevel += currentLevels[i];
392	>	if ( i != currentLevelint-1 ){
393	>	currentLevel += ".";
394	>	} // if
395	>	} // for
396	>
397	>	} // while
398	>
399	>
400	>	} // if
401	>
402	>	if ( debug == 1 ){
403	>	std::cout << "Retrying Main While" << endl;
404	>	} // if
405	>
406	>	if ( retryCount > 10 ){
407	>	count++;
408	>	if ( debug == 1 ){
409	>	std::cout << "Tried too many times" << endl;
410	>	} // if
411	>	retryCount = 0;
412	>	} // if
413	>
414	>	} // while
415	>
416	>	if ( debug == 1 ){
417	>	std::cout << "\n";
418	>	} // if
419	>
420		// return the string
421		return xml.returnXML();
422

Diff Legend

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