Turned off debugging printfs.
[dyninst.git] / 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 }