← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gridengine/utopic

« back to all changes in this revision

Viewing changes to source/clients/qmon/qmon_host.c

  • Committer: Bazaar Package Importer
  • Author(s): Mark Hymers
  • Date: 2008-06-25 22:36:13 UTC
  • Revision ID: james.westby@ubuntu.com-20080625223613-tvd9xlhuoct9kyhm
Tags: upstream-6.2~beta2
Import upstream version 6.2~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/clients/qmon/qmon_host.c
 
1
/*___INFO__MARK_BEGIN__*/
 
2
/*************************************************************************
 
3
 * 
 
4
 *  The Contents of this file are made available subject to the terms of 
 
5
 *  the Sun Industry Standards Source License Version 1.2
 
6
 * 
 
7
 *
 
8
 *  Sun Microsystems Inc., March, 2001
 
9
 * 
 
10
 * 
 
11
 *  Sun Industry Standards Source License Version 1.2
 
12
 *  =================================================
 
13
 *  The contents of this file are subject to the Sun Industry Standards
 
14
 *  Source License Version 1.2 (the "License"); You may not use this file
 
15
 *  except in compliance with the License. You may obtain a copy of the
 
16
 *  License at http://gridengine.sunsource.net/Gridengine_SISSL_license.html
 
17
 * 
 
18
 *  Software provided under this License is provided on an "AS IS" basis,
 
19
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 
20
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 
21
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 
22
 *  See the License for the specific provisions governing your rights and
 
23
 *  obligations concerning the Software.
 
24
 * 
 
25
 *   The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 
26
 * 
 
27
 *   Copyright: 2001 by Sun Microsystems, Inc.
 
28
 * 
 
29
 *   All Rights Reserved.
 
30
 * 
 
31
 ************************************************************************/
 
32
/*___INFO__MARK_END__*/
 
33
#include <stdio.h>
 
34
#include <stdlib.h>
 
35
#include <ctype.h>
 
36
 
 
37
#include <Xm/Xm.h>
 
38
#include <Xm/List.h>
 
39
#include <Xm/TextF.h>
 
40
#include <Xm/Text.h>
 
41
 
 
42
#include <Xmt/Xmt.h>
 
43
#include <Xmt/Help.h>
 
44
#include <Xmt/Create.h>
 
45
#include <Xmt/Layout.h>
 
46
#include <Xmt/Chooser.h>
 
47
#include <Xmt/Dialog.h>
 
48
#include <Xmt/MsgLine.h>
 
49
#include <Xmt/InputField.h>
 
50
#include <Xmt/Procedures.h>
 
51
 
 
52
#include "sge_all_listsL.h"
 
53
#include "commlib.h"
 
54
#include "sge.h"
 
55
#include "sge_complex_schedd.h"
 
56
#include "sge_answer.h"
 
57
#include "sge_feature.h"
 
58
#include "sge_host.h"
 
59
#include "load_correction.h"
 
60
#include "sge_prog.h"
 
61
#include "sge_host.h"
 
62
#include "sge_hgroup.h"
 
63
#include "sge_hgroup_qconf.h"
 
64
#include "gdi/sge_gdi.h"
 
65
#include "gdi/sge_gdi_ctx.h"
 
66
 
 
67
#include "qmon_proto.h"
 
68
#include "qmon_rmon.h"
 
69
#include "qmon_cull.h"
 
70
#include "qmon_util.h"
 
71
#include "qmon_appres.h"
 
72
#include "qmon_host.h"
 
73
#include "qmon_comm.h"
 
74
#include "qmon_globals.h"
 
75
#include "qmon_timer.h"
 
76
#include "qmon_widgets.h"
 
77
#include "qmon_quarks.h"
 
78
#include "qmon_message.h"
 
79
#include "qmon_load.h"
 
80
#include "qmon_cplx.h"
 
81
#include "qmon_manop.h"
 
82
#include "qmon_project.h"
 
83
#include "qmon_queue.h"
 
84
#include "Matrix.h"
 
85
#include "Tab.h"
 
86
 
 
87
extern sge_gdi_ctx_class_t *ctx;
 
88
 
 
89
/*-------------------------------------------------------------------------*/
 
90
typedef struct _tHostEntry {
 
91
   lList *consumable_config_list;
 
92
   lList *scaling_list;
 
93
   lList *usage_scaling_list;
 
94
   char *name;
 
95
   lList *acl;
 
96
   lList *xacl;
 
97
   lList *prj;
 
98
   lList *xprj;
 
99
   lList *reporting_variables;
 
100
} tHostEntry;
 
101
 
 
102
XtResource host_resources[] = {
 
103
 
 
104
   { "name", "name", XtRString,
 
105
      sizeof(char*), XtOffsetOf(tHostEntry, name),
 
106
      XtRImmediate, NULL },
 
107
   
 
108
   { "scaling_list", "scaling_list", QmonRHS_Type,
 
109
      sizeof(lList*), XtOffsetOf(tHostEntry, scaling_list),
 
110
      XtRImmediate, NULL },
 
111
 
 
112
   { "usage_scaling_list", "usage_scaling_list", QmonRHS_Type,
 
113
      sizeof(lList*), XtOffsetOf(tHostEntry, usage_scaling_list),
 
114
      XtRImmediate, NULL },
 
115
 
 
116
/*---- consumables  ----*/
 
117
   { "consumable_config_list", "consumable_config_list", QmonRCE2_Type,
 
118
      sizeof(lList*), XtOffsetOf(tHostEntry, consumable_config_list),
 
119
      XtRImmediate, NULL },
 
120
 
 
121
/*---- access  ----*/
 
122
   { "acl", "acl", QmonRUS_Type,
 
123
      sizeof(lList *),
 
124
      XtOffsetOf(tHostEntry, acl),
 
125
      XtRImmediate, NULL },
 
126
   
 
127
   { "xacl", "xacl", QmonRUS_Type,
 
128
      sizeof(lList *),
 
129
      XtOffsetOf(tHostEntry, xacl),
 
130
      XtRImmediate, NULL },
 
131
      
 
132
/*---- projects  ----*/
 
133
   { "prj", "prj", QmonRPR_Type,
 
134
      sizeof(lList *),
 
135
      XtOffsetOf(tHostEntry, prj),
 
136
      XtRImmediate, NULL },
 
137
   
 
138
   { "xprj", "xprj", QmonRPR_Type,
 
139
      sizeof(lList *),
 
140
      XtOffsetOf(tHostEntry, xprj),
 
141
      XtRImmediate, NULL },
 
142
      
 
143
/*---- reporting variables  ----*/
 
144
   { "reporting_variables", "reporting_variables", QmonRSTU_Type,
 
145
      sizeof(lList *),
 
146
      XtOffsetOf(tHostEntry, reporting_variables),
 
147
      XtRImmediate, NULL }
 
148
   
 
149
};
 
150
 
 
151
 
 
152
/*-------------------------------------------------------------------------*/
 
153
static Widget qmonCreateHostConfig(Widget parent);
 
154
static Widget qmonCreateExecHostConfig(Widget parent, XtPointer cld);
 
155
static Widget qmonCreateExecHostAsk(Widget parent);
 
156
static void qmonHostFillList(void);
 
157
static void qmonHostFolderChange(Widget w, XtPointer cld, XtPointer cad);
 
158
static void qmonHostHelp(Widget w, XtPointer cld, XtPointer cad);
 
159
static void qmonHostAdd(Widget w, XtPointer cld, XtPointer cad);
 
160
static void qmonHostDelete(Widget w, XtPointer cld, XtPointer cad);
 
161
/*
 
162
static Widget qmonCreateAdminHostConfig(Widget parent, XtPointer cld);
 
163
static Widget qmonCreateSubmitHostConfig(Widget parent, XtPointer cld);
 
164
*/
 
165
static void qmonExecHostShutdown(Widget w, XtPointer cld, XtPointer cad);
 
166
static void qmonExecHostOk(Widget w, XtPointer cld, XtPointer cad);
 
167
static void qmonExecHostCancel(Widget w, XtPointer cld, XtPointer cad);
 
168
static void qmonExecHostChange(Widget w, XtPointer cld, XtPointer cad);
 
169
static void qmonExecHostSelect(Widget w, XtPointer cld, XtPointer cad);
 
170
static void qmonExecHostCheckName(Widget w, XtPointer cld, XtPointer cad);
 
171
static void qmonExecHostCheckScaling(Widget w, XtPointer cld, XtPointer cad);
 
172
static void qmonExecHostSetAsk(StringConst name);
 
173
static lList* qmonExecHostGetAsk(void);
 
174
static void qmonHostAvailableAcls(void);
 
175
static void qmonHostAvailableProjects(void);
 
176
static void qmonHostAvailableReportVars(void);
 
177
 
 
178
static void qmonExecHostAccessToggle(Widget w, XtPointer cld, XtPointer cad); 
 
179
static void qmonExecHostAccessAdd(Widget w, XtPointer cld, XtPointer cad); 
 
180
static void qmonExecHostAccessRemove(Widget w, XtPointer cld, XtPointer cad); 
 
181
static void qmonExecHostProjectToggle(Widget w, XtPointer cld, XtPointer cad); 
 
182
static void qmonExecHostProjectAdd(Widget w, XtPointer cld, XtPointer cad); 
 
183
static void qmonExecHostProjectRemove(Widget w, XtPointer cld, XtPointer cad); 
 
184
static void qmonExecHostReportVarAdd(Widget w, XtPointer cld, XtPointer cad); 
 
185
static void qmonExecHostReportVarRemove(Widget w, XtPointer cld, XtPointer cad); 
 
186
static void qmonPopdownHostConfig(Widget w, XtPointer cld, XtPointer cad);
 
187
static Widget qmonCreateHostgroupAsk(Widget parent);
 
188
static void qmonHostgroupChange(Widget w, XtPointer cld, XtPointer cad);
 
189
static void qmonHostgroupOk(Widget w, XtPointer cld, XtPointer cad);
 
190
static void qmonHostgroupCancel(Widget w, XtPointer cld, XtPointer cad);
 
191
static void qmonHostgroupCheckName(Widget w, XtPointer cld, XtPointer cad);
 
192
static void qmonHostgroupSetAsk(StringConst name);
 
193
static void qmonHostgroupSelect(Widget w, XtPointer cld, XtPointer cad);
 
194
static void qmonHostgroupAddHost(Widget w, XtPointer cld, XtPointer cad);
 
195
static void qmonHostgroupAddHostgroups(Widget w, XtPointer cld, XtPointer cad);
 
196
static void updateHostListCB(Widget w, XtPointer cld, XtPointer cad);
 
197
static void updateHostList(void);
 
198
/*-------------------------------------------------------------------------*/
 
199
static Widget qmon_host = NULL;
 
200
static Widget adminhost_list = NULL;
 
201
static Widget submithost_list = NULL;
 
202
static Widget hostgroup_list = NULL;
 
203
static Widget hostgroup_memberlist = NULL;
 
204
static Widget host_modify = NULL;
 
205
static Widget host_shutdown = NULL;
 
206
 
 
207
static Widget exechost_list = NULL;
 
208
static Widget exechost_access = 0;
 
209
static Widget exechost_reporting_variables = 0;
 
210
static Widget exechost_load_scaling = 0;
 
211
static Widget exechost_consumables = 0;
 
212
static Widget exechost_usage_scaling = 0;
 
213
static Widget eh_ask_layout = 0;
 
214
static Widget hg_ask_layout = 0;
 
215
static Widget hg_name_w = 0;
 
216
static Widget hg_memberlist_w = 0;
 
217
static Widget hg_hglist_w = 0;
 
218
static Widget hg_member_w = 0;
 
219
static Widget eh_name_w = 0;
 
220
static Widget eh_folder = 0;
 
221
static Widget access_list = 0;
 
222
static Widget access_allow = 0;
 
223
static Widget access_deny = 0;
 
224
static Widget access_toggle = 0;
 
225
static Widget project_list = 0;
 
226
static Widget project_allow = 0;
 
227
static Widget project_deny = 0;
 
228
static Widget project_toggle = 0;
 
229
static Widget reporting_variables_list = 0;
 
230
static Widget reporting_variables_chosen = 0;
 
231
 
 
232
static tHostEntry host_data = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
 
233
static int add_mode = 0;
 
234
static int dialog_mode = SGE_ADMINHOST_LIST;
 
235
 
 
236
 
 
237
 
 
238
/*-------------------------------------------------------------------------*/
 
239
void qmonPopupHostConfig(Widget w, XtPointer cld, XtPointer cad)
 
240
{
 
241
   Widget shell;
 
242
   lList *alp = NULL;
 
243
 
 
244
   DENTER(GUI_LAYER, "qmonPopupHostConfig");
 
245
 
 
246
   /* set busy cursor */
 
247
   XmtDisplayBusyCursor(w);
 
248
 
 
249
   if (!qmon_host) {
 
250
      shell = XmtGetTopLevelShell(w);
 
251
      qmon_host = qmonCreateHostConfig(shell);
 
252
      XmtAddDeleteCallback(shell, XmDO_NOTHING, 
 
253
                              qmonPopdownHostConfig, NULL);
 
254
      XtAddEventHandler(XtParent(qmon_host), StructureNotifyMask, False,
 
255
                                SetMinShellSize, NULL);
 
256
   }
 
257
 
 
258
   qmonMirrorMultiAnswer(ADMINHOST_T | SUBMITHOST_T | EXECHOST_T | CENTRY_T |
 
259
                         USERSET_T | PROJECT_T, &alp);
 
260
   if (alp) {
 
261
      qmonMessageBox(w, alp, 0);
 
262
      lFreeList(&alp);
 
263
      /* set default cursor */
 
264
      XmtDisplayDefaultCursor(w);
 
265
      DEXIT;
 
266
      return;
 
267
   }
 
268
   
 
269
   qmonTimerAddUpdateProc(ADMINHOST_T, "updateHostList", updateHostList);
 
270
   qmonStartTimer(ADMINHOST_T | SUBMITHOST_T | EXECHOST_T |
 
271
                  USERSET_T | PROJECT_T);
 
272
   qmonHostFillList();
 
273
 
 
274
   xmui_manage(qmon_host);
 
275
 
 
276
   /* set default cursor */
 
277
   XmtDisplayDefaultCursor(w);
 
278
 
 
279
   DEXIT;
 
280
}
 
281
 
 
282
 
 
283
/*-------------------------------------------------------------------------*/
 
284
static void qmonPopdownHostConfig(Widget w, XtPointer cld, XtPointer cad)
 
285
{
 
286
   DENTER(GUI_LAYER, "qmonPopdownHostConfig");
 
287
 
 
288
   qmonStopTimer(ADMINHOST_T | SUBMITHOST_T | EXECHOST_T |
 
289
                 USERSET_T | PROJECT_T);
 
290
   qmonTimerRmUpdateProc(ADMINHOST_T, "updateHostList");
 
291
   xmui_unmanage(qmon_host);
 
292
 
 
293
   DEXIT;
 
294
}
 
295
 
 
296
/*-------------------------------------------------------------------------*/
 
297
static void updateHostListCB(Widget w, XtPointer cld, XtPointer cad)
 
298
{
 
299
   lList *alp = NULL;
 
300
 
 
301
   DENTER(GUI_LAYER, "updateHostListCB");
 
302
 
 
303
   /*
 
304
   ** fetch changed lists
 
305
   */
 
306
   qmonMirrorMultiAnswer(ADMINHOST_T | SUBMITHOST_T | EXECHOST_T | HGROUP_T, &alp);
 
307
   if (alp) {
 
308
      qmonMessageBox(w, alp, 0);
 
309
      lFreeList(&alp);
 
310
      DEXIT;
 
311
      return;
 
312
   }
 
313
 
 
314
   updateHostList();
 
315
}
 
316
 
 
317
/*-------------------------------------------------------------------------*/
 
318
static void updateHostList(void)
 
319
{
 
320
   DENTER(GUI_LAYER, "updateHostList");
 
321
 
 
322
   if (qmon_host && XtIsManaged(qmon_host))
 
323
      qmonHostFillList();
 
324
 
 
325
   DEXIT;
 
326
}
 
327
 
 
328
/*-------------------------------------------------------------------------*/
 
329
/* P R I V A T E                                                           */
 
330
/*-------------------------------------------------------------------------*/
 
331
 
 
332
/*-------------------------------------------------------------------------*/
 
333
static Widget qmonCreateHostConfig(
 
334
Widget parent 
 
335
) {
 
336
   Widget host_layout, host_add, host_delete, host_done, host_help,
 
337
          host_main_link, host_folder, adminhost_hostname, submithost_hostname,
 
338
          exechost_layout;
 
339
 
 
340
   DENTER(GUI_LAYER, "qmonCreateHostConfig");
 
341
   
 
342
   host_layout = XmtBuildQueryDialog( parent, "qmon_host",
 
343
                           NULL, 0,
 
344
                           "host_folder", &host_folder,
 
345
                           "host_add", &host_add,
 
346
                           "host_modify", &host_modify,
 
347
                           "host_delete", &host_delete,
 
348
                           "host_shutdown", &host_shutdown,
 
349
                           "host_done", &host_done,
 
350
                           "host_help", &host_help,
 
351
                           "host_main_link", &host_main_link,
 
352
                           "adminhost_list", &adminhost_list,
 
353
                           "submithost_list", &submithost_list,
 
354
                           "hostgroup_list", &hostgroup_list,
 
355
                           "hostgroup_memberlist", &hostgroup_memberlist,
 
356
                           "adminhost_hostname", &adminhost_hostname,
 
357
                           "submithost_hostname", &submithost_hostname,
 
358
                           NULL);
 
359
   
 
360
   hg_ask_layout = qmonCreateHostgroupAsk(host_folder);
 
361
   
 
362
   exechost_layout = qmonCreateExecHostConfig(host_folder, NULL);
 
363
   XtManageChild(exechost_layout);
 
364
 
 
365
                               
 
366
   XtAddCallback(host_main_link, XmNactivateCallback, 
 
367
                     qmonMainControlRaise, NULL);
 
368
   XtAddCallback(host_folder, XmNvalueChangedCallback, 
 
369
                     qmonHostFolderChange, NULL);
 
370
   XtAddCallback(host_done, XmNactivateCallback, 
 
371
                     qmonPopdownHostConfig, NULL);
 
372
   XtAddCallback(host_add, XmNactivateCallback, 
 
373
                     qmonHostAdd, (XtPointer) 1); 
 
374
   XtAddCallback(host_modify, XmNactivateCallback, 
 
375
                     qmonHostAdd, NULL); 
 
376
   XtAddCallback(host_delete, XmNactivateCallback, 
 
377
                     qmonHostDelete, NULL); 
 
378
   XtAddCallback(host_shutdown, XmNactivateCallback, 
 
379
                     qmonExecHostShutdown, NULL);
 
380
   XtAddCallback(adminhost_hostname, XmtNinputCallback, 
 
381
                     qmonHostAdd, NULL);
 
382
   XtAddCallback(submithost_hostname, XmtNinputCallback, 
 
383
                     qmonHostAdd, NULL);
 
384
   XtAddCallback(host_help, XmNactivateCallback, 
 
385
                     qmonHostHelp, NULL);
 
386
   XtAddCallback(hostgroup_list, XmNbrowseSelectionCallback,
 
387
                     qmonHostgroupSelect, NULL);
 
388
 
 
389
   XtAddEventHandler(XtParent(host_layout), StructureNotifyMask, False, 
 
390
                        SetMinShellSize, NULL);
 
391
 
 
392
   DEXIT;
 
393
   return host_layout;
 
394
}
 
395
 
 
396
/*-------------------------------------------------------------------------*/
 
397
static void qmonHostFillList(void)
 
398
{
 
399
   lList *lp;
 
400
   static lCondition *where = NULL;
 
401
   static lEnumeration *what = NULL;
 
402
   
 
403
   DENTER(GUI_LAYER, "qmonHostFillList");
 
404
 
 
405
 
 
406
   /* admin host list */
 
407
   lp = qmonMirrorList(SGE_ADMINHOST_LIST);
 
408
   lPSortList(lp, "%I+", AH_name);
 
409
   UpdateXmListFromCull(adminhost_list, XmFONTLIST_DEFAULT_TAG, lp, AH_name);
 
410
 
 
411
   /* submit host list */
 
412
   lp = qmonMirrorList(SGE_SUBMITHOST_LIST);
 
413
   lPSortList(lp, "%I+", SH_name);
 
414
   UpdateXmListFromCull(submithost_list, XmFONTLIST_DEFAULT_TAG, lp, SH_name);
 
415
 
 
416
   /* exec host is a special case needs additional configuration */
 
417
   if (!where)
 
418
      where = lWhere("%T(%I!=%s)", EH_Type, EH_name, SGE_TEMPLATE_NAME);
 
419
   if (!what)
 
420
      what = lWhat("%T(ALL)", EH_Type);
 
421
   
 
422
   lp = lSelect("EHL", qmonMirrorList(SGE_EXECHOST_LIST), where, what);
 
423
   lPSortList(lp, "%I+", EH_name);
 
424
   UpdateXmListFromCull(exechost_list, XmFONTLIST_DEFAULT_TAG, lp, EH_name);
 
425
   XmListMoveItemToPos(exechost_list, "global", 1);
 
426
   lFreeList(&lp);
 
427
   XmListSelectPos(exechost_list, 1, True);
 
428
 
 
429
   /* host groups */
 
430
   lp = qmonMirrorList(SGE_HGROUP_LIST);
 
431
   lPSortList(lp, "%I+", HGRP_name);
 
432
   UpdateXmListFromCull(hostgroup_list, XmFONTLIST_DEFAULT_TAG, lp, HGRP_name);
 
433
   XmListSelectPos(hostgroup_list, 1, True);
 
434
 
 
435
   DEXIT;
 
436
}
 
437
 
 
438
/*-------------------------------------------------------------------------*/
 
439
static void qmonHostAvailableReportVars(void)
 
440
{
 
441
   lList *lp;
 
442
   
 
443
   DENTER(GUI_LAYER, "qmonHostAvailableReportVars");
 
444
 
 
445
   lp = qmonMirrorList(SGE_CENTRY_LIST);
 
446
   lPSortList(lp, "%I+", CE_name);
 
447
   UpdateXmListFromCull(reporting_variables_list, XmFONTLIST_DEFAULT_TAG, lp, CE_name);
 
448
 
 
449
   DEXIT;
 
450
}
 
451
 
 
452
/*-------------------------------------------------------------------------*/
 
453
static void qmonHostAvailableAcls(void)
 
454
{
 
455
   lList *lp;
 
456
   
 
457
   DENTER(GUI_LAYER, "qmonHostAvailableAcls");
 
458
 
 
459
   lp = qmonMirrorList(SGE_USERSET_LIST);
 
460
   lPSortList(lp, "%I+", US_name);
 
461
   UpdateXmListFromCull(access_list, XmFONTLIST_DEFAULT_TAG, lp, US_name);
 
462
 
 
463
   DEXIT;
 
464
}
 
465
 
 
466
/*-------------------------------------------------------------------------*/
 
467
static void qmonHostAvailableProjects(void)
 
468
{
 
469
   lList *lp;
 
470
   
 
471
   DENTER(GUI_LAYER, "qmonHostAvailableProjects");
 
472
 
 
473
   lp = qmonMirrorList(SGE_PROJECT_LIST);
 
474
   lPSortList(lp, "%I+", PR_name);
 
475
   UpdateXmListFromCull(project_list, XmFONTLIST_DEFAULT_TAG, lp, PR_name);
 
476
 
 
477
   DEXIT;
 
478
}
 
479
 
 
480
 
 
481
/*-------------------------------------------------------------------------*/
 
482
/* Exec Host Stuff                                                         */
 
483
/*-------------------------------------------------------------------------*/
 
484
static Widget qmonCreateExecHostConfig(
 
485
Widget parent,
 
486
XtPointer cld 
 
487
) {
 
488
   Widget exechost_layout, exechost_add, exechost_shutdown, 
 
489
          exechost_modify, exechost_delete, exechost_done;
 
490
 
 
491
   DENTER(GUI_LAYER, "qmonCreateExecHostConfig");
 
492
   
 
493
   exechost_layout = XmtCreateLayout(parent, "exechost_layout", NULL, 0);
 
494
   XmtDialogBindResourceList(exechost_layout, host_resources, 
 
495
                              XtNumber(host_resources));
 
496
   XmtCreateQueryChildren( exechost_layout,
 
497
                           "exechost_list", &exechost_list,
 
498
                           "exechost_load_scaling", &exechost_load_scaling,
 
499
                           "exechost_usage_scaling", &exechost_usage_scaling,
 
500
                           "exechost_add", &exechost_add,
 
501
                           "exechost_modify", &exechost_modify,
 
502
                           "exechost_delete", &exechost_delete,
 
503
                           "exechost_done", &exechost_done,
 
504
                           "exechost_shutdown", &exechost_shutdown,
 
505
                           "exechost_consumables", &exechost_consumables,
 
506
                           "exechost_access", &exechost_access,
 
507
                           "exechost_reporting_variables", 
 
508
                                    &exechost_reporting_variables,
 
509
                           NULL);
 
510
 
 
511
   XtAddCallback(exechost_list, XmNbrowseSelectionCallback,
 
512
                     qmonExecHostSelect, NULL);
 
513
 
 
514
#if 0
 
515
   XtAddCallback(exechost_done, XmNactivateCallback, 
 
516
                     qmonPopdownHostConfig, NULL);
 
517
   XtAddCallback(exechost_add, XmNactivateCallback, 
 
518
                     qmonExecHostChange, (XtPointer) 1);
 
519
   XtAddCallback(exechost_modify, XmNactivateCallback, 
 
520
                     qmonExecHostChange, (XtPointer) 0);
 
521
   XtAddCallback(exechost_delete, XmNactivateCallback, 
 
522
                     qmonHostDelete, (XtPointer) SGE_EXECHOST_LIST);
 
523
   XtAddCallback(exechost_shutdown, XmNactivateCallback, 
 
524
                     qmonExecHostShutdown, NULL);
 
525
#endif
 
526
 
 
527
   /*
 
528
   ** create exec host ask dialog for adding/modifying exec hosts
 
529
   */
 
530
   eh_ask_layout = qmonCreateExecHostAsk(exechost_layout);
 
531
  
 
532
   DEXIT;
 
533
   return exechost_layout;
 
534
}
 
535
 
 
536
/*-------------------------------------------------------------------------*/
 
537
static void qmonExecHostSelect(Widget w, XtPointer cld, XtPointer cad)
 
538
{
 
539
   XmListCallbackStruct *cbs = (XmListCallbackStruct*) cad;
 
540
   char *ehname;
 
541
   lListElem *ehp;
 
542
   lListElem *ep;
 
543
   lList *lsl;
 
544
   lList *usl;
 
545
   static char buf[10*BUFSIZ];
 
546
   XmTextPosition pos;
 
547
   
 
548
   DENTER(GUI_LAYER, "qmonExecHostSelect");
 
549
 
 
550
   if (! XmStringGetLtoR(cbs->item, XmFONTLIST_DEFAULT_TAG, &ehname)) {
 
551
      fprintf(stderr, "XmStringGetLtoR failed\n");
 
552
      DEXIT;
 
553
      return;
 
554
   }
 
555
 
 
556
   ehp = host_list_locate(qmonMirrorList(SGE_EXECHOST_LIST), ehname);
 
557
   XtFree((char*) ehname);
 
558
 
 
559
   if (ehp) {
 
560
      /*
 
561
      ** fill the load scaling and usage scaling list
 
562
      */
 
563
      lsl = lGetList(ehp, EH_scaling_list);
 
564
 
 
565
      XmTextDisableRedisplay(exechost_load_scaling);
 
566
      pos = 0;
 
567
      XmTextSetString(exechost_load_scaling, "");
 
568
      for_each(ep, lsl) {
 
569
         sprintf(buf, "%-15.15s   %3.2f\n", lGetString(ep, HS_name),
 
570
                  lGetDouble(ep, HS_value));
 
571
         XmTextInsert(exechost_load_scaling, pos, buf);
 
572
         pos += strlen(buf);
 
573
      }
 
574
      XmTextEnableRedisplay(exechost_load_scaling);
 
575
    
 
576
      /*
 
577
      ** fill the consumable list into the textfield
 
578
      */
 
579
      lsl = lGetList(ehp, EH_consumable_config_list);
 
580
      XmTextDisableRedisplay(exechost_consumables);
 
581
      pos = 0;
 
582
      XmTextSetString(exechost_consumables, "");
 
583
      for_each(ep, lsl) {
 
584
         sprintf(buf, "%-15.15s   %-15.15s\n", lGetString(ep, CE_name),
 
585
                  lGetString(ep, CE_stringval));
 
586
         XmTextInsert(exechost_consumables, pos, buf);
 
587
         pos += strlen(buf);
 
588
      }
 
589
      XmTextEnableRedisplay(exechost_consumables);
 
590
    
 
591
      /*
 
592
      ** reporting variables
 
593
      */
 
594
      lsl = lGetList(ehp, EH_report_variables);
 
595
      XmTextDisableRedisplay(exechost_reporting_variables);
 
596
      pos = 0;
 
597
      XmTextSetString(exechost_reporting_variables, "");
 
598
      for_each(ep, lsl) {
 
599
         sprintf(buf, "%s\n", lGetString(ep, STU_name));
 
600
         XmTextInsert(exechost_reporting_variables, pos, buf);
 
601
         pos += strlen(buf);
 
602
      }
 
603
      XmTextEnableRedisplay(exechost_reporting_variables);
 
604
 
 
605
      /*
 
606
      ** fill the access list into the textfield
 
607
      */
 
608
      XmTextDisableRedisplay(exechost_access);
 
609
      pos = 0;
 
610
      XmTextSetString(exechost_access, "");
 
611
 
 
612
      /*
 
613
      ** acl
 
614
      */
 
615
      lsl = lGetList(ehp, EH_acl);
 
616
      sprintf(buf, "%-15.15s", "Access");
 
617
      for_each(ep, lsl) {
 
618
         strcat(buf, " ");
 
619
         strcat(buf, lGetString(ep, US_name));
 
620
      }
 
621
      if (!lGetNumberOfElem(lsl))
 
622
         strcat(buf, " NONE");
 
623
      strcat(buf, "\n");
 
624
      XmTextInsert(exechost_access, pos, buf);
 
625
      pos += strlen(buf);
 
626
 
 
627
      /*
 
628
      ** xacl
 
629
      */
 
630
      lsl = lGetList(ehp, EH_xacl);
 
631
      sprintf(buf, "%-15.15s", "XAccess");
 
632
      for_each(ep, lsl) {
 
633
         strcat(buf, " ");
 
634
         strcat(buf, lGetString(ep, US_name));
 
635
      }
 
636
      if (!lGetNumberOfElem(lsl))
 
637
         strcat(buf, " NONE");
 
638
      strcat(buf, "\n");
 
639
      XmTextInsert(exechost_access, pos, buf);
 
640
      pos += strlen(buf);
 
641
 
 
642
      /*
 
643
      ** projects
 
644
      */
 
645
      lsl = lGetList(ehp, EH_prj);
 
646
      sprintf(buf, "%-15.15s", "Projects");
 
647
      for_each(ep, lsl) {
 
648
         strcat(buf, " ");
 
649
         strcat(buf, lGetString(ep, PR_name));
 
650
      }
 
651
      if (!lGetNumberOfElem(lsl))
 
652
         strcat(buf, " NONE");
 
653
      strcat(buf, "\n");
 
654
      XmTextInsert(exechost_access, pos, buf);
 
655
      pos += strlen(buf);
 
656
 
 
657
      /*
 
658
      ** xprojects
 
659
      */
 
660
      lsl = lGetList(ehp, EH_xprj);
 
661
      sprintf(buf, "%-15.15s", "XProjects");
 
662
      for_each(ep, lsl) {
 
663
         strcat(buf, " ");
 
664
         strcat(buf, lGetString(ep, PR_name));
 
665
      }
 
666
      if (!lGetNumberOfElem(lsl))
 
667
         strcat(buf, " NONE");
 
668
      strcat(buf, "\n");
 
669
      XmTextInsert(exechost_access, pos, buf);
 
670
      pos += strlen(buf);
 
671
 
 
672
      XmTextEnableRedisplay(exechost_access);
 
673
    
 
674
      usl = lGetList(ehp, EH_usage_scaling_list);
 
675
      XmTextDisableRedisplay(exechost_usage_scaling);
 
676
      pos = 0;
 
677
      XmTextSetString(exechost_usage_scaling, "");
 
678
      for_each(ep, usl) {
 
679
         sprintf(buf, "%-15.15s   %3.2f\n", lGetString(ep, HS_name),
 
680
                  lGetDouble(ep, HS_value));
 
681
         XmTextInsert(exechost_usage_scaling, pos, buf);
 
682
         pos += strlen(buf);
 
683
      }
 
684
      XmTextEnableRedisplay(exechost_usage_scaling);
 
685
 
 
686
   }
 
687
   DEXIT;
 
688
}
 
689
 
 
690
/*-------------------------------------------------------------------------*/
 
691
static Widget qmonCreateExecHostAsk(
 
692
Widget parent 
 
693
) {
 
694
   Widget eh_ok, eh_cancel, eh_load_scaling, eh_usage_scaling, 
 
695
          complexes_ccl;
 
696
   Widget access_add, access_remove, access_dialog;
 
697
   Widget reporting_variables_add, reporting_variables_remove;
 
698
   Widget project_add, project_remove, project_dialog, eh_project;
 
699
 
 
700
   DENTER(GUI_LAYER, "qmonCreateExecHostAsk");
 
701
   
 
702
   eh_ask_layout = XmtBuildQueryDialog( parent, "eh_ask_shell",
 
703
                           host_resources, XtNumber(host_resources),
 
704
                           "eh_ok", &eh_ok,
 
705
                           "eh_folder", &eh_folder,
 
706
                           "eh_cancel", &eh_cancel,
 
707
                           "eh_name", &eh_name_w,
 
708
                           "eh_load_scaling", &eh_load_scaling,
 
709
                           "eh_usage_scaling", &eh_usage_scaling,
 
710
                           "complexes_ccl", &complexes_ccl,
 
711
                           /* access_config */
 
712
                           "access_list", &access_list,
 
713
                           "access_allow", &access_allow,
 
714
                           "access_deny", &access_deny,
 
715
                           "access_add", &access_add,
 
716
                           "access_remove", &access_remove,
 
717
                           "access_toggle", &access_toggle,
 
718
                           "access_dialog", &access_dialog,
 
719
                           /* project_config */
 
720
                           "project_list", &project_list,
 
721
                           "project_allow", &project_allow,
 
722
                           "project_deny", &project_deny,
 
723
                           "project_add", &project_add,
 
724
                           "project_remove", &project_remove,
 
725
                           "project_toggle", &project_toggle,
 
726
                           "project_dialog", &project_dialog,
 
727
                           "eh_project", &eh_project,
 
728
                           "reporting_variables_list", &reporting_variables_list,
 
729
                           "reporting_variables_chosen", &reporting_variables_chosen,
 
730
                           "reporting_variables_add", &reporting_variables_add,
 
731
                           "reporting_variables_remove", &reporting_variables_remove,
 
732
                           NULL);
 
733
 
 
734
   XtAddCallback(eh_ok, XmNactivateCallback, 
 
735
                     qmonExecHostOk, NULL);
 
736
   XtAddCallback(eh_cancel, XmNactivateCallback, 
 
737
                     qmonExecHostCancel, NULL);
 
738
   XtAddCallback(eh_name_w, XmtNverifyCallback, 
 
739
                     qmonExecHostCheckName, NULL);
 
740
   XtAddCallback(eh_load_scaling, XmNleaveCellCallback, 
 
741
                     qmonExecHostCheckScaling, NULL);
 
742
   XtAddCallback(eh_usage_scaling, XmNleaveCellCallback, 
 
743
                     qmonExecHostCheckScaling, NULL);
 
744
 
 
745
   XtAddCallback(complexes_ccl, XmNselectCellCallback,
 
746
                  qmonLoadSelectEntry, NULL);
 
747
   XtAddCallback(complexes_ccl, XmNlabelActivateCallback,
 
748
                  qmonLoadNames, (XtPointer) 1);
 
749
 
 
750
   XtAddCallback(access_toggle, XmtNvalueChangedCallback, 
 
751
                     qmonExecHostAccessToggle, NULL);
 
752
   XtAddCallback(access_add, XmNactivateCallback, 
 
753
                     qmonExecHostAccessAdd, NULL);
 
754
   XtAddCallback(access_remove, XmNactivateCallback, 
 
755
                     qmonExecHostAccessRemove, NULL);
 
756
   XtAddCallback(access_dialog, XmNactivateCallback, 
 
757
                     qmonPopupManopConfig, (XtPointer)2);
 
758
 
 
759
   XtAddCallback(reporting_variables_add, XmNactivateCallback, 
 
760
                     qmonExecHostReportVarAdd, NULL);
 
761
   XtAddCallback(reporting_variables_remove, XmNactivateCallback, 
 
762
                     qmonExecHostReportVarRemove, NULL);
 
763
 
 
764
   /*
 
765
   ** Project & Xproject
 
766
   */
 
767
   XtAddCallback(project_toggle, XmtNvalueChangedCallback, 
 
768
                     qmonExecHostProjectToggle, NULL);
 
769
   XtAddCallback(project_add, XmNactivateCallback, 
 
770
                     qmonExecHostProjectAdd, NULL);
 
771
   XtAddCallback(project_remove, XmNactivateCallback, 
 
772
                     qmonExecHostProjectRemove, NULL);
 
773
   XtAddCallback(project_dialog, XmNactivateCallback, 
 
774
                     qmonPopupProjectConfig, NULL);
 
775
 
 
776
   XtAddEventHandler(XtParent(eh_ask_layout), StructureNotifyMask, False, 
 
777
                        SetMinShellSize, NULL);
 
778
 
 
779
   DEXIT;
 
780
   return eh_ask_layout;
 
781
}
 
782
 
 
783
/*-------------------------------------------------------------------------*/
 
784
static void qmonExecHostOk(Widget w, XtPointer cld, XtPointer cad)
 
785
{
 
786
   lList *ehl = NULL;
 
787
   lList *alp;
 
788
   lEnumeration *what;
 
789
   Boolean status = False;
 
790
   XmString xehname = NULL;
 
791
   StringConst ehname = NULL;
 
792
 
 
793
   DENTER(GUI_LAYER, "qmonExecHostOk");
 
794
 
 
795
   /*
 
796
   ** get the list with one new host
 
797
   */
 
798
   ehl = qmonExecHostGetAsk();
 
799
 
 
800
   if (ehl) {
 
801
      ehname = lGetHost(lFirst(ehl), EH_name);
 
802
      /*
 
803
      ** gdi call 
 
804
      */
 
805
      what = lWhat("%T(ALL)", EH_Type);
 
806
      
 
807
      if (add_mode) {
 
808
         alp = qmonAddList(SGE_EXECHOST_LIST, qmonMirrorListRef(SGE_EXECHOST_LIST), EH_name, &ehl, NULL, what);
 
809
      }
 
810
      else {
 
811
         alp = qmonModList(SGE_EXECHOST_LIST, qmonMirrorListRef(SGE_EXECHOST_LIST), EH_name, &ehl, NULL, what);
 
812
      }
 
813
 
 
814
      if (lFirst(alp) && lGetUlong(lFirst(alp), AN_status) == STATUS_OK)
 
815
         status = True;
 
816
 
 
817
      qmonMessageBox(w, alp, 0);
 
818
      lFreeList(&alp);
 
819
 
 
820
      if (status) {
 
821
         XtUnmanageChild(eh_ask_layout);
 
822
         updateHostList();
 
823
         /*
 
824
         ** select the modified or added Exec Host
 
825
         */
 
826
         xehname = XmtCreateXmString(ehname);
 
827
         XmListSelectItem(exechost_list, xehname, True);
 
828
         XmStringFree(xehname);
 
829
      } else {
 
830
         qmonExecHostSetAsk(ehname);
 
831
      }   
 
832
 
 
833
      lFreeWhat(&what);
 
834
      lFreeList(&ehl);
 
835
   }
 
836
 
 
837
   DEXIT;
 
838
}
 
839
 
 
840
/*-------------------------------------------------------------------------*/
 
841
static void qmonExecHostCancel(Widget w, XtPointer cld, XtPointer cad)
 
842
{
 
843
   DENTER(GUI_LAYER, "qmonExecHostCancel");
 
844
 
 
845
   XtUnmanageChild(eh_ask_layout);
 
846
 
 
847
   DEXIT;
 
848
}
 
849
 
 
850
 
 
851
/*-------------------------------------------------------------------------*/
 
852
static lList* qmonExecHostGetAsk(void)
 
853
{
 
854
   lList *lp;
 
855
   static lCondition *where = NULL;
 
856
   
 
857
   DENTER(GUI_LAYER, "qmonExecHostGetAsk");
 
858
 
 
859
   lp = lCreateElemList("EH", EH_Type, 1);
 
860
 
 
861
   if (lp) {
 
862
      XmtDialogGetDialogValues(eh_ask_layout, &host_data);
 
863
 
 
864
      /*
 
865
      ** name of exec_host
 
866
      */
 
867
      lSetHost(lFirst(lp), EH_name, host_data.name);
 
868
      XtFree((char*)host_data.name);
 
869
      host_data.name = NULL;
 
870
      
 
871
      /*
 
872
      ** the cast to double is absolutely necessary, otherwise
 
873
      ** the varargs get expanded in a wrong way
 
874
      */
 
875
      if (!where) 
 
876
         where = lWhere("%T(%I != %g)", HS_Type, HS_value, (double)1.0);
 
877
      /*
 
878
      ** load scaling
 
879
      */
 
880
      host_data.scaling_list = lSelectDestroy(host_data.scaling_list,
 
881
                                                where);
 
882
 
 
883
      lSetList(lFirst(lp), EH_scaling_list, host_data.scaling_list);
 
884
      host_data.scaling_list = NULL;
 
885
 
 
886
      /*
 
887
      ** consumable_config_list 
 
888
      */
 
889
      lSetList(lFirst(lp), EH_consumable_config_list, 
 
890
                     host_data.consumable_config_list);
 
891
      host_data.consumable_config_list = NULL;
 
892
 
 
893
      /*
 
894
      ** (x)acl 
 
895
      */
 
896
      lSetList(lFirst(lp), EH_acl, host_data.acl);
 
897
      host_data.acl = NULL;
 
898
      lSetList(lFirst(lp), EH_xacl, host_data.xacl);
 
899
      host_data.xacl = NULL;
 
900
      /*
 
901
      ** reporting variables
 
902
      */
 
903
      lSetList(lFirst(lp), EH_report_variables, host_data.reporting_variables);
 
904
      host_data.reporting_variables = NULL;
 
905
 
 
906
      /*
 
907
      ** usage scaling
 
908
      */
 
909
      host_data.usage_scaling_list = 
 
910
                  lSelectDestroy(host_data.usage_scaling_list,
 
911
                                       where);
 
912
   
 
913
      lSetList(lFirst(lp), EH_usage_scaling_list, 
 
914
                        host_data.usage_scaling_list);
 
915
      host_data.usage_scaling_list = NULL;
 
916
 
 
917
      /*
 
918
      ** (x)project 
 
919
      */
 
920
      lSetList(lFirst(lp), EH_prj, host_data.prj);
 
921
      host_data.prj = NULL;
 
922
      lSetList(lFirst(lp), EH_xprj, host_data.xprj);
 
923
      host_data.xprj = NULL;
 
924
   }
 
925
               
 
926
   DEXIT;
 
927
   return lp;
 
928
}
 
929
 
 
930
 
 
931
/*-------------------------------------------------------------------------*/
 
932
static void qmonExecHostSetAsk(
 
933
StringConst name 
 
934
) {
 
935
   lListElem *ehp = NULL;
 
936
   lListElem *ep;
 
937
   lListElem *lsep;
 
938
   lListElem *usep;
 
939
   lList *lsl = NULL;
 
940
   lList *ehl = NULL;
 
941
   lList *cl = NULL;
 
942
   lList *ehsl = NULL;
 
943
   lList *ehul = NULL;
 
944
   lList *usl = NULL;
 
945
   lList *entries = NULL;
 
946
   lList *acls = NULL;
 
947
   lList *prjs = NULL;
 
948
   static lCondition *where = NULL;
 
949
   
 
950
   DENTER(GUI_LAYER, "qmonExecHostSetAsk");
 
951
 
 
952
   cl = qmonMirrorList(SGE_CENTRY_LIST);
 
953
   ehl = qmonMirrorList(SGE_EXECHOST_LIST);
 
954
   acls = qmonMirrorList(SGE_USERSET_LIST);
 
955
   prjs = qmonMirrorList(SGE_PROJECT_LIST);
 
956
 
 
957
   if (name) {
 
958
      /*
 
959
      ** get the selected host element
 
960
      */
 
961
      ehp = host_list_locate(ehl, name);
 
962
      if (host_data.name)
 
963
         XtFree((char*)host_data.name);
 
964
      host_data.name = XtNewString(name);
 
965
   } else {
 
966
      if (host_data.name)
 
967
         XtFree((char*)host_data.name);
 
968
      host_data.name = NULL;
 
969
   }   
 
970
      
 
971
   /* get complex entries and filter out scalable entries */
 
972
   entries = lCopyList("", cl);
 
973
   if (!where)
 
974
      where = lWhere("%T(%I == %u || %I == %u || %I == %u || %I == %u)", CE_Type,
 
975
                     CE_valtype, TYPE_INT, CE_valtype, TYPE_TIM, 
 
976
                     CE_valtype, TYPE_DOUBLE, CE_valtype, TYPE_MEM);
 
977
   entries = lSelectDestroy(entries, where);
 
978
   lPSortList(entries, "%I+", CE_name);
 
979
   for_each (ep, entries) {
 
980
      lsep = lAddElemStr(&lsl, HS_name, lGetString(ep, CE_name), HS_Type);
 
981
      lSetDouble(lsep, HS_value, 1.0);
 
982
   }
 
983
   lFreeList(&entries);
 
984
      
 
985
   if (ehp) {
 
986
      ehsl = lGetList(ehp, EH_scaling_list);
 
987
      
 
988
      for_each (ep, ehsl) {
 
989
         lsep = lGetElemStr(lsl, HS_name, lGetString(ep, HS_name));
 
990
         lSetDouble(lsep, HS_value, lGetDouble(ep, HS_value));
 
991
      }
 
992
   }
 
993
 
 
994
   /* 
 
995
   ** set now fully configured load scaling list 
 
996
   */
 
997
   lFreeList(&(host_data.scaling_list));
 
998
   host_data.scaling_list = lsl;
 
999
 
 
1000
   /*
 
1001
   ** set the consumable/per slot limit entries
 
1002
   */
 
1003
   if (ehp) {
 
1004
      host_data.consumable_config_list = lGetList(ehp, 
 
1005
                                             EH_consumable_config_list);
 
1006
   }
 
1007
   else {
 
1008
      host_data.consumable_config_list = NULL;
 
1009
   }
 
1010
 
 
1011
   /*
 
1012
   ** set (x)acl
 
1013
   */
 
1014
   if (ehp) {
 
1015
      host_data.acl = lGetList(ehp, EH_acl);
 
1016
      host_data.xacl = lGetList(ehp, EH_xacl);
 
1017
   }
 
1018
   else {
 
1019
      host_data.acl = NULL;
 
1020
      host_data.xacl = NULL;
 
1021
   }
 
1022
 
 
1023
   /*
 
1024
   ** set reporting variables
 
1025
   */
 
1026
   if (ehp) {
 
1027
      host_data.reporting_variables = lGetList(ehp, EH_report_variables);
 
1028
   }
 
1029
   else {
 
1030
      host_data.reporting_variables = NULL;
 
1031
   }
 
1032
 
 
1033
   
 
1034
   
 
1035
   /*
 
1036
   ** build the usage scaling list, we have three entries at the moment:
 
1037
   ** cpu, io, mem
 
1038
   */
 
1039
   usl = lCreateElemList("UsageScalingList", HS_Type, 3);
 
1040
   ep = lFirst(usl);
 
1041
   lSetString(ep, HS_name, USAGE_ATTR_CPU);
 
1042
   lSetDouble(ep, HS_value, 1.0);
 
1043
   ep = lNext(ep);
 
1044
   lSetString(ep, HS_name, USAGE_ATTR_MEM);
 
1045
   lSetDouble(ep, HS_value, 1.0);
 
1046
   ep = lNext(ep);
 
1047
   lSetString(ep, HS_name, USAGE_ATTR_IO);
 
1048
   lSetDouble(ep, HS_value, 1.0);
 
1049
 
 
1050
   if (ehp) {
 
1051
      /*
 
1052
      ** get the usage scaling list from host
 
1053
      */
 
1054
      ehul = lGetList(ehp, EH_usage_scaling_list);
 
1055
      
 
1056
      for_each (ep, ehul) {
 
1057
         usep = lGetElemStr(usl, HS_name, lGetString(ep, HS_name));
 
1058
         lSetDouble(usep, HS_value, lGetDouble(ep, HS_value));
 
1059
      }
 
1060
   }
 
1061
 
 
1062
   /* 
 
1063
   ** set now fully configured usage scaling list 
 
1064
   */
 
1065
   lFreeList(&(host_data.usage_scaling_list));
 
1066
   host_data.usage_scaling_list = usl;
 
1067
 
 
1068
   /*
 
1069
   ** set (x)project
 
1070
   */
 
1071
   if (ehp) {
 
1072
      host_data.prj = lGetList(ehp, EH_prj);
 
1073
      host_data.xprj = lGetList(ehp, EH_xprj);
 
1074
   }
 
1075
   else {
 
1076
      host_data.prj = NULL;
 
1077
      host_data.xprj = NULL;
 
1078
   }
 
1079
 
 
1080
   /*
 
1081
   ** set the values in the matrices
 
1082
   */
 
1083
   XmtDialogSetDialogValues(eh_ask_layout, &host_data);
 
1084
   
 
1085
   /*
 
1086
   ** fill the acl list
 
1087
   */
 
1088
   qmonHostAvailableAcls();
 
1089
 
 
1090
   /*
 
1091
   ** fill the reporting variables
 
1092
   */
 
1093
   qmonHostAvailableReportVars();
 
1094
 
 
1095
   /*
 
1096
   ** fill the project list
 
1097
   */
 
1098
   qmonHostAvailableProjects();
 
1099
 
 
1100
   DEXIT;
 
1101
}
 
1102
 
 
1103
 
 
1104
/*-------------------------------------------------------------------------*/
 
1105
static void qmonExecHostShutdown(Widget w, XtPointer cld, XtPointer cad)
 
1106
{
 
1107
   lList *lp = NULL;
 
1108
   lList *alp = NULL;
 
1109
   static lCondition *where = NULL;
 
1110
   const char *default_cell = ctx->get_default_cell(ctx);
 
1111
 
 
1112
   DENTER(GUI_LAYER, "qmonExecHostShutdown");
 
1113
 
 
1114
   if (!where) 
 
1115
      where = lWhere("%T(%I != %s)", EH_Type, EH_name, SGE_GLOBAL_NAME);
 
1116
 
 
1117
   lp = XmStringToCull(exechost_list, EH_Type, EH_name, SELECTED_ITEMS);
 
1118
   lp = lSelectDestroy(lp, where); 
 
1119
 
 
1120
   /* if no elements remain, we get an empty list, however gdi_kill()
 
1121
    * deletes all hosts if list is empty
 
1122
    */
 
1123
   if (lp) {
 
1124
      alp = ctx->kill(ctx, lp, default_cell, 0, EXECD_KILL); 
 
1125
      qmonMessageBox(w, alp, 1);
 
1126
      lFreeList(&lp);
 
1127
      lFreeList(&alp);
 
1128
   }
 
1129
 
 
1130
   DEXIT;
 
1131
}
 
1132
         
 
1133
/*-------------------------------------------------------------------------*/
 
1134
static void qmonHostDelete(Widget w, XtPointer cld, XtPointer cad)
 
1135
{
 
1136
   /* int type = (int)(long) cld; */ /* 
 
1137
                                * 64 bit pointers == long , this cast
 
1138
                                * keeps the compiler's mouth shut
 
1139
                                */
 
1140
   int type = dialog_mode;
 
1141
   lList *lp = NULL;
 
1142
   lList *alp = NULL;
 
1143
   lEnumeration *what = NULL;
 
1144
   lDescr *dp;
 
1145
   int field;
 
1146
   Widget list;
 
1147
 
 
1148
   DENTER(GUI_LAYER, "qmonHostDelete");
 
1149
 
 
1150
   switch (type) {
 
1151
      case SGE_ADMINHOST_LIST:
 
1152
         dp = AH_Type;
 
1153
         list = adminhost_list;
 
1154
         field = AH_name;
 
1155
         break;
 
1156
      case SGE_SUBMITHOST_LIST:
 
1157
         dp = SH_Type;
 
1158
         list = submithost_list;
 
1159
         field = SH_name;
 
1160
         break;
 
1161
      case SGE_EXECHOST_LIST:
 
1162
         dp = EH_Type;
 
1163
         list = exechost_list;
 
1164
         field = EH_name;
 
1165
         break;
 
1166
      case SGE_HGROUP_LIST:
 
1167
         dp = HGRP_Type;
 
1168
         list = hostgroup_list;
 
1169
         field = HGRP_name;
 
1170
         break;
 
1171
      default:
 
1172
         DEXIT;
 
1173
         return;
 
1174
   }
 
1175
    
 
1176
   lp = XmStringToCull(list, dp, field, SELECTED_ITEMS);
 
1177
      
 
1178
   if (lp) {
 
1179
      what = lWhat("%T(ALL)", dp);
 
1180
      
 
1181
      alp = qmonDelList(type, qmonMirrorListRef(type), field, &lp, NULL, what);
 
1182
 
 
1183
      qmonMessageBox(w, alp, 0);
 
1184
 
 
1185
      updateHostList();
 
1186
      
 
1187
      lFreeWhat(&what);
 
1188
      lFreeList(&lp);
 
1189
      lFreeList(&alp);
 
1190
   }
 
1191
   DEXIT;
 
1192
}
 
1193
         
 
1194
/*-------------------------------------------------------------------------*/
 
1195
static void qmonHostHelp(Widget w, XtPointer cld, XtPointer cad)
 
1196
{
 
1197
   Widget widget = 0;
 
1198
   
 
1199
   DENTER(GUI_LAYER, "qmonHostHelp");
 
1200
 
 
1201
   switch(dialog_mode) {
 
1202
      case SGE_ADMINHOST_LIST:
 
1203
         widget = adminhost_list; 
 
1204
         break;
 
1205
      case SGE_SUBMITHOST_LIST:
 
1206
         widget = submithost_list; 
 
1207
         break;
 
1208
      case SGE_HGROUP_LIST:
 
1209
         widget = hostgroup_list; 
 
1210
         break;
 
1211
      case SGE_EXECHOST_LIST:
 
1212
         widget = exechost_list; 
 
1213
         break;
 
1214
   }
 
1215
 
 
1216
   XmtHelpDisplayContextHelp(widget);  
 
1217
 
 
1218
   DEXIT;
 
1219
}
 
1220
 
 
1221
 
 
1222
/*-------------------------------------------------------------------------*/
 
1223
static void qmonHostAdd(Widget w, XtPointer cld, XtPointer cad)
 
1224
{
 
1225
   int type = dialog_mode;
 
1226
   lList *lp = NULL;
 
1227
   lList *alp = NULL;
 
1228
   lEnumeration *what = NULL;
 
1229
   String host = NULL;
 
1230
   char unique[CL_MAXHOSTLEN];
 
1231
   lDescr *dp;
 
1232
   int field, ret;
 
1233
   Widget list;
 
1234
   Widget hostname;
 
1235
 
 
1236
   DENTER(GUI_LAYER, "qmonHostAdd");
 
1237
 
 
1238
   switch (type) {
 
1239
      case SGE_ADMINHOST_LIST:
 
1240
         dp = AH_Type;
 
1241
         list = adminhost_list;
 
1242
         field = AH_name;
 
1243
         hostname = XmtNameToWidget(list, "~*adminhost_hostname");
 
1244
         break;
 
1245
      case SGE_SUBMITHOST_LIST:
 
1246
         dp = SH_Type;
 
1247
         list = submithost_list;
 
1248
         field = SH_name;
 
1249
         hostname = XmtNameToWidget(list, "~*submithost_hostname");
 
1250
         break;
 
1251
      case SGE_HGROUP_LIST:
 
1252
         qmonHostgroupChange(w, cld, NULL); 
 
1253
         DEXIT;
 
1254
         return;
 
1255
      case SGE_EXECHOST_LIST:
 
1256
         qmonExecHostChange(w, cld, NULL); 
 
1257
         DEXIT;
 
1258
         return;
 
1259
      default:
 
1260
         DPRINTF(("Not allowed\n"));
 
1261
         DEXIT;
 
1262
         return;
 
1263
   }
 
1264
 
 
1265
   host = XmtInputFieldGetString(hostname);
 
1266
   
 
1267
 
 
1268
   if (host && host[0] != '\0' && host[0] != ' ') { 
 
1269
       
 
1270
      DPRINTF(("host = %s\n", host));
 
1271
 
 
1272
      /* try to resolve hostname */
 
1273
      ret=sge_resolve_hostname(host, unique, EH_name);
 
1274
 
 
1275
      switch ( ret ) {
 
1276
         case CL_RETVAL_GETHOSTNAME_ERROR:
 
1277
            qmonMessageShow(w, True, "Can't resolve host '%s'", host);
 
1278
            break;
 
1279
         case CL_RETVAL_OK:
 
1280
            what = lWhat("%T(ALL)", dp);
 
1281
            
 
1282
            if (!(lp = lCreateElemList("AH", dp, 1))) {
 
1283
               fprintf(stderr, "lCreateElemList failed\n");
 
1284
               lFreeWhat(&what);
 
1285
               DEXIT;
 
1286
               return;
 
1287
            }
 
1288
            lSetHost(lFirst(lp), field, unique);
 
1289
 
 
1290
            alp = qmonAddList(type, qmonMirrorListRef(type), 
 
1291
                                 field, &lp, NULL, what);
 
1292
               
 
1293
            qmonMessageBox(w, alp, 0);
 
1294
               
 
1295
            updateHostList();
 
1296
            XmListSelectPos(list, 0, True);
 
1297
            
 
1298
            lFreeWhat(&what);
 
1299
            lFreeList(&lp);
 
1300
            lFreeList(&alp);
 
1301
            break;
 
1302
            
 
1303
         default:
 
1304
            DPRINTF(("sge_resolve_hostname() failed resolving: %s\n", cl_get_error_text(ret)));
 
1305
      }
 
1306
      XmtInputFieldSetString(hostname, "");
 
1307
   }
 
1308
   
 
1309
   DEXIT;
 
1310
}
 
1311
 
 
1312
/*-------------------------------------------------------------------------*/
 
1313
static void qmonExecHostChange(Widget w, XtPointer cld, XtPointer cad)
 
1314
{
 
1315
   long mode = (long) cld;
 
1316
   Cardinal ehnum;
 
1317
   XmString *ehnames;
 
1318
   String ehstr;
 
1319
   lList *alp = NULL;
 
1320
 
 
1321
   DENTER(GUI_LAYER, "qmonExecHostChange");
 
1322
 
 
1323
   qmonMirrorMultiAnswer(EXECHOST_T | USERSET_T | PROJECT_T | CENTRY_T,
 
1324
                           &alp);
 
1325
   if (alp) {
 
1326
      qmonMessageBox(w, alp, 0);
 
1327
      lFreeList(&alp);
 
1328
      DEXIT;
 
1329
      return;
 
1330
   }
 
1331
 
 
1332
   if (mode) {
 
1333
      XtVaSetValues( eh_name_w,
 
1334
                     XmNeditable, True,
 
1335
                     NULL);
 
1336
      XmtInputFieldSetString(eh_name_w, "");
 
1337
      /*
 
1338
      ** fill the exec host ask dialog with default values
 
1339
      */
 
1340
      qmonExecHostSetAsk(NULL);
 
1341
      add_mode = mode;
 
1342
 
 
1343
   } else {
 
1344
      /*
 
1345
      ** on opening the dialog fill in the old values
 
1346
      */
 
1347
      XtVaGetValues( exechost_list,
 
1348
                     XmNselectedItems, &ehnames,
 
1349
                     XmNselectedItemCount, &ehnum,
 
1350
                     NULL);
 
1351
      
 
1352
      if (ehnum == 1 && 
 
1353
            XmStringGetLtoR(ehnames[0], XmFONTLIST_DEFAULT_TAG, &ehstr)) {
 
1354
         XmtInputFieldSetString(eh_name_w, ehstr);
 
1355
         XtVaSetValues( eh_name_w,
 
1356
                        XmNeditable, False,
 
1357
                        NULL);
 
1358
         qmonExecHostSetAsk(ehstr);
 
1359
         XtFree((char*)ehstr);
 
1360
         add_mode = 0;
 
1361
      }
 
1362
   }
 
1363
 
 
1364
   XtManageChild(eh_ask_layout);
 
1365
 
 
1366
   DEXIT;
 
1367
}
 
1368
 
 
1369
/*-------------------------------------------------------------------------*/
 
1370
static void qmonExecHostCheckName(Widget w, XtPointer cld, XtPointer cad)
 
1371
{
 
1372
   XmtInputFieldCallbackStruct *cbs = (XmtInputFieldCallbackStruct*) cad;
 
1373
   static char unique[CL_MAXHOSTLEN];
 
1374
   int ret;
 
1375
 
 
1376
   DENTER(GUI_LAYER, "qmonExecHostCheckName");
 
1377
   
 
1378
   if (cbs->input && cbs->input[0] != '\0' && cbs->input[0] != ' ') { 
 
1379
       
 
1380
      DPRINTF(("cbs->input = %s\n", cbs->input));
 
1381
 
 
1382
      strcpy(unique, "");
 
1383
 
 
1384
      /* try to resolve hostname */
 
1385
      ret=sge_resolve_hostname((const char*)cbs->input, unique, EH_name);
 
1386
 
 
1387
      switch ( ret ) {
 
1388
         case CL_RETVAL_GETHOSTNAME_ERROR:
 
1389
            qmonMessageShow(w, True, "Can't resolve host '%s'", cbs->input);
 
1390
            cbs->okay = False;
 
1391
            break;
 
1392
         case CL_RETVAL_OK:
 
1393
            cbs->input = unique;
 
1394
            break;
 
1395
         default:
 
1396
            DPRINTF(("sge_resolve_hostname() failed resolving: %s\n", cl_get_error_text(ret)));
 
1397
            cbs->okay = False;
 
1398
      }
 
1399
   }
 
1400
   
 
1401
   DEXIT;
 
1402
}
 
1403
 
 
1404
 
 
1405
/*-------------------------------------------------------------------------*/
 
1406
static void qmonExecHostCheckScaling(Widget w, XtPointer cld, XtPointer cad)
 
1407
{
 
1408
   XbaeMatrixLeaveCellCallbackStruct *cbs =
 
1409
         (XbaeMatrixLeaveCellCallbackStruct*) cad;
 
1410
   double value;
 
1411
   Pixel bg;
 
1412
 
 
1413
   DENTER(GUI_LAYER, "qmonExecHostCheckScaling");
 
1414
 
 
1415
   if (cbs->column == 1) {
 
1416
      value = atof(cbs->value);
 
1417
      if (value < 0) {
 
1418
         cbs->doit = False;
 
1419
      }
 
1420
      if ( !cbs->doit )
 
1421
         XbaeMatrixSetCellBackground(w, cbs->row, cbs->column, WarningPixel);
 
1422
      else {
 
1423
         if (cbs->row % 2)
 
1424
            XtVaGetValues(w, XmNoddRowBackground, &bg, NULL);
 
1425
         else
 
1426
            XtVaGetValues(w, XmNevenRowBackground, &bg, NULL);
 
1427
         XbaeMatrixSetCellBackground(w, cbs->row, cbs->column, bg);
 
1428
      }
 
1429
   }
 
1430
 
 
1431
   DEXIT;
 
1432
}
 
1433
 
 
1434
 
 
1435
/*-------------------------------------------------------------------------*/
 
1436
static void qmonHostFolderChange(Widget w, XtPointer cld, XtPointer cad)
 
1437
{
 
1438
   XmTabCallbackStruct *cbs = (XmTabCallbackStruct *) cad;
 
1439
 
 
1440
   DENTER(GUI_LAYER, "qmonHostFolderChange");
 
1441
   
 
1442
   DPRINTF(("%s\n", XtName(cbs->tab_child)));
 
1443
 
 
1444
   if (!strcmp(XtName(cbs->tab_child), "adminhost_layout"))
 
1445
      dialog_mode = SGE_ADMINHOST_LIST;
 
1446
 
 
1447
   if (!strcmp(XtName(cbs->tab_child), "submithost_layout"))
 
1448
      dialog_mode = SGE_SUBMITHOST_LIST;
 
1449
 
 
1450
   if (!strcmp(XtName(cbs->tab_child), "hostgroup_layout"))
 
1451
      dialog_mode = SGE_HGROUP_LIST;
 
1452
 
 
1453
   if (!strcmp(XtName(cbs->tab_child), "exechost_layout"))
 
1454
      dialog_mode = SGE_EXECHOST_LIST;
 
1455
 
 
1456
   
 
1457
   updateHostListCB(w, NULL, NULL);
 
1458
 
 
1459
   XtSetSensitive(host_modify, (dialog_mode==SGE_EXECHOST_LIST ||
 
1460
                   dialog_mode==SGE_HGROUP_LIST) ? True:False);
 
1461
   XtSetSensitive(host_shutdown, (dialog_mode==SGE_EXECHOST_LIST) ? True:False);
 
1462
      
 
1463
   DEXIT;
 
1464
}
 
1465
 
 
1466
 
 
1467
/*-------------------------------------------------------------------------*/
 
1468
/* A C C E S S L I S T     P A G E                                         */
 
1469
/*-------------------------------------------------------------------------*/
 
1470
static void qmonExecHostAccessToggle(Widget w, XtPointer cld, XtPointer cad)
 
1471
{
 
1472
   XmtChooserCallbackStruct *cbs = (XmtChooserCallbackStruct*) cad;
 
1473
   
 
1474
   DENTER(GUI_LAYER, "qmonExecHostAccessToggle");
 
1475
 
 
1476
   if (cbs->state) {
 
1477
      XtSetSensitive(access_allow, False);
 
1478
      XtSetSensitive(access_deny, True);
 
1479
   }
 
1480
   else {
 
1481
      XtSetSensitive(access_allow, True);
 
1482
      XtSetSensitive(access_deny, False);
 
1483
   }
 
1484
  
 
1485
   DEXIT;
 
1486
}
 
1487
 
 
1488
/*-------------------------------------------------------------------------*/
 
1489
static void qmonExecHostAccessAdd(Widget w, XtPointer cld, XtPointer cad)
 
1490
{
 
1491
   XmString *selectedItems;
 
1492
   Cardinal selectedItemCount, i;
 
1493
   Widget list;
 
1494
   int state;
 
1495
   String text;
 
1496
   
 
1497
   DENTER(GUI_LAYER, "qmonExecHostAccessAdd");
 
1498
 
 
1499
   XtVaGetValues( access_list,
 
1500
                  XmNselectedItems, &selectedItems,
 
1501
                  XmNselectedItemCount, &selectedItemCount,
 
1502
                  NULL);
 
1503
 
 
1504
   if (selectedItemCount) {
 
1505
/*       XmtLayoutDisableLayout(qc_dialog); */
 
1506
      state = XmtChooserGetState(access_toggle);
 
1507
 
 
1508
      if (state)
 
1509
         list = access_deny;
 
1510
      else
 
1511
         list = access_allow;
 
1512
         
 
1513
      for (i=0; i<selectedItemCount; i++) {
 
1514
         if (!XmStringGetLtoR(selectedItems[i], XmFONTLIST_DEFAULT_TAG, &text))
 
1515
            continue;
 
1516
         XmListAddItemUniqueSorted(list, text);
 
1517
         XtFree(text); 
 
1518
      }
 
1519
/*       XmtLayoutEnableLayout(qc_dialog); */
 
1520
   }
 
1521
 
 
1522
   DEXIT;
 
1523
}
 
1524
 
 
1525
/*-------------------------------------------------------------------------*/
 
1526
static void qmonExecHostAccessRemove(Widget w, XtPointer cld, XtPointer cad)
 
1527
{
 
1528
   XmString *selectedItems;
 
1529
   Cardinal selectedItemCount;
 
1530
   int state;
 
1531
   Widget list;
 
1532
   
 
1533
   DENTER(GUI_LAYER, "qmonExecHostAccessRemove");
 
1534
 
 
1535
   state = XmtChooserGetState(access_toggle);
 
1536
 
 
1537
   if (state)
 
1538
      list = access_deny;
 
1539
   else
 
1540
      list = access_allow;
 
1541
         
 
1542
   XtVaGetValues( list,
 
1543
                  XmNselectedItems, &selectedItems,
 
1544
                  XmNselectedItemCount, &selectedItemCount,
 
1545
                  NULL);
 
1546
 
 
1547
   if (selectedItemCount)
 
1548
      XmListDeleteItems(list, selectedItems, selectedItemCount); 
 
1549
 
 
1550
   DEXIT;
 
1551
}
 
1552
 
 
1553
/*-------------------------------------------------------------------------*/
 
1554
/* R E P O R T I N G  V A R I A B L E S                                    */
 
1555
/*-------------------------------------------------------------------------*/
 
1556
static void qmonExecHostReportVarAdd(Widget w, XtPointer cld, XtPointer cad) 
 
1557
{
 
1558
   XmString *selectedItems;
 
1559
   Cardinal selectedItemCount, i;
 
1560
   String text;
 
1561
   
 
1562
   DENTER(GUI_LAYER, "qmonExecHostReportVarAdd");
 
1563
 
 
1564
   XtVaGetValues( reporting_variables_list,
 
1565
                  XmNselectedItems, &selectedItems,
 
1566
                  XmNselectedItemCount, &selectedItemCount,
 
1567
                  NULL);
 
1568
 
 
1569
   if (selectedItemCount) {
 
1570
      for (i=0; i<selectedItemCount; i++) {
 
1571
         if (!XmStringGetLtoR(selectedItems[i], XmFONTLIST_DEFAULT_TAG, &text))
 
1572
            continue;
 
1573
         XmListAddItemUniqueSorted(reporting_variables_chosen, text);
 
1574
         XtFree(text); 
 
1575
      }
 
1576
   }
 
1577
 
 
1578
   DEXIT;
 
1579
}
 
1580
 
 
1581
/*-------------------------------------------------------------------------*/
 
1582
static void qmonExecHostReportVarRemove(Widget w, XtPointer cld, XtPointer cad) 
 
1583
{
 
1584
   XmString *selectedItems;
 
1585
   Cardinal selectedItemCount;
 
1586
   
 
1587
   DENTER(GUI_LAYER, "qmonExecHostReportVarRemove");
 
1588
 
 
1589
   XtVaGetValues( reporting_variables_chosen,
 
1590
                  XmNselectedItems, &selectedItems,
 
1591
                  XmNselectedItemCount, &selectedItemCount,
 
1592
                  NULL);
 
1593
 
 
1594
   if (selectedItemCount)
 
1595
      XmListDeleteItems(reporting_variables_chosen, selectedItems, selectedItemCount); 
 
1596
 
 
1597
   DEXIT;
 
1598
}
 
1599
 
 
1600
/*-------------------------------------------------------------------------*/
 
1601
/* P R O J E C T     P A G E                                               */
 
1602
/*-------------------------------------------------------------------------*/
 
1603
static void qmonExecHostProjectToggle(Widget w, XtPointer cld, XtPointer cad)
 
1604
{
 
1605
   XmtChooserCallbackStruct *cbs = (XmtChooserCallbackStruct*) cad;
 
1606
   
 
1607
   DENTER(GUI_LAYER, "qmonExecHostProjectToggle");
 
1608
 
 
1609
   if (cbs->state) {
 
1610
      XtSetSensitive(project_allow, False);
 
1611
      XtSetSensitive(project_deny, True);
 
1612
   }
 
1613
   else {
 
1614
      XtSetSensitive(project_allow, True);
 
1615
      XtSetSensitive(project_deny, False);
 
1616
   }
 
1617
  
 
1618
   DEXIT;
 
1619
}
 
1620
 
 
1621
/*-------------------------------------------------------------------------*/
 
1622
static void qmonExecHostProjectAdd(Widget w, XtPointer cld, XtPointer cad)
 
1623
{
 
1624
   XmString *selectedItems;
 
1625
   Cardinal selectedItemCount, i;
 
1626
   Widget list;
 
1627
   int state;
 
1628
   String text;
 
1629
   
 
1630
   DENTER(GUI_LAYER, "qmonExecHostProjectAdd");
 
1631
 
 
1632
   XtVaGetValues( project_list,
 
1633
                  XmNselectedItems, &selectedItems,
 
1634
                  XmNselectedItemCount, &selectedItemCount,
 
1635
                  NULL);
 
1636
 
 
1637
   if (selectedItemCount) {
 
1638
/*       XmtLayoutDisableLayout(qc_dialog); */
 
1639
      state = XmtChooserGetState(project_toggle);
 
1640
 
 
1641
      if (state)
 
1642
         list = project_deny;
 
1643
      else
 
1644
         list = project_allow;
 
1645
         
 
1646
      for (i=0; i<selectedItemCount; i++) {
 
1647
         if (!XmStringGetLtoR(selectedItems[i], XmFONTLIST_DEFAULT_TAG, &text))
 
1648
            continue;
 
1649
         XmListAddItemUniqueSorted(list, text);
 
1650
         XtFree(text); 
 
1651
      }
 
1652
/*       XmtLayoutEnableLayout(qc_dialog); */
 
1653
   }
 
1654
 
 
1655
   DEXIT;
 
1656
}
 
1657
 
 
1658
/*-------------------------------------------------------------------------*/
 
1659
static void qmonExecHostProjectRemove(Widget w, XtPointer cld, XtPointer cad)
 
1660
{
 
1661
   XmString *selectedItems;
 
1662
   Cardinal selectedItemCount;
 
1663
   int state;
 
1664
   Widget list;
 
1665
   
 
1666
   DENTER(GUI_LAYER, "qmonExecHostProjectRemove");
 
1667
 
 
1668
   state = XmtChooserGetState(project_toggle);
 
1669
 
 
1670
   if (state)
 
1671
      list = project_deny;
 
1672
   else
 
1673
      list = project_allow;
 
1674
         
 
1675
   XtVaGetValues( list,
 
1676
                  XmNselectedItems, &selectedItems,
 
1677
                  XmNselectedItemCount, &selectedItemCount,
 
1678
                  NULL);
 
1679
 
 
1680
   if (selectedItemCount)
 
1681
      XmListDeleteItems(list, selectedItems, selectedItemCount); 
 
1682
 
 
1683
   DEXIT;
 
1684
}
 
1685
 
 
1686
/*-------------------------------------------------------------------------*/
 
1687
static Widget qmonCreateHostgroupAsk(
 
1688
Widget parent 
 
1689
) {
 
1690
   Widget hg_ok, hg_cancel, hg_ask_layout, hg_add, hg_add_hg,
 
1691
          hg_del_member;
 
1692
 
 
1693
   DENTER(GUI_LAYER, "qmonCreateHostgroupAsk");
 
1694
   
 
1695
   hg_ask_layout = XmtBuildQueryDialog(parent, "hg_ask_shell",
 
1696
                           NULL, 0,
 
1697
                           "hg_ok", &hg_ok,
 
1698
                           "hg_cancel", &hg_cancel,
 
1699
                           "hg_name", &hg_name_w,
 
1700
                           "hg_memberlist", &hg_memberlist_w,
 
1701
                           "hg_hglist", &hg_hglist_w,
 
1702
                           "hg_member", &hg_member_w,
 
1703
                           "hg_add_hg", &hg_add_hg,
 
1704
                           "hg_add", &hg_add,
 
1705
                           "hg_del_member", &hg_del_member,
 
1706
                           NULL);
 
1707
 
 
1708
   XtAddCallback(hg_ok, XmNactivateCallback, 
 
1709
                     qmonHostgroupOk, NULL);
 
1710
   XtAddCallback(hg_cancel, XmNactivateCallback, 
 
1711
                     qmonHostgroupCancel, NULL);
 
1712
   XtAddCallback(hg_member_w, XmtNverifyCallback,
 
1713
                      qmonHostgroupCheckName, NULL);
 
1714
   XtAddCallback(hg_member_w, XmtNinputCallback, 
 
1715
                      qmonHostgroupAddHost, NULL);
 
1716
   XtAddCallback(hg_add, XmNactivateCallback, 
 
1717
                     qmonHostgroupAddHost, NULL);
 
1718
   XtAddCallback(hg_add_hg, XmNactivateCallback, 
 
1719
                     qmonHostgroupAddHostgroups, NULL);
 
1720
   XtAddCallback(hg_del_member, XmNactivateCallback, 
 
1721
                     DeleteItems, (XtPointer) hg_memberlist_w);
 
1722
 
 
1723
   XtAddEventHandler(XtParent(hg_ask_layout), StructureNotifyMask, False, 
 
1724
                        SetMinShellSize, NULL);
 
1725
 
 
1726
   DEXIT;
 
1727
   return hg_ask_layout;
 
1728
}
 
1729
 
 
1730
/*-------------------------------------------------------------------------*/
 
1731
static void qmonHostgroupChange(Widget w, XtPointer cld, XtPointer cad)
 
1732
{
 
1733
   long mode = (long) cld;
 
1734
   Cardinal hgnum;
 
1735
   XmString *hgnames;
 
1736
   String hgstr;
 
1737
   lList *alp = NULL;
 
1738
 
 
1739
   DENTER(GUI_LAYER, "qmonHostgroupChange");
 
1740
 
 
1741
   qmonMirrorMultiAnswer(HGROUP_T, &alp);
 
1742
   if (alp) {
 
1743
      qmonMessageBox(w, alp, 0);
 
1744
      lFreeList(&alp);
 
1745
      DEXIT;
 
1746
      return;
 
1747
   }
 
1748
 
 
1749
   if (mode) {
 
1750
      XtVaSetValues( hg_name_w,
 
1751
                     XmNeditable, True,
 
1752
                     NULL);
 
1753
      XmtInputFieldSetString(hg_name_w, "");
 
1754
      /*
 
1755
      ** fill the hostgroup ask dialog with default values
 
1756
      */
 
1757
      qmonHostgroupSetAsk(NULL);
 
1758
      add_mode = mode;
 
1759
 
 
1760
   } else {
 
1761
      /*
 
1762
      ** on opening the dialog fill in the old values
 
1763
      */
 
1764
      XtVaGetValues( hostgroup_list,
 
1765
                     XmNselectedItems, &hgnames,
 
1766
                     XmNselectedItemCount, &hgnum,
 
1767
                     NULL);
 
1768
      
 
1769
      if (hgnum == 1 && 
 
1770
            XmStringGetLtoR(hgnames[0], XmFONTLIST_DEFAULT_TAG, &hgstr)) {
 
1771
         XmtInputFieldSetString(hg_name_w, hgstr);
 
1772
         XtVaSetValues( hg_name_w,
 
1773
                        XmNeditable, False,
 
1774
                        NULL);
 
1775
         qmonHostgroupSetAsk(hgstr);
 
1776
         XtFree((char*)hgstr);
 
1777
         add_mode = 0;
 
1778
      }
 
1779
   }
 
1780
 
 
1781
   XtManageChild(hg_ask_layout);
 
1782
 
 
1783
   DEXIT;
 
1784
}
 
1785
 
 
1786
/*-------------------------------------------------------------------------*/
 
1787
static void qmonHostgroupOk(Widget w, XtPointer cld, XtPointer cad)
 
1788
{
 
1789
   lList *alp = NULL;
 
1790
   StringConst hgname = NULL;
 
1791
   lListElem *hg_ep = NULL;
 
1792
   lList *href_list = NULL;
 
1793
 
 
1794
   DENTER(GUI_LAYER, "qmonHostgroupOk");
 
1795
 
 
1796
   /*
 
1797
   ** get the list with one new host
 
1798
   */
 
1799
   hgname = XmtInputFieldGetString(hg_name_w);
 
1800
   if (!hgname || hgname[0] == '\0') {
 
1801
      qmonMessageShow(w, True, "@{Empty hostgroup name !}");
 
1802
      DEXIT;
 
1803
      return;
 
1804
   }
 
1805
 
 
1806
   href_list = XmStringToCull(hg_memberlist_w, HR_Type, HR_name, ALL_ITEMS);
 
1807
   hg_ep = hgroup_create(&alp, hgname, href_list, true);
 
1808
 
 
1809
   if (add_mode) {
 
1810
      hgroup_add_del_mod_via_gdi(ctx, hg_ep, &alp, SGE_GDI_ADD);
 
1811
   } else {
 
1812
      hgroup_add_del_mod_via_gdi(ctx, hg_ep, &alp, SGE_GDI_MOD);
 
1813
   }   
 
1814
 
 
1815
   if (lFirst(alp) && lGetUlong(lFirst(alp), AN_status) != STATUS_OK) {
 
1816
      qmonMessageBox(w, alp, 0);
 
1817
      lFreeList(&alp);
 
1818
   } else {
 
1819
      XtUnmanageChild(hg_ask_layout);
 
1820
      updateHostListCB(w, NULL, NULL);
 
1821
   }
 
1822
 
 
1823
   DEXIT;
 
1824
}
 
1825
 
 
1826
/*-------------------------------------------------------------------------*/
 
1827
static void qmonHostgroupCancel(Widget w, XtPointer cld, XtPointer cad)
 
1828
{
 
1829
   DENTER(GUI_LAYER, "qmonHostgroupCancel");
 
1830
 
 
1831
   XtUnmanageChild(hg_ask_layout);
 
1832
 
 
1833
   DEXIT;
 
1834
}
 
1835
 
 
1836
/*-------------------------------------------------------------------------*/
 
1837
static void qmonHostgroupCheckName(Widget w, XtPointer cld, XtPointer cad)
 
1838
{
 
1839
   XmtInputFieldCallbackStruct *cbs = (XmtInputFieldCallbackStruct*) cad;
 
1840
   static char unique[CL_MAXHOSTLEN];
 
1841
   int ret;
 
1842
 
 
1843
   DENTER(GUI_LAYER, "qmonHostgroupCheckName");
 
1844
   
 
1845
   if (cbs->input && cbs->input[0] != '\0' && cbs->input[0] != ' ') { 
 
1846
       
 
1847
      DPRINTF(("cbs->input = %s\n", cbs->input));
 
1848
 
 
1849
      strcpy(unique, "");
 
1850
 
 
1851
      /* try to resolve hostname */
 
1852
      ret=sge_resolve_hostname((const char*)cbs->input, unique, EH_name);
 
1853
 
 
1854
      switch ( ret ) {
 
1855
         case CL_RETVAL_GETHOSTNAME_ERROR:
 
1856
            qmonMessageShow(w, True, "Can't resolve host '%s'", cbs->input);
 
1857
            cbs->okay = False;
 
1858
            break;
 
1859
         case CL_RETVAL_OK:
 
1860
            cbs->input = unique;
 
1861
            break;
 
1862
         default:
 
1863
            DPRINTF(("sge_resolve_hostname() failed resolving: %s\n", cl_get_error_text(ret)));
 
1864
            cbs->okay = False;
 
1865
      }
 
1866
   }
 
1867
   
 
1868
   DEXIT;
 
1869
}
 
1870
 
 
1871
/*-------------------------------------------------------------------------*/
 
1872
static void qmonHostgroupSetAsk(
 
1873
StringConst name 
 
1874
) {
 
1875
   lListElem *hgp = NULL;
 
1876
   lList *hgl = NULL;
 
1877
   
 
1878
   DENTER(GUI_LAYER, "qmonHostgroupSetAsk");
 
1879
 
 
1880
   hgl = qmonMirrorList(SGE_HGROUP_LIST);
 
1881
 
 
1882
   if (name) {
 
1883
      /*
 
1884
      ** get the selected hostgroup element
 
1885
      */
 
1886
      hgp = hgroup_list_locate(hgl, name);
 
1887
      if (hgp) {
 
1888
         /* set name field */
 
1889
         XmtInputFieldSetString(hg_name_w, name);
 
1890
         /* set members */
 
1891
         UpdateXmListFromCull(hg_memberlist_w, XmFONTLIST_DEFAULT_TAG, 
 
1892
                              lGetList(hgp, HGRP_host_list), HR_name);
 
1893
      }   
 
1894
   }
 
1895
   else {
 
1896
      UpdateXmListFromCull(hg_memberlist_w, XmFONTLIST_DEFAULT_TAG, 
 
1897
                              NULL, HR_name);
 
1898
      XmtInputFieldSetString(hg_name_w, "");
 
1899
   }   
 
1900
 
 
1901
   /*
 
1902
   ** FIXME ANDRE
 
1903
   ** hostgroups that would create a cycle should be suppressed
 
1904
   */
 
1905
   UpdateXmListFromCull(hg_hglist_w, XmFONTLIST_DEFAULT_TAG, 
 
1906
                              hgl, HGRP_name);
 
1907
 
 
1908
   DEXIT;
 
1909
}
 
1910
 
 
1911
/*-------------------------------------------------------------------------*/
 
1912
static void qmonHostgroupSelect(Widget w, XtPointer cld, XtPointer cad)
 
1913
{
 
1914
   XmListCallbackStruct *cbs = (XmListCallbackStruct*) cad;
 
1915
   char *hgname;
 
1916
   lListElem *hgp;
 
1917
   
 
1918
   DENTER(GUI_LAYER, "qmonHostgroupSelect");
 
1919
 
 
1920
   if (! XmStringGetLtoR(cbs->item, XmFONTLIST_DEFAULT_TAG, &hgname)) {
 
1921
      fprintf(stderr, "XmStringGetLtoR failed\n");
 
1922
      DEXIT;
 
1923
      return;
 
1924
   }
 
1925
 
 
1926
   hgp = hgroup_list_locate(qmonMirrorList(SGE_HGROUP_LIST), hgname);
 
1927
   XtFree((char*) hgname);
 
1928
 
 
1929
   if (hgp) {
 
1930
      UpdateXmListFromCull(hostgroup_memberlist, XmFONTLIST_DEFAULT_TAG, 
 
1931
                           lGetList(hgp, HGRP_host_list), HR_name);
 
1932
   }
 
1933
   DEXIT;
 
1934
}
 
1935
 
 
1936
/*-------------------------------------------------------------------------*/
 
1937
static void qmonHostgroupAddHost(Widget w, XtPointer cld, XtPointer cad)
 
1938
{
 
1939
   char *host;
 
1940
   
 
1941
   DENTER(GUI_LAYER, "qmonHostgroupAddHost");
 
1942
 
 
1943
   host = XmtInputFieldGetString(hg_member_w);
 
1944
 
 
1945
   if (host && host[0] != '\0') {
 
1946
      XmListAddItemUniqueSorted(hg_memberlist_w, host);
 
1947
   }
 
1948
 
 
1949
   XmtInputFieldSetString(hg_member_w, "");
 
1950
 
 
1951
   DEXIT;
 
1952
}
 
1953
 
 
1954
/*-------------------------------------------------------------------------*/
 
1955
static void qmonHostgroupAddHostgroups(Widget w, XtPointer cld, XtPointer cad)
 
1956
{
 
1957
   int i;
 
1958
   XmString *items = NULL;
 
1959
   Cardinal itemCount = 0;
 
1960
 
 
1961
   DENTER(GUI_LAYER, "qmonHostgroupAddHostgroups");
 
1962
 
 
1963
   XtVaGetValues( hg_hglist_w,
 
1964
               XmNselectedItems, &items,
 
1965
               XmNselectedItemCount, &itemCount,
 
1966
               NULL);
 
1967
   for (i=0; i<itemCount; i++) {
 
1968
      XmListAddXmStringUniqueSorted(hg_memberlist_w, items[i]); 
 
1969
   }
 
1970
 
 
1971
   DEXIT;
 
1972
}