ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/cms/source/host/c++/SysMon.cpp
(Generate patch)

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