capq.c

   1 /*
   2  * capq - print out state of CAP queue (obtained from capqd).
   3  *
   4  * capq [-c] [-i interval] [-h cap-host]
   5  *
   6  * Author: Paul Mackerras, June 1993.
   7  */
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <stdlib.h>
  11 #include <errno.h>
  12 #include <math.h>
  13 #include <signal.h>
  14 #include <sys/types.h>
  15 #include <sys/time.h>
  16 #include <sys/socket.h>
  17 #include <sys/termios.h>
  18 #include <netinet/in.h>
  19 #include <arpa/inet.h>
  20 #include <netdb.h>
  21 #include <termios.h>
  22
  23 #define CAPQD_PORT      6123    /* capqd's well-known port number */
  24 #define CAP_HOST_DFLT   "cafe"  /* default value for -h option */
  25
  26 FILE *capqd_w, *capqd_r;        /* streams to and from capqd */
  27 char *cap_host;                 /* hostname where capqd is */
  28
  29 /* used for terminal capabilities */
  30 char termcap_entry[1024], string_caps[1024];
  31
  32 #define MAXLINES        100     /* max # lines for continuous display */
  33 #define MAXCOLS         100     /* max # columns  */
  34
  35 double last_change_time;        /* cap_host's time of last queue change */
  36 double our_time;                /* time according to our clock */
  37 double host_time_diff;          /* cap_host's clock - our clock */
  38 double timez[MAXLINES];         /* start time for each line of display */
  39 int num_lines;                  /* # entries valid in timez[] */
  40
  41 /* Convert from a timeval to a floating-point number of seconds */
  42 #define double_time(x)          ((x)->tv_sec + (x)->tv_usec / 1.0E6)
  43
  44 /* Termcap routines */
  45 extern int tgetent();
  46 extern int tgetnum();
  47 extern char *tgetstr();
  48 extern int tgetflag();
  49 extern short ospeed;
  50
  51 /* Option values */
  52 int continuous;                 /* => display the queue continuously */
  53 double interval;                /* with updates at this interval */
  54
  55 /* Capability strings and terminal information from termcap */
  56 int screen_lines;               /* screen has this many lines */
  57 int screen_width;               /* and this many columns */
  58 char *term;                     /* terminal type */
  59 char *home;                     /* go to top-left corner of screen */
  60 char *init_str;                 /* initialize terminal */
  61 char *finish_str;               /* reset terminal before exit */
  62 char *clr_screen;               /* clear whole screen */
  63 char *clr_eol;                  /* clear to end of line */
  64 char *clr_eos;                  /* clear to end of screen */
  65
  66 int size_changed;               /* set when the window size changes */
  67
  68 void getout();
  69 void hoist();
  70 int outchar();
  71
  72 main(argc, argv)
  73     int argc;
  74     char **argv;
  75 {
  76     int fd, c, n;
  77     int queue_empty;
  78     double t;
  79     char *ptr;
  80     extern char *optarg;
  81     fd_set ready;
  82     struct timeval *timo, tval;
  83     struct termios tio;
  84
  85     /* set defaults */
  86     cap_host = getenv("AP1000HOST");
  87     if( cap_host == NULL )
  88         cap_host = CAP_HOST_DFLT;
  89     continuous = 0;
  90     interval = 1.0;
  91
  92     /* parse command-line options */
  93     while( (c = getopt(argc, argv, "c:h:")) != -1 ){
  94         switch( c ){
  95         case 'h':
  96             cap_host = optarg;
  97             break;
  98         case 'c':
  99           continuous = 1;
 100           interval = atof(optarg);
 101           break;
 102         case '?':
 103             fprintf(stderr, "Usage: %s [-h host]\n", argv[0]);
 104             exit(1);
 105         }
 106     }
 107
 108     /* connect to the capqd process */
 109     fd = connect_tcp(cap_host, CAPQD_PORT);
 110     if( fd < 0 )
 111         exit(1);
 112     capqd_r = fdopen(fd, "r");
 113     capqd_w = fdopen(fd, "w");
 114     if( capqd_r == NULL || capqd_w == NULL ){
 115         fprintf(stderr, "fdopen failed!\n");
 116         exit(1);
 117     }
 118
 119     /* request the current state of the queue */
 120     fputs("queue\n", capqd_w);
 121     fflush(capqd_w);
 122
 123     if( !continuous ){
 124         /* just print the queue once and exit. */
 125         show_queue(0, "");
 126         exit(0);
 127     }
 128
 129     /* Continuous mode - get information about the terminal. */
 130     if( tcgetattr(0, &tio) == 0 )
 131         ospeed = cfgetospeed(&tio);
 132     screen_lines = 24;
 133     screen_width = 80;
 134     home = clr_screen = clr_eol = finish_str = NULL;
 135     term = getenv("TERM");
 136     if( term != NULL && tgetent(termcap_entry, term) > 0 ){
 137         ptr = string_caps;
 138         screen_lines = tgetnum("li");
 139         screen_width = tgetnum("co");
 140         home = tgetstr("ho", &ptr);
 141         clr_screen = tgetstr("cl", &ptr);
 142         clr_eol = tgetstr("ce", &ptr);
 143         clr_eos = tgetstr("cd", &ptr);
 144         init_str = tgetstr("ti", &ptr);
 145         finish_str = tgetstr("te", &ptr);
 146         if( init_str != NULL )
 147             tputs(init_str, screen_lines, outchar);
 148     }
 149
 150     /* default to the ANSI sequences */
 151     if( home == NULL )
 152         home = "\033[H";
 153     if( clr_screen == NULL )
 154         clr_screen = "\033[H\033[J";
 155     if( clr_eol == NULL )
 156         clr_eol = "\033[K";
 157     if( clr_eos == NULL )
 158         clr_eos = "\033[J";
 159     if( finish_str == NULL )
 160         finish_str = "";
 161     tputs(clr_screen, screen_lines, outchar);
 162     fflush(stdout);
 163
 164     if( screen_lines > MAXLINES )
 165         screen_lines = MAXLINES;
 166     if( screen_width > MAXCOLS )
 167         screen_width = MAXCOLS;
 168
 169     /* fix up the terminal and exit on these signals */
 170     signal(SIGINT, getout);
 171     signal(SIGTERM, getout);
 172     /* update the terminal size on this signal */
 173     signal(SIGWINCH, hoist);
 174
 175     /*
 176      * This loop waits for either (a) an update to arrive from capqd,
 177      * or (b) for it to be time to change the time values displayed
 178      * for jobs in the queue, or (c) for the terminal window size to change.
 179      */
 180     num_lines = 0;
 181     size_changed = 0;
 182     for(;;){
 183         if( num_lines <= 1 )
 184             /* no times to update - don't time out */
 185             timo = NULL;
 186
 187         else {
 188             /* work out how long until the first time displayed
 189                should change, i.e. until it's a multiple of `interval'. */
 190             gettimeofday(&tval, NULL);
 191             our_time = double_time(&tval);
 192             t = timez[1];
 193             if( t == 0 )
 194                 t = timez[1];
 195             t = our_time + host_time_diff - t;
 196             t = interval - fmod(t, interval);
 197             tval.tv_sec = (int) floor(t);
 198             tval.tv_usec = (int) floor((t - tval.tv_sec) * 1.0E6);
 199             timo = &tval;
 200         }
 201
 202         /* wait for something */
 203         FD_ZERO(&ready);
 204         FD_SET(fd, &ready);
 205         n = select(fd+1, &ready, NULL, NULL, timo);
 206         if( n < 0 && errno != EINTR ){
 207             tputs(finish_str, screen_lines, outchar);
 208             perror("select");
 209             exit(1);
 210         }
 211
 212         if( n > 0 ){
 213             /* update display with new information, then ask for
 214                another report when the queue changes. */
 215             size_changed = 0;
 216             show_queue();
 217             fprintf(capqd_w, "queue %.2f\n", last_change_time);
 218             fflush(capqd_w);
 219
 220         } else if( size_changed ){
 221             /* ask for the queues again */
 222             fprintf(capqd_w, "queue\n");
 223             fflush(capqd_w);
 224             size_changed = 0;
 225
 226         } else if( n == 0 ){
 227             /* timeout - no new information from capqd */
 228             update_times();
 229         }
 230
 231         /* leave the cursor at the top left of the screen */
 232         tputs(home, 0, outchar);
 233         fflush(stdout);
 234     }
 235 }
 236
 237 /*
 238  * Fatal signal - clean up terminal and exit.
 239  */
 240 void
 241 getout(sig)
 242     int sig;
 243 {
 244     tputs(finish_str, screen_lines, outchar);
 245     exit(0);
 246 }
 247
 248 /*
 249  * Window size changed - winch up the new size.
 250  */
 251 void
 252 hoist(sig)
 253     int sig;
 254 {
 255     struct winsize winsz;
 256
 257     if( ioctl(fileno(stdout), TIOCGWINSZ, &winsz) == 0 ){
 258         size_changed = 1;
 259         screen_lines = winsz.ws_row;
 260         screen_width = winsz.ws_col;
 261         if( screen_lines > MAXLINES )
 262             screen_lines = MAXLINES;
 263         if( screen_width > MAXCOLS )
 264             screen_width = MAXCOLS;
 265     }
 266 }
 267
 268 /*
 269  * Output character routine for tputs to use.
 270  */
 271 int
 272 outchar(c)
 273     int c;
 274 {
 275     putchar(c);
 276 }
 277
 278 /*
 279  * New information from capqd - display it, and (in continuous mode)
 280  * record the start times for the users shown on each line of the display.
 281  */
 282 int
 283 show_queue()
 284 {
 285     int n, index, run_done, lnum;
 286     double start_time;
 287     char *ptr;
 288     char line[80];
 289     char user[64], more[8];
 290     int pid[3];
 291     struct timeval now;
 292     char str[MAXCOLS+1];
 293
 294     /* initialize, print heading */
 295     run_done = 0;
 296     timez[0] = 0;
 297     lnum = 1;
 298     sprintf(str, "        CAP queue on %.50s", cap_host);
 299     putstr(str, 0);
 300
 301     /* get lines from capqd */
 302     for(;;){
 303         if( fgets(line, sizeof(line), capqd_r) == NULL ){
 304             /* EOF or error - capqd must have gone away */
 305             if( continuous ){
 306                 tputs(finish_str, screen_lines, outchar);
 307                 fflush(stdout);
 308             }
 309             fprintf(stderr, "read error\n");
 310             exit(1);
 311         }
 312
 313         if( line[0] == 'E' )
 314             /* end of queue report */
 315             break;
 316         if( line[0] == 'T' ){
 317             /* first line of queue report: T last-change-time time-now */
 318             gettimeofday(&now, NULL);
 319             our_time = double_time(&now);
 320             sscanf(line+2, "%lf %lf", &last_change_time, &host_time_diff);
 321             host_time_diff -= our_time;
 322             continue;
 323         }
 324
 325         /* line specifying next user in queue:
 326            index user start-time { pids... } */
 327         n = sscanf(line, "%d %s %lf { %d %d %d %d %s", &index,
 328                    user, &start_time, &pid[0], &pid[1], &pid[2],
 329                    &pid[3], more);
 330         if( (n -= 3) <= 0 ){
 331             /* couldn't parse line - ignore it */
 332 #ifdef  DEBUG
 333             fprintf(stderr, "bad line %s", line);
 334 #endif
 335             continue;
 336         }
 337
 338         /* accumulate a line to be printed in str */
 339         ptr = str;
 340         if( index == 0 ){
 341             /* this is the running job */
 342             sprint_time(&ptr, start_time);
 343             sprintf(ptr, "  Run  %.20s  (pid %d", user, pid[0]);
 344             ptr += strlen(ptr);
 345             if( n > 1 ){
 346                 /* print the rest of the pids which are waiting */
 347                 strcpy(ptr, ", ");
 348                 ptr += 2;
 349                 sprint_pids_waiting(&ptr, pid, n, 1);
 350                 strcpy(ptr, " waiting");
 351                 ptr += 8;
 352             }
 353             *ptr++ = ')';
 354             run_done = 1;
 355
 356         } else {
 357             /* a user in the queue */
 358             if( continuous && !run_done ){
 359                 /* no running job - leave a blank line for it */
 360                 str[0] = 0;
 361                 putstr(str, lnum);
 362                 run_done = 1;
 363                 timez[lnum] = 0;
 364                 ++lnum;
 365             }
 366             if( continuous && lnum >= screen_lines - 1 ){
 367                 /* no more room on screen */
 368                 if( lnum == screen_lines - 1 ){
 369                     strcpy(ptr, "                (more)");
 370                     ptr += strlen(ptr);
 371                     start_time = 0;
 372                 } else
 373                     ptr = NULL; /* don't print anything */
 374             } else {
 375                 /* format this line into str */
 376                 sprint_time(&ptr, start_time);
 377                 sprintf(ptr, "  %3d  %.20s  (", index, user);
 378                 ptr += strlen(ptr);
 379                 sprint_pids_waiting(&ptr, pid, n, 0);
 380                 *ptr++ = ')';
 381             }
 382         }
 383         /* print out the line we've formatted */
 384         if( ptr != NULL ){
 385             *ptr = 0;
 386             if( continuous ){
 387                 putstr(str, lnum);
 388                 timez[lnum] = start_time;
 389                 ++lnum;
 390             } else
 391                 printf("%s\n", str);
 392         }
 393     }
 394
 395     if( lnum > screen_lines )
 396         lnum = screen_lines;
 397     num_lines = lnum;
 398
 399     /* clear the remainder of the screen */
 400     if( continuous && lnum < screen_lines )
 401         tputs(clr_eos, screen_lines - lnum + 1, outchar);
 402 }
 403
 404 /*
 405  * Output a line to the screen.  In continuous mode, truncate the
 406  * line to the screen width and clear the remainder of the line.
 407  */
 408 putstr(str, lnum)
 409     char *str;
 410     int lnum;
 411 {
 412     if( continuous ){
 413         if( lnum < screen_lines ){
 414             str[screen_width] = 0;
 415             fputs(str, stdout);
 416             if( strlen(str) < screen_width )
 417                 tputs(clr_eol, 1, outchar);
 418             if( lnum < screen_lines - 1 )
 419                 putchar('\n');
 420         }
 421     } else
 422         printf("%s\n", str);
 423 }
 424
 425 /*
 426  * Format the time since time t on the cap_host into the buffer
 427  * at **pp, advancing *pp past the formatted string.
 428  */
 429 sprint_time(pp, t)
 430     char **pp;
 431     double t;
 432 {
 433     int x;
 434
 435     t = floor(our_time + host_time_diff - t + 0.5);
 436     if( t > 3600 ){
 437         x = floor(t / 3600);
 438         sprintf(*pp, "%3d:", x);
 439         *pp += strlen(*pp);
 440         t -= x * 3600.0;
 441     } else {
 442         strcpy(*pp, "    ");
 443         *pp += 4;
 444     }
 445     x = floor(t / 60);
 446     sprintf(*pp, "%.2d:%.2d", x, (int)(t - x * 60));
 447     *pp += strlen(*pp);
 448 }
 449
 450 /*
 451  * Format a list of pids waiting into **pp, advancing *pp.
 452  */
 453 sprint_pids_waiting(pp, pid, n, i)
 454     char **pp;
 455     int pid[], n, i;
 456 {
 457     sprintf(*pp, "pid%s %d", (n > i+1? "s": ""), pid[i]);
 458     *pp += strlen(*pp);
 459     for( ++i; i < n && i < 4; ++i ){
 460         sprintf(*pp, ", %d", pid[i]);
 461         *pp += strlen(*pp);
 462     }
 463     if( n >= 5 ){
 464         strcpy(*pp, ", ...");
 465         *pp += 5;
 466     }
 467 }
 468
 469 /*
 470  * Update the times displayed for each user.
 471  */
 472 update_times()
 473 {
 474     double t;
 475     int i;
 476     struct timeval now;
 477     char *ptr, str[12];
 478
 479     gettimeofday(&now, NULL);
 480     our_time = double_time(&now);
 481     for( i = 0; i < num_lines; ++i ){
 482         ptr = str;
 483         if( (t = timez[i]) != 0 ){
 484             sprint_time(&ptr, t);
 485             if( screen_width < sizeof(str) )
 486                 str[screen_width] = 0;
 487             *ptr = 0;
 488             printf("%s", str);
 489         }
 490         if( i < num_lines - 1 )
 491             printf("\n");
 492     }
 493 }
 494
 495 /*
 496  * Establish a TCP/IP connection with the process at the given hostname
 497  * and port number.
 498  */
 499 int
 500 connect_tcp(host, port)
 501     char *host;
 502     int port;
 503 {
 504     int fd;
 505     unsigned long hnum;
 506     struct hostent *hent;
 507     struct sockaddr_in addr;
 508
 509     hnum = inet_addr(host);
 510     if( hnum == -1 ){
 511         hent = gethostbyname(host);
 512         if( hent == NULL ){
 513             fprintf(stderr, "hostname %s not recognized\n", host);
 514             return -1;
 515         }
 516         hnum = *(unsigned long *)(hent->h_addr_list[0]);
 517     }
 518
 519     if( (fd = socket(PF_INET, SOCK_STREAM, 0)) < 0 ){
 520         perror("socket");
 521         return -1;
 522     }
 523
 524     bzero(&addr, sizeof(addr));
 525     addr.sin_family = AF_INET;
 526     addr.sin_port = htons(port);
 527     addr.sin_addr.s_addr = hnum;
 528
 529     if( connect(fd, &addr, sizeof(addr)) < 0 ){
 530         perror("connect");
 531         return -1;
 532     }
 533
 534     return fd;
 535 }