ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/libstatgrab/src/saidar/saidar.c
(Generate patch)

Comparing projects/libstatgrab/src/saidar/saidar.c (file contents):
Revision 1.34 by tdb, Wed Sep 7 14:15:40 2005 UTC vs.
Revision 1.37 by tdb, Fri Dec 1 00:38:39 2006 UTC

# Line 36 | Line 36
36   #include <sys/times.h>
37   #include <limits.h>
38   #include <time.h>
39 + #include <math.h>
40  
41   #ifdef HAVE_NCURSES_H
42   #include <ncurses.h>
# Line 43 | Line 44
44   #include <curses.h>
45   #endif
46  
47 + #define THRESHOLD_LOAD 1.0
48 +
49 + #define THRESHOLD_WARN_ZMB 0
50 +
51 + #define THRESHOLD_WARN_CPU 60.0
52 + #define THRESHOLD_ALERT_CPU 90.0
53 +
54 + #define THRESHOLD_WARN_SWAP 75.0
55 + #define THRESHOLD_ALERT_SWAP 90.0
56 +
57 + #define THRESHOLD_WARN_MEM 75.0
58 + #define THRESHOLD_ALERT_MEM 90.0
59 +
60 + #define THRESHOLD_WARN_DISK 75.0
61 + #define THRESHOLD_ALERT_DISK 90.0
62 +
63   typedef struct{
64          sg_cpu_percents *cpu_percents;
65          sg_mem_stats *mem_stats;
# Line 63 | Line 80 | typedef struct{
80          sg_host_info *host_info;
81          sg_user_stats *user_stats;
82   }stats_t;
83 <        
83 >
84   stats_t stats;
85  
86   char *size_conv(long long number){
# Line 88 | Line 105 | char *size_conv(long long number){
105  
106          snprintf(string, 10, "%lld%c", number, type[x]);
107          return string;
108 <        
108 >
109   }
110  
111   char *hr_uptime(time_t time){
112          int day = 0, hour = 0, min = 0;
113          static char uptime_str[25];
114          int sec = (int) time;
115 <        
115 >
116          day = sec / (24*60*60);
117          sec = sec % (24*60*60);
118          hour = sec / (60*60);
# Line 187 | Line 204 | void display_headings(){
204          move(10,15);
205          printw("Read");
206          move(10,28);
207 <        printw("Write");        
207 >        printw("Write");
208  
209          line = 10;
210          if (stats.network_io_stats != NULL) {
# Line 211 | Line 228 | void display_headings(){
228          refresh();
229   }
230  
231 < void display_data(){
231 > void display_data(int colors){
232          char cur_time[20];
233          struct tm *tm_time;
234          time_t epoc_time;
# Line 236 | Line 253 | void display_data(){
253                   */
254                  if (ptr != NULL){
255                          *ptr = '\0';
256 <                }      
256 >                }
257 >                if (colors) {
258 >                        attron(COLOR_PAIR(1));
259 >                }
260                  printw("%s", hostname);
261                  move(0,36);
262                  printw("%s", hr_uptime(stats.host_info->uptime));
# Line 245 | Line 265 | void display_data(){
265                  strftime(cur_time, 20, "%Y-%m-%d %T", tm_time);
266                  move(0,61);
267                  printw("%s", cur_time);
268 +                if (colors) {
269 +                        attroff(COLOR_PAIR(1));
270 +                }
271          }
272  
273          if (stats.load_stats != NULL) {
274                  /* Load */
275 +                if (colors) {
276 +                        attron(COLOR_PAIR(6));
277 +                }
278                  move(2,12);
279 +                if (colors && fabs(stats.load_stats->min1 - stats.load_stats->min5) > THRESHOLD_LOAD) {
280 +                        attron(A_BOLD);
281 +                }
282                  printw("%6.2f", stats.load_stats->min1);
283 +                if (colors) {
284 +                        attroff(A_BOLD);
285 +                }
286                  move(3,12);
287 +                if (colors && fabs(stats.load_stats->min5 - stats.load_stats->min15) > THRESHOLD_LOAD) {
288 +                        attron(A_BOLD);
289 +                }
290                  printw("%6.2f", stats.load_stats->min5);
291 +                if (colors) {
292 +                        attroff(A_BOLD);
293 +                }
294                  move(4,12);
295 +                if (colors && fabs(stats.load_stats->min1 - stats.load_stats->min15) > THRESHOLD_LOAD) {
296 +                        attron(A_BOLD);
297 +                }
298                  printw("%6.2f", stats.load_stats->min15);
299 +                if (colors) {
300 +                        attroff(A_BOLD);
301 +                }
302          }
303  
304          if (stats.cpu_percents != NULL) {
# Line 264 | Line 308 | void display_data(){
308                  move(3,33);
309                  printw("%6.2f%%", (stats.cpu_percents->kernel + stats.cpu_percents->iowait + stats.cpu_percents->swap));
310                  move(4,33);
311 +                if (colors && stats.cpu_percents->user + stats.cpu_percents->nice > THRESHOLD_ALERT_CPU) {
312 +                        attron(A_STANDOUT);
313 +                        attron(A_BOLD);
314 +                }
315 +                else if (colors && stats.cpu_percents->user + stats.cpu_percents->nice > THRESHOLD_WARN_CPU) {
316 +                        attron(A_BOLD);
317 +                }
318                  printw("%6.2f%%", (stats.cpu_percents->user + stats.cpu_percents->nice));
319 +                if(colors) {
320 +                        attroff(A_BOLD);
321 +                        attroff(A_STANDOUT);
322 +                        attron(COLOR_PAIR(6));
323 +                }
324          }
325  
326          if (stats.process_count != NULL) {
# Line 272 | Line 328 | void display_data(){
328                  move(2, 54);
329                  printw("%5d", stats.process_count->running);
330                  move(2,74);
331 +                if (colors && stats.process_count->zombie > THRESHOLD_WARN_ZMB) {
332 +                        attron(A_STANDOUT);
333 +                        attron(A_BOLD);
334 +                }
335                  printw("%5d", stats.process_count->zombie);
336 +                if(colors) {
337 +                        attroff(A_STANDOUT);
338 +                        attroff(A_BOLD);
339 +                }
340                  move(3, 54);
341                  printw("%5d", stats.process_count->sleeping);
342                  move(3, 74);
# Line 285 | Line 349 | void display_data(){
349                  printw("%5d", stats.user_stats->num_entries);
350          }
351  
352 +        if(colors) {
353 +                attroff(COLOR_PAIR(6));
354 +                attron(COLOR_PAIR(5));
355 +        }
356          if (stats.mem_stats != NULL) {
357                  /* Mem */
358                  move(6, 12);
359 <                printw("%7s", size_conv(stats.mem_stats->total));      
359 >                printw("%7s", size_conv(stats.mem_stats->total));
360                  move(7, 12);
361 <                printw("%7s", size_conv(stats.mem_stats->used));        
361 >                printw("%7s", size_conv(stats.mem_stats->used));
362                  move(8, 12);
363                  printw("%7s", size_conv(stats.mem_stats->free));
364          }
365 <        
366 <        if (stats.swap_stats != NULL) {
365 >
366 >        if (stats.swap_stats != NULL) {
367                  /* Swap */
368                  move(6, 32);
369                  printw("%8s", size_conv(stats.swap_stats->total));
# Line 306 | Line 374 | void display_data(){
374          }
375  
376          /* VM */
377 <        if (stats.mem_stats != NULL && stats.mem_stats->total != 0) {  
377 >        if (stats.mem_stats != NULL && stats.mem_stats->total != 0) {
378 >                float f = 100.00 * (float)(stats.mem_stats->used)/stats.mem_stats->total;
379 >                if (colors && f > THRESHOLD_ALERT_MEM) {
380 >                        attron(A_STANDOUT);
381 >                        attron(A_BOLD);
382 >                }
383 >                else if (colors && f > THRESHOLD_WARN_MEM) {
384 >                        attron(A_BOLD);
385 >                }
386                  move(6, 54);
387 <                printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used)/stats.mem_stats->total));
387 >                printw("%5.2f%%", f);
388 >                if (colors) {
389 >                        attroff(A_STANDOUT);
390 >                        attroff(A_BOLD);
391 >                        attron(COLOR_PAIR(5));
392 >                }
393          }
394 <        if (stats.swap_stats != NULL && stats.swap_stats->total != 0) {
394 >        if (stats.swap_stats != NULL && stats.swap_stats->total != 0) {
395 >                float f = 100.00 * (float)(stats.swap_stats->used)/stats.swap_stats->total;
396 >                if (colors && f > THRESHOLD_ALERT_SWAP) {
397 >                        attron(A_STANDOUT);
398 >                        attron(A_BOLD);
399 >                }
400 >                else if (colors && f > THRESHOLD_WARN_SWAP) {
401 >                        attron(A_BOLD);
402 >                }
403                  move(7, 54);
404 <                printw("%5.2f%%", (100.00 * (float)(stats.swap_stats->used)/stats.swap_stats->total));
404 >                printw("%5.2f%%", f);
405 >                if (colors) {
406 >                        attroff(A_STANDOUT);
407 >                        attroff(A_BOLD);
408 >                        attron(COLOR_PAIR(5));
409 >                }
410          }
411          if (stats.mem_stats != NULL && stats.swap_stats != NULL &&
412 <            stats.mem_stats->total != 0 && stats.swap_stats->total != 0) {      
412 >            stats.mem_stats->total != 0 && stats.swap_stats->total != 0) {
413                  move(8, 54);
414                  printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used+stats.swap_stats->used)/(stats.mem_stats->total+stats.swap_stats->total)));
415          }
416  
417 <        if (stats.page_stats != NULL) {
417 >        if (stats.page_stats != NULL) {
418                  /* Paging */
419                  move(6, 74);
420                  printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pagein / stats.page_stats->systime): stats.page_stats->pages_pagein);
421                  move(7, 74);
422                  printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pageout / stats.page_stats->systime) : stats.page_stats->pages_pageout);
423          }
424 +        if (colors) {
425 +                attroff(COLOR_PAIR(5));
426 +        }
427  
428          line = 11;
429 <        if (stats.disk_io_stats != NULL) {      
429 >        if (stats.disk_io_stats != NULL) {
430                  /* Disk IO */
431                  disk_io_stat_ptr = stats.disk_io_stats;
432                  r=0;
# Line 342 | Line 439 | void display_data(){
439                          printw("%s", name);
440                          move(line, 12);
441                          rt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->read_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->read_bytes;
442 +                        if(colors) {
443 +                                attron(COLOR_PAIR(4));
444 +                        }
445                          printw("%7s", size_conv(rt));
446                          r+=rt;
447                          move(line, 26);
# Line 350 | Line 450 | void display_data(){
450                          w+=wt;
451                          disk_io_stat_ptr++;
452                          line++;
453 +                        if(colors) {
454 +                                attroff(COLOR_PAIR(4));
455 +                        }
456                  }
457                  line++;
458                  move(line, 0);
459                  printw("Total");
460                  move(line, 12);
461 +                if(colors) {
462 +                        attron(COLOR_PAIR(4));
463 +                }
464                  printw("%7s", size_conv(r));
465                  move(line, 26);
466                  printw("%7s", size_conv(w));
467 +                if(colors) {
468 +                        attroff(COLOR_PAIR(4));
469 +                }
470          }
471  
472          line = 11;
473 <        if (stats.network_io_stats != NULL) {  
473 >        if (stats.network_io_stats != NULL) {
474                  /* Network */
475                  network_stat_ptr = stats.network_io_stats;
476                  for(counter=0;counter<stats.network_io_entries;counter++){
# Line 372 | Line 481 | void display_data(){
481                          printw("%s", name);
482                          move(line, 62);
483                          rt = (network_stat_ptr->systime)? (network_stat_ptr->rx / network_stat_ptr->systime): network_stat_ptr->rx;
484 +                        if(colors) {
485 +                                attron(COLOR_PAIR(4));
486 +                        }
487                          printw("%7s", size_conv(rt));
488                          move(line, 72);
489 <                        wt = (network_stat_ptr->systime)? (network_stat_ptr->tx / network_stat_ptr->systime): network_stat_ptr->tx;
489 >                        wt = (network_stat_ptr->systime)? (network_stat_ptr->tx / network_stat_ptr->systime): network_stat_ptr->tx;
490                          printw("%7s", size_conv(wt));
491                          network_stat_ptr++;
492                          line++;
493 +                        if(colors) {
494 +                                attroff(COLOR_PAIR(4));
495 +                        }
496                  }
497                  line += 2;
498          }
499  
500 <        if (stats.fs_stats != NULL) {  
500 >        if (stats.fs_stats != NULL) {
501                  /* Disk */
502                  disk_stat_ptr = stats.fs_stats;
503                  for(counter=0;counter<stats.fs_entries;counter++){
# Line 392 | Line 507 | void display_data(){
507                          move(line, 42);
508                          printw("%s", name);
509                          move(line, 62);
510 +                        if(colors) {
511 +                                attron(COLOR_PAIR(2));
512 +                        }
513                          printw("%7s", size_conv(disk_stat_ptr->avail));
514                          move(line, 73);
515 +                        if(colors && 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)) > THRESHOLD_ALERT_DISK) {
516 +                                attron(A_STANDOUT);
517 +                                attron(A_BOLD);
518 +                        } else if (colors && 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)) > THRESHOLD_WARN_DISK) {
519 +                                attron(A_BOLD);
520 +                        }
521                          printw("%6.2f%%", 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)));
522                          disk_stat_ptr++;
523                          line++;
524 +                        if(colors) {
525 +                                attroff(COLOR_PAIR(2));
526 +                                attroff(A_STANDOUT);
527 +                                attroff(A_BOLD);
528 +                        }
529                  }
530          }
531  
# Line 406 | Line 535 | void display_data(){
535   void sig_winch_handler(int dummy){
536          clear();
537          display_headings();
538 <        display_data();
538 >        display_data(0);
539          signal(SIGWINCH, sig_winch_handler);
540   }
541  
# Line 433 | Line 562 | void version_num(char *progname){
562   }
563  
564   void usage(char *progname){
565 <        fprintf(stderr, "Usage: %s [-d delay] [-v] [-h]\n\n", progname);
565 >        fprintf(stderr, "Usage: %s [-d delay] [-c] [-v] [-h]\n\n", progname);
566          fprintf(stderr, "  -d    Sets the update time in seconds\n");
567 +        fprintf(stderr, "  -c    Enables coloured output\n");
568          fprintf(stderr, "  -v    Prints version number\n");
569          fprintf(stderr, "  -h    Displays this help information.\n");
570          fprintf(stderr, "\nReport bugs to <%s>.\n", PACKAGE_BUGREPORT);
# Line 442 | Line 572 | void usage(char *progname){
572   }
573  
574   int main(int argc, char **argv){
445 –
575          extern char *optarg;
576          int c;
577 +        int colouron = 0;
578  
579          time_t last_update = 0;
580  
# Line 459 | Line 589 | int main(int argc, char **argv){
589                  fprintf(stderr, "Failed to drop setuid/setgid privileges\n");
590                  return 1;
591          }
592 <                
593 <        while ((c = getopt(argc, argv, "vhd:")) != -1){
592 >
593 >        while ((c = getopt(argc, argv, "d:cvh")) != -1){
594                  switch (c){
595                          case 'd':
596                                  delay = atoi(optarg);
# Line 469 | Line 599 | int main(int argc, char **argv){
599                                          exit(1);
600                                  }
601                                  break;
602 +                        case 'c':
603 +                                colouron = 1;
604 +                                break;
605                          case 'v':
606 <                                version_num(argv[0]);  
606 >                                version_num(argv[0]);
607                                  break;
608                          case 'h':
609                          default:
# Line 482 | Line 615 | int main(int argc, char **argv){
615  
616          signal(SIGWINCH, sig_winch_handler);
617          initscr();
618 +        /* turn on colour */
619 +        if (colouron) {
620 +                if (has_colors()) {
621 +                        start_color();
622 +                        use_default_colors();
623 +                        init_pair(1,COLOR_RED,-1);
624 +                        init_pair(2,COLOR_GREEN,-1);
625 +                        init_pair(3,COLOR_YELLOW,-1);
626 +                        init_pair(4,COLOR_BLUE,-1);
627 +                        init_pair(5,COLOR_MAGENTA,-1);
628 +                        init_pair(6,COLOR_CYAN,-1);
629 +                } else {
630 +                        fprintf(stderr, "Colour support disabled: your terminal does not support colour.");
631 +                        colouron = 0;
632 +                }
633 +        }
634          nonl();
635          cbreak();
636          noecho();
# Line 514 | Line 663 | int main(int argc, char **argv){
663                  }
664                  last_update = now;
665  
666 <                display_data();
667 <        }      
666 >                display_data(colouron);
667 >        }
668  
669          endwin();
670          return 0;
671 < }      
671 > }

Diff Legend

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