paradyn/src/met/metMain.C

   1
   2 /* metMain contains the functions that are called by the parser to support the
   3  * configuration language.  The functions are:
   4  *     metProcess(..) - build the process list
   5  *     metDaemon (..) - build the daemon list
   6  *     metTunable(..) - build the tunable constant list
   7  *     metVisi(..) - build the visi list
   8  *
   9  *     metDoProcess(..) - start a process
  10  *     metDoDaemon (..) - start a daemon
  11  *     metDoTunable(..) - set a tunable constant value
  12  *     metDoVisi(..) - declare a visi
  13  */
  14
  15 /*
  16  * $Log: metMain.C,v $
  17  * Revision 1.2  1994/07/07 13:10:41  markc
  18  * Turned off debugging printfs.
  19  *
  20  * Revision 1.1  1994/07/07  03:25:25  markc
  21  * Configuration language parser.
  22  *
  23  */
  24
  25 #include "paradyn/src/met/metParse.h"
  26 #include <stdio.h>
  27 #include <fcntl.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <unistd.h>
  31 #include "util/h/list.h"
  32 #include "paradyn/src/pdMain/paradyn.h"
  33 #include "util/h/tunableConst.h"
  34
  35 extern "C" {
  36 int gethostname(char*, int);
  37 }
  38
  39 #define CONFIG_NAME "sample.psdl"
  40 #define CONFIG_SLASH "/sample.psdl"
  41 #define ROOT_NAME "/p/paradyn/sample.psdl"
  42
  43 extern int yyparse();
  44 extern int yyrestart(FILE *);
  45
  46 int open_N_parse(char *file);
  47
  48 List<tunableStruct*> globalTunable;
  49 List<processStruct*> globalProcess;
  50 List<visiStruct*> globalVisi;
  51 List<daemonStruct*> globalDaemon;
  52
  53 // open the config file and parse it
  54 // return -1 on failure to open file
  55 // else return yyparse result
  56
  57 int open_N_parse (char *file)
  58 {
  59   int res;
  60   FILE *f;
  61   static int been_here = 0;
  62
  63   f = fopen (file, "r");
  64   if (f)
  65     {
  66       if (!been_here)
  67         {
  68           been_here = 1;
  69           yyin = f;
  70           res = yyparse();
  71           fclose(f);
  72           return res;
  73         }
  74       else
  75         {
  76           res = yyrestart(f);
  77           res = yyparse();
  78           fclose(f);
  79           return res;
  80         }
  81     }
  82   return -1;
  83 }
  84
  85 //
  86 static char *convert_local(char *old_host)
  87 {
  88   char holder[100];
  89
  90   if (!old_host)
  91       return ((char*) 0);
  92
  93   if (!strcmp("localhost", old_host))
  94     {
  95       if(!gethostname(holder, 99))
  96         return(strdup(holder));
  97       else
  98         return(old_host);
  99     }
 100   else
 101     return strdup(old_host);
 102 }
 103
 104
 105 // parse the 3 files (system, user, application)
 106
 107 int metMain()
 108 {
 109   // return yyparse();
 110   int yy1, yy2, yy3, hlen;
 111   char *home, *homecat;
 112
 113   home = getenv("HOME");
 114
 115   globalTunable.removeAll();
 116   globalProcess.removeAll();
 117   globalDaemon.removeAll();
 118
 119   yy1 = open_N_parse(ROOT_NAME);
 120   if (home)
 121     {
 122       hlen = strlen(home);
 123       hlen += (1 + strlen(CONFIG_NAME));
 124       homecat = new char[hlen];
 125       strcpy(homecat, home);
 126       strcat(homecat, CONFIG_SLASH);
 127       yy2 = open_N_parse(homecat);
 128     }
 129   else
 130     yy2 = 0;
 131
 132   yy3 = open_N_parse(CONFIG_NAME);
 133
 134   return (yy1 + yy2 + yy3);
 135 }
 136
 137 void dumpProcess(processStruct ps)
 138 {
 139   List<char*> tempList;
 140   int i=0;
 141   char *val;
 142
 143   printf("DUMPING THE PROCESS\n");
 144   printf("    COMMAND: %s\n", ps.command ? ps.command : " ");
 145   printf("    NAME:    %s\n", ps.name ? ps.name : " ");
 146
 147   printf("    ARGS:  ");
 148   for (tempList=ps.args; val = *tempList; tempList++)
 149     printf("arg %d: %s  ", i++, val);
 150
 151   printf("    HOST:    %s\n", ps.host ? ps.host : " ");
 152   printf("    DAEMON:  %s\n", ps.daemon ? ps.daemon : " ");
 153   printf("    FLAVOR:  %d\n", ps.flavor);
 154 }
 155
 156 int metProcess (processStruct ps)
 157 {
 158   processStruct *new_ps;
 159
 160   printf("metProcess\n");
 161   if (!ps.command || !ps.host || !ps.daemon)
 162     {
 163       printf("for a process, command, daemon, and host must be defined\n");
 164       dumpProcess(ps);
 165       return -1;
 166     }
 167   else
 168     {
 169       new_ps = new processStruct;
 170       new_ps->name = ps.name;
 171       new_ps->command = ps.command;
 172       new_ps->args = ps.args;
 173       new_ps->host = convert_local(ps.host);
 174       new_ps->daemon  = ps.daemon;
 175       new_ps->flavor = ps.flavor;
 176       globalProcess.add(new_ps);
 177       // dumpProcess(ps);
 178       return 0;
 179     }
 180 }
 181
 182 void dumpVisi (visiStruct vs)
 183 {
 184   List<char*> tempList;
 185   int i=0;
 186   char *val;
 187
 188   printf("DUMPING THE VISI\n");
 189   printf("    COMMAND: %s\n", vs.command ? vs.command : " ");
 190   printf("    NAME:    %s\n", vs.name ? vs.name : " ");
 191
 192   printf("    ARGS:  ");
 193   for (tempList=vs.args; val = *tempList; tempList++)
 194     printf("arg %d: %s  ", i++, val);
 195
 196   printf("    HOST:    %s\n", vs.host ? vs.host : " ");
 197 }
 198
 199 int metVisi(visiStruct vs)
 200 {
 201   visiStruct *new_vs;
 202
 203   printf("metVisi\n");
 204   if (!vs.command || !vs.name)
 205     {
 206       printf("for a visi, command and name must be defined\n");
 207       dumpVisi(vs);
 208       return -1;
 209     }
 210   else
 211     {
 212       new_vs = new visiStruct;
 213       new_vs->name = vs.name;
 214       new_vs->command = vs.command;
 215       new_vs->args = vs.args;
 216       new_vs->host = convert_local(vs.host);
 217       globalVisi.add(new_vs);
 218       // dumpVisi(vs);
 219       return 0;
 220     }
 221 }
 222 void dumpTunable (char *name, float value)
 223 {
 224   printf("DUMPING THE TUNABLE\n");
 225   printf("    NAME:  %s\n", name ? name : " ");
 226   printf("    VALUE: %f\n", value);
 227 }
 228
 229 int metTunable (char *name, float value)
 230 {
 231   tunableStruct *ts;
 232
 233   printf("metTunable\n");
 234   if (!name)
 235     {
 236       printf("for a tunable constant, name must be defined\n");
 237       dumpTunable(name, value);
 238       return -1;
 239     }
 240   else
 241     {
 242       ts = new tunableStruct;
 243       ts->name = name;
 244       ts->value = value;
 245       globalTunable.add(ts);
 246       // dumpTunable(name, value);
 247       return 0;
 248     }
 249 }
 250
 251 void dumpDaemon (daemonStruct ds)
 252 {
 253   printf("DUMPING THE DAEMON\n");
 254   printf("    COMMAND: %s\n", ds.command ? ds.command : " ");
 255   printf("    NAME:    %s\n", ds.name ? ds.name : " ");
 256   printf("    HOST:    %s\n", ds.host ? ds.host : " ");
 257   printf("    FLAVOR:  %d\n", ds.flavor);
 258 }
 259
 260 int metDaemon (daemonStruct ds)
 261 {
 262   daemonStruct *new_ds;
 263
 264   printf("metDaemon\n");
 265   if (!ds.command || !ds.host)
 266     {
 267       printf("for a daemon, command and host must be defined\n");
 268       dumpDaemon(ds);
 269       return -1;
 270     }
 271   else
 272     {
 273       new_ds =  new daemonStruct;
 274       new_ds->name = ds.name;
 275       new_ds->command = ds.command;
 276       new_ds->host = convert_local(ds.host);
 277       new_ds->flavor = ds.flavor;
 278       globalDaemon.add(new_ds);
 279       // dumpDaemon(ds);
 280       return 0;
 281     }
 282 }
 283
 284 int metDoDaemon()
 285 {
 286   daemonStruct *the_ds;
 287   List<daemonStruct*> dl;
 288
 289   for (dl = globalDaemon; the_ds = *dl; dl++)
 290     {
 291       // dumpDaemon(*the_ds);
 292       if (dataMgr->addDaemon(context, the_ds->host, (char *) 0,
 293                              the_ds->command))
 294         ; //printf("Start daemon %s on %s succeeded\n", the_ds->command,
 295            //    the_ds->host);
 296       else
 297         ; //printf("Start daemon %s on %s failed\n", the_ds->command,
 298            //    the_ds->host);
 299     }
 300   return 0;
 301 }
 302
 303 int metDoVisi()
 304 {
 305   visiStruct *the_vs;
 306   List<visiStruct*> vl;
 307   List <char*> tempList;
 308   int argc, i;
 309   char **argv;
 310   char *val;
 311
 312   for (vl = globalVisi; the_vs = *vl; vl++)
 313     {
 314       argc = the_vs->args.count() + 1;
 315       argv = new char*[argc+1];
 316       argv[argc] = 0;
 317       i = 1;
 318       argv[0] = strdup(the_vs->command);
 319       for (tempList = the_vs->args; val = *tempList; tempList++)
 320         {
 321           argv[i] = strdup(val);
 322           i++;
 323         }
 324       // dumpVisi(*the_vs);
 325       vmMgr->VMAddNewVisualization(the_vs->name, argc, argv);
 326       for (i=0; i<argc; ++i)
 327        if (argv[i]) delete argv[i];
 328       delete argv;
 329     }
 330   return 0;
 331 }
 332
 333 int metDoProcess()
 334 {
 335   processStruct *the_ps;
 336   List<processStruct*> pl;
 337   List <char*> tempList;
 338   int argc, i;
 339   char **argv;
 340   char *val;
 341
 342   for (pl = globalProcess; the_ps = *pl; pl++)
 343     {
 344       argc = the_ps->args.count() + 1;
 345       argv = new char*[argc+1];
 346       argv[argc] = 0;
 347       i = 1;
 348       argv[0] = strdup(the_ps->command);
 349       for (tempList = the_ps->args; val = *tempList; tempList++)
 350         {
 351           argv[i] = strdup(val);
 352           i++;
 353         }
 354       // dumpProcess(*the_ps);
 355       if (dataMgr->addExecutable(context, the_ps->host, (char*) 0,
 356                                  the_ps->daemon, argc, argv))
 357         ; // printf("Start process %s succeeded on %s\n", the_ps->command,
 358            //    the_ps->host);
 359       else
 360         ; //printf("Start process %s failed on %s\n", the_ps->command,
 361            //    the_ps->host);
 362
 363       for (i=0; i<argc; ++i)
 364        if (argv[i]) delete argv[i];
 365       delete argv;
 366     }
 367   return 0;
 368 }
 369
 370 int metDoTunable()
 371 {
 372   tunableStruct *the_ts;
 373   List<tunableStruct*> tl;
 374   tunableConstant* curr;
 375   char *sp;
 376
 377   if (!tunableConstant::allConstants)
 378     return -1;
 379
 380   for (tl = globalTunable; the_ts = *tl; tl++)
 381     {
 382       // dumpTunable(the_ts->name, the_ts->value);
 383       sp = tunableConstant::pool->findAndAdd(the_ts->name);
 384       curr = tunableConstant::allConstants->find(sp);
 385
 386       if (curr)
 387         {
 388           if (!curr->setValue(the_ts->value))
 389             ; // printf("Can't set value of tunable constant\n");
 390           else
 391             ; //printf("Set Tunable Constant: %s = %f\n", the_ts->name,
 392         //         the_ts->value);
 393         }
 394     }
 395   return 0;
 396 }