← Back to branch summary

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

« back to all changes in this revision

Viewing changes to source/clients/qstat/qstat_xml.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/qstat/qstat_xml.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
 *  Sun Microsystems Inc., March, 2001
 
8
 * 
 
9
 * 
 
10
 *  Sun Industry Standards Source License Version 1.2
 
11
 *  =================================================
 
12
 *  The contents of this file are subject to the Sun Industry Standards
 
13
 *  Source License Version 1.2 (the "License"); You may not use this file
 
14
 *  except in compliance with the License. You may obtain a copy of the
 
15
 *  License at http://gridengine.sunsource.net/Gridengine_SISSL_license.html
 
16
 * 
 
17
 *  Software provided under this License is provided on an "AS IS" basis,
 
18
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 
19
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 
20
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 
21
 *  See the License for the specific provisions governing your rights and
 
22
 *  obligations concerning the Software.
 
23
 * 
 
24
 *   The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 
25
 * 
 
26
 *   Copyright: 2001 by Sun Microsystems, Inc.
 
27
 * 
 
28
 *   All Rights Reserved.
 
29
 * 
 
30
 ************************************************************************/
 
31
/*___INFO__MARK_END__*/
 
32
#include <stdio.h>
 
33
#include <stdlib.h>
 
34
#include <string.h>
 
35
#include <fnmatch.h>
 
36
#include <ctype.h>
 
37
 
 
38
 
 
39
#include "sgermon.h"
 
40
#include "symbols.h"
 
41
#include "sge.h"
 
42
#include "gdi/sge_gdi.h"
 
43
#include "sge_time.h"
 
44
#include "sge_log.h"
 
45
#include "sge_stdlib.h"
 
46
#include "sge_all_listsL.h"
 
47
#include "commlib.h"
 
48
#include "sge_host.h"
 
49
#include "sig_handlers.h"
 
50
#include "sge_sched.h"
 
51
#include "cull_sort.h"
 
52
#include "usage.h"
 
53
#include "sge_dstring.h"
 
54
#include "sge_feature.h"
 
55
#include "parse.h"
 
56
#include "sge_prog.h"
 
57
#include "sge_parse_num_par.h"
 
58
#include "sge_string.h"
 
59
#include "show_job.h"
 
60
#include "qstat_printing.h"
 
61
#include "sge_range.h"
 
62
#include "sge_schedd_text.h"
 
63
#include "qm_name.h"
 
64
#include "load_correction.h"
 
65
#include "msg_common.h"
 
66
#include "msg_clients_common.h"
 
67
#include "msg_qstat.h"
 
68
#include "sge_conf.h" 
 
69
#include "sgeee.h" 
 
70
#include "sge_support.h"
 
71
#include "sge_unistd.h"
 
72
#include "sge_answer.h"
 
73
#include "sge_pe.h"
 
74
#include "sge_ckpt.h"
 
75
#include "sge_qinstance.h"
 
76
#include "sge_qinstance_state.h"
 
77
#include "sge_qinstance_type.h"
 
78
#include "sge_centry.h"
 
79
#include "sge_schedd_conf.h"
 
80
#include "sge_cqueue.h"
 
81
#include "sge_qref.h"
 
82
#include "sge_ja_task.h"
 
83
 
 
84
#include "sge_job.h"
 
85
#include "sge_urgency.h"
 
86
#include "sge_ulong.h"
 
87
 
 
88
#include "sge_mt_init.h"
 
89
#include "sge_qstat.h"
 
90
 
 
91
/* ----------------------- qselect xml handler ------------------------------ */
 
92
 
 
93
static int qselect_xml_report_queue(qselect_handler_t *thiz, const char* qname, lList** alpp);
 
94
static int qselect_xml_finished(qselect_handler_t *thiz, lList** alpp);
 
95
static int qselect_xml_destroy(qselect_handler_t *thiz, lList** alpp);
 
96
static int qselect_xml_started(qselect_handler_t *thiz, lList** alpp);
 
97
 
 
98
int qselect_xml_init(qselect_handler_t* handler, lList **alpp) {
 
99
   
 
100
   memset(handler, 0, sizeof(qselect_handler_t));
 
101
   
 
102
   handler->ctx = sge_malloc(sizeof(dstring));
 
103
   if (handler->ctx == NULL ) {
 
104
      answer_list_add(alpp, "malloc of dstring buffer failed",
 
105
                            STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
106
      return -1;
 
107
   }
 
108
   memset(handler->ctx, 0, sizeof(dstring));
 
109
 
 
110
   handler->report_started = qselect_xml_started;
 
111
   handler->report_finished = qselect_xml_finished;
 
112
   handler->destroy = qselect_xml_destroy;
 
113
   handler->report_queue = qselect_xml_report_queue;
 
114
   return 0;
 
115
}
 
116
 
 
117
static int qselect_xml_destroy(qselect_handler_t *thiz, lList** alpp) {
 
118
   if (thiz != NULL ) {
 
119
      sge_dstring_free((dstring*)thiz->ctx);
 
120
      FREE(thiz->ctx);
 
121
   }
 
122
   return 0;
 
123
}
 
124
 
 
125
static int qselect_xml_started(qselect_handler_t *thiz, lList** alpp) {
 
126
   printf("<qselect>\n");
 
127
   return 0;
 
128
}
 
129
 
 
130
static int qselect_xml_finished(qselect_handler_t *thiz, lList** alpp) {
 
131
   printf("</qselect>\n");
 
132
   return 0;
 
133
}
 
134
 
 
135
static int qselect_xml_report_queue(qselect_handler_t *thiz, const char* qname, lList** alpp) {
 
136
   escape_string(qname, (dstring*)thiz->ctx);
 
137
   printf("   <queue>%s</queue>\n", sge_dstring_get_string((dstring*)thiz->ctx));
 
138
   sge_dstring_clear((dstring*)thiz->ctx);
 
139
   return 0;
 
140
}
 
141
                           
 
142
/* --------------- Cluster Queue Summary To XML Handler -------------------*/
 
143
static int cqueue_summary_xml_report_finished(cqueue_summary_handler_t *handler, lList **alpp);
 
144
static int cqueue_summary_xml_report_cqueue(cqueue_summary_handler_t *handler, const char* cqname, cqueue_summary_t *summary, lList **alpp);
 
145
 
 
146
int cqueue_summary_xml_handler_init(cqueue_summary_handler_t *handler) {
 
147
   memset(handler, 0, sizeof(cqueue_summary_handler_t));
 
148
   
 
149
   handler->report_finished = cqueue_summary_xml_report_finished;
 
150
   handler->report_cqueue = cqueue_summary_xml_report_cqueue; 
 
151
   return 0;
 
152
}
 
153
 
 
154
 
 
155
static int cqueue_summary_xml_report_finished(cqueue_summary_handler_t *handler, lList **alpp) {
 
156
   if (handler->ctx != NULL) {
 
157
      lListElem *xml_elem = NULL;
 
158
    
 
159
      xml_elem = xml_getHead("job_info", (lList*)handler->ctx, NULL);
 
160
      handler->ctx = NULL;
 
161
      lWriteElemXMLTo(xml_elem, stdout);  
 
162
      lFreeElem(&xml_elem);
 
163
   }
 
164
   return 0;
 
165
}
 
166
 
 
167
static int cqueue_summary_xml_report_cqueue(cqueue_summary_handler_t *handler, const char* cqname, cqueue_summary_t *summary, lList **alpp) {
 
168
   
 
169
   lListElem *elem = NULL;
 
170
   lList *attributeList = NULL;
 
171
   qstat_env_t *qstat_env = handler->qstat_env;
 
172
   bool show_states = (qstat_env->full_listing & QSTAT_DISPLAY_EXTENDED) ? true : false;
 
173
   
 
174
   elem = lCreateElem(XMLE_Type);
 
175
   attributeList = lCreateList("attributes", XMLE_Type);
 
176
   lSetList(elem, XMLE_List, attributeList);
 
177
 
 
178
   xml_append_Attr_S(attributeList, "name", cqname);
 
179
   if (summary->is_load_available) {
 
180
      xml_append_Attr_D(attributeList, "load", summary->load);
 
181
   }
 
182
   xml_append_Attr_I(attributeList, "used", (int)summary->used);
 
183
   xml_append_Attr_I(attributeList, "resv", (int)summary->resv);
 
184
   xml_append_Attr_I(attributeList, "available", (int)summary->available);
 
185
   xml_append_Attr_I(attributeList, "total", (int)summary->total);
 
186
   xml_append_Attr_I(attributeList, "temp_disabled", (int)summary->temp_disabled);
 
187
   xml_append_Attr_I(attributeList, "manual_intervention", (int)summary->manual_intervention);
 
188
   if (show_states) {
 
189
      xml_append_Attr_I(attributeList, "suspend_manual", (int)summary->suspend_manual);
 
190
      xml_append_Attr_I(attributeList, "suspend_threshold", (int)summary->suspend_threshold);
 
191
      xml_append_Attr_I(attributeList, "suspend_on_subordinate", (int)summary->suspend_on_subordinate);
 
192
      xml_append_Attr_I(attributeList, "suspend_calendar", (int)summary->suspend_calendar);
 
193
      xml_append_Attr_I(attributeList, "unknown", (int)summary->unknown);
 
194
      xml_append_Attr_I(attributeList, "load_alarm", (int)summary->load_alarm);
 
195
      xml_append_Attr_I(attributeList, "disabled_manual", (int)summary->disabled_manual);
 
196
      xml_append_Attr_I(attributeList, "disabled_calendar", (int)summary->disabled_calendar);
 
197
      xml_append_Attr_I(attributeList, "ambiguous", (int)summary->ambiguous);
 
198
      xml_append_Attr_I(attributeList, "orphaned", (int)summary->orphaned);
 
199
      xml_append_Attr_I(attributeList, "error", (int)summary->error);
 
200
   }
 
201
   if (elem) {
 
202
      if (handler->ctx == NULL){
 
203
         handler->ctx = lCreateList("cluster_queue_summary", XMLE_Type);
 
204
      }
 
205
      lAppendElem((lList*)handler->ctx, elem); 
 
206
   } 
 
207
   return 0;
 
208
}
 
209
 
 
210
                           
 
211
static int qstat_xml_queue_started(qstat_handler_t* handler, const char* qname, lList **alpp);
 
212
static int qstat_xml_queue_summary(qstat_handler_t* handler, const char* qname, queue_summary_t *summary, lList **alpp);
 
213
static int qstat_xml_queue_finished(qstat_handler_t* handler, const char* qname, lList **alpp);
 
214
static int qstat_xml_queue_load_alarm(qstat_handler_t* handler, const char* qname, const char* reason, lList **alpp);
 
215
static int qstat_xml_queue_suspend_alarm(qstat_handler_t* handler, const char* qname, const char* reason, lList **alpp);
 
216
static int qstat_xml_queue_message(qstat_handler_t* handler, const char* qname, const char *message, lList **alpp);
 
217
static int qstat_xml_queue_resource(qstat_handler_t* handler, const char* dom, const char* name, const char* value, lList **alpp);
 
218
 
 
219
static int qstat_xml_job(job_handler_t* handler, u_long32 jid, job_summary_t *summary, lList **alpp);
 
220
static int qstat_xml_sub_task(job_handler_t* handler, task_summary_t *summary, lList **alpp);
 
221
static int qstat_xml_job_additional_info(job_handler_t* handler, job_additional_info_t name, const char* value, lList **alpp);
 
222
static int qstat_xml_job_requested_pe(job_handler_t *handler, const char* pe_name, const char* pe_range, lList **alpp);
 
223
 
 
224
static int qstat_xml_job_granted_pe(job_handler_t *handler, const char* pe_name, int pe_slots, lList **alpp);
 
225
static int qstat_xml_job_request(job_handler_t* handler, const char* name, const char* value, lList **alpp);
 
226
static int qstat_xml_job_report_hard_resource(job_handler_t *handler, const char* name, const char* value, double uc, lList **alpp);
 
227
static int qstat_xml_job_soft_resource(job_handler_t *handler, const char* name, const char* value, double uc, lList **alpp);
 
228
static int qstat_xml_job_hard_requested_queue(job_handler_t *handler, const char* name, lList **alpp);
 
229
static int qstat_xml_job_soft_requested_queue(job_handler_t *handler, const char* name, lList **alpp);
 
230
static int qstat_xml_job_master_hard_requested_queue(job_handler_t* handler, const char* name, lList **alpp);
 
231
static int qstat_xml_job_predecessor_requested(job_handler_t* handler, const char* name, lList **alpp);
 
232
static int qstat_xml_job_predecessor(job_handler_t* handler, u_long32 jid, lList **alpp);
 
233
static int qstat_xml_job_ad_predecessor_requested(job_handler_t* handler, const char* name, lList **alpp);
 
234
static int qstat_xml_job_ad_predecessor(job_handler_t* handler, u_long32 jid, lList **alpp);
 
235
 
 
236
static int qstat_xml_job_finished(job_handler_t* handler, u_long32 jid, lList **alpp);
 
237
 
 
238
 
 
239
static int qstat_xml_create_job_list(qstat_handler_t *handler, lList **alpp);
 
240
static int qstat_xml_finish_job_list(qstat_handler_t *handler, const char* state, lList* target_list, lList **alpp);
 
241
 
 
242
static int qstat_xml_queue_jobs_started(qstat_handler_t *handler, const char* qname, lList **alpp);
 
243
static int qstat_xml_queue_jobs_finished(qstat_handler_t *handler, const char* qname, lList **alpp);
 
244
 
 
245
static int qstat_xml_pending_jobs_started(qstat_handler_t *handler, lList **alpp);
 
246
static int qstat_xml_pending_jobs_finished(qstat_handler_t *handler, lList **alpp);
 
247
static int qstat_xml_finished_jobs_started(qstat_handler_t *handler, lList **alpp);
 
248
static int qstat_xml_finished_jobs_finished(qstat_handler_t *handler, lList **alpp);
 
249
static int qstat_xml_error_jobs_started(qstat_handler_t *handler, lList **alpp);
 
250
static int qstat_xml_error_jobs_finished(qstat_handler_t *handler, lList **alpp);
 
251
static int qstat_xml_zombie_jobs_started(qstat_handler_t *handler, lList **alpp);
 
252
static int qstat_xml_zombie_jobs_finished(qstat_handler_t *handler, lList **alpp);
 
253
 
 
254
static int qstat_xml_started(qstat_handler_t* handler, lList** alpp);
 
255
static int qstat_xml_finished(qstat_handler_t* handler, lList** alpp);
 
256
 
 
257
static int qstat_xml_dummy_started(job_handler_t* handler, lList** alpp);
 
258
static int qstat_xml_dummy_finished(job_handler_t* handler, lList** alpp);
 
259
 
 
260
typedef struct {
 
261
 
 
262
   lListElem *queue_list_elem;
 
263
   lListElem *queue_elem;
 
264
 
 
265
   lListElem *job_list_elem;
 
266
   lList     *job_list;
 
267
   lListElem *job_elem;
 
268
   
 
269
} qstat_xml_ctx_t;
 
270
 
 
271
 
 
272
int qstat_xml_handler_init(qstat_handler_t* handler, lList **alpp) {
 
273
   int ret = 0;
 
274
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)sge_malloc(sizeof(qstat_xml_ctx_t));
 
275
   
 
276
   DENTER(TOP_LAYER, "qstat_xml_handler_init");
 
277
   
 
278
   if (ctx == NULL) {
 
279
      answer_list_add(alpp, "malloc of qstat_xml_ctx_t failed",
 
280
                            STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
 
281
      ret = -1;
 
282
      goto error;
 
283
   }
 
284
   
 
285
   memset(handler, 0, sizeof(qstat_handler_t));
 
286
   memset(ctx, 0, sizeof(qstat_xml_ctx_t));
 
287
   
 
288
   handler->ctx = ctx;
 
289
   handler->job_handler.ctx = ctx;
 
290
   
 
291
   handler->report_queue_started = qstat_xml_queue_started;
 
292
   handler->report_queue_finished = qstat_xml_queue_finished;
 
293
   handler->report_queue_summary = qstat_xml_queue_summary;
 
294
   handler->report_queue_load_alarm = qstat_xml_queue_load_alarm;
 
295
   handler->report_queue_suspend_alarm = qstat_xml_queue_suspend_alarm;
 
296
   handler->report_queue_message = qstat_xml_queue_message;
 
297
   handler->report_queue_resource = qstat_xml_queue_resource;
 
298
 
 
299
   handler->job_handler.report_job = qstat_xml_job;
 
300
 
 
301
   handler->job_handler.report_sub_tasks_started = qstat_xml_dummy_started;
 
302
   handler->job_handler.report_sub_task = qstat_xml_sub_task;
 
303
   handler->job_handler.report_sub_tasks_finished = qstat_xml_dummy_finished;
 
304
 
 
305
   handler->job_handler.report_additional_info = qstat_xml_job_additional_info;
 
306
 
 
307
   handler->job_handler.report_requested_pe = qstat_xml_job_requested_pe;
 
308
   handler->job_handler.report_granted_pe = qstat_xml_job_granted_pe;
 
309
 
 
310
   handler->job_handler.report_request = qstat_xml_job_request;
 
311
 
 
312
   handler->job_handler.report_hard_resources_started = qstat_xml_dummy_started;
 
313
   handler->job_handler.report_hard_resource = qstat_xml_job_report_hard_resource;
 
314
   handler->job_handler.report_hard_resources_finished = qstat_xml_dummy_finished;
 
315
 
 
316
   handler->job_handler.report_soft_resources_started = qstat_xml_dummy_started;
 
317
   handler->job_handler.report_soft_resource = qstat_xml_job_soft_resource;
 
318
   handler->job_handler.report_soft_resources_finished = qstat_xml_dummy_finished;
 
319
 
 
320
   handler->job_handler.report_hard_requested_queues_started = qstat_xml_dummy_started;
 
321
   handler->job_handler.report_hard_requested_queue = qstat_xml_job_hard_requested_queue;
 
322
   handler->job_handler.report_hard_requested_queues_finished = qstat_xml_dummy_finished;
 
323
 
 
324
   handler->job_handler.report_soft_requested_queues_started = qstat_xml_dummy_started;
 
325
   handler->job_handler.report_soft_requested_queue = qstat_xml_job_soft_requested_queue;
 
326
   handler->job_handler.report_soft_requested_queues_finished = qstat_xml_dummy_finished;
 
327
 
 
328
   handler->job_handler.report_master_hard_requested_queues_started = qstat_xml_dummy_started;
 
329
   handler->job_handler.report_master_hard_requested_queue = qstat_xml_job_master_hard_requested_queue;
 
330
   handler->job_handler.report_master_hard_requested_queues_finished = qstat_xml_dummy_finished;
 
331
 
 
332
   handler->job_handler.report_predecessors_requested_started = qstat_xml_dummy_started;
 
333
   handler->job_handler.report_predecessor_requested = qstat_xml_job_predecessor_requested;
 
334
   handler->job_handler.report_predecessors_requested_finished = qstat_xml_dummy_finished;
 
335
 
 
336
   handler->job_handler.report_predecessors_started = qstat_xml_dummy_started;
 
337
   handler->job_handler.report_predecessor = qstat_xml_job_predecessor;
 
338
   handler->job_handler.report_predecessors_finished = qstat_xml_dummy_finished;
 
339
 
 
340
   handler->job_handler.report_ad_predecessors_requested_started = qstat_xml_dummy_started;
 
341
   handler->job_handler.report_ad_predecessor_requested = qstat_xml_job_ad_predecessor_requested;
 
342
   handler->job_handler.report_ad_predecessors_requested_finished = qstat_xml_dummy_finished;
 
343
 
 
344
   handler->job_handler.report_ad_predecessors_started = qstat_xml_dummy_started;
 
345
   handler->job_handler.report_ad_predecessor = qstat_xml_job_ad_predecessor;
 
346
   handler->job_handler.report_ad_predecessors_finished = qstat_xml_dummy_finished;
 
347
 
 
348
   handler->job_handler.report_job_finished = qstat_xml_job_finished;
 
349
 
 
350
   handler->report_queue_jobs_started = qstat_xml_queue_jobs_started;
 
351
   handler->report_queue_jobs_finished = qstat_xml_queue_jobs_finished;
 
352
   
 
353
   handler->report_pending_jobs_started = qstat_xml_pending_jobs_started;
 
354
   handler->report_pending_jobs_finished = qstat_xml_pending_jobs_finished;
 
355
   
 
356
   handler->report_finished_jobs_started = qstat_xml_finished_jobs_started;
 
357
   handler->report_finished_jobs_finished = qstat_xml_finished_jobs_finished;
 
358
 
 
359
   handler->report_error_jobs_started = qstat_xml_error_jobs_started;
 
360
   handler->report_error_jobs_finished = qstat_xml_error_jobs_finished;
 
361
   
 
362
   handler->report_zombie_jobs_started = qstat_xml_zombie_jobs_started;
 
363
   handler->report_zombie_jobs_finished = qstat_xml_zombie_jobs_finished;
 
364
   
 
365
   handler->report_finished = qstat_xml_finished; 
 
366
   handler->report_started = qstat_xml_started;
 
367
error:
 
368
   DEXIT;
 
369
   return ret;
 
370
}
 
371
 
 
372
static int qstat_xml_started(qstat_handler_t* handler, lList** alpp) {
 
373
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
374
   lListElem *attr_elem = NULL;
 
375
   
 
376
   DENTER(TOP_LAYER, "qstat_xml_started" );
 
377
   
 
378
   ctx->queue_list_elem = lCreateElem(XMLE_Type);
 
379
   attr_elem = lCreateElem(XMLA_Type);
 
380
   lSetString(attr_elem, XMLA_Name, "queue_info");
 
381
   lSetObject(ctx->queue_list_elem, XMLE_Element, attr_elem);
 
382
   lSetBool(ctx->queue_list_elem, XMLE_Print, true);
 
383
   
 
384
   ctx->job_list_elem = lCreateElem(XMLE_Type);
 
385
   attr_elem = lCreateElem(XMLA_Type);
 
386
   lSetString(attr_elem, XMLA_Name, "job_info");
 
387
   lSetObject(ctx->job_list_elem, XMLE_Element, attr_elem);
 
388
   lSetBool(ctx->job_list_elem, XMLE_Print, true);
 
389
   lSetList(ctx->job_list_elem, XMLE_List, lCreateList("job_list", XMLE_Type));
 
390
 
 
391
   DEXIT;
 
392
   return 0;
 
393
}
 
394
 
 
395
static int qstat_xml_finished(qstat_handler_t* handler, lList** alpp) {
 
396
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
397
   lListElem *xml_elem = NULL;
 
398
   lList *XML_out = NULL;
 
399
   DENTER(TOP_LAYER, "qstat_xml_finished");
 
400
 
 
401
   XML_out = lCreateList("job_info", XMLE_Type);
 
402
   
 
403
   lAppendElem(XML_out, ctx->queue_list_elem);
 
404
   ctx->queue_list_elem = NULL;
 
405
   
 
406
   lAppendElem(XML_out, ctx->job_list_elem);
 
407
   ctx->job_list_elem = NULL;
 
408
   
 
409
   xml_elem = xml_getHead("job_info", XML_out, NULL);
 
410
   /*lWriteListTo(XML_out, stdout);*/
 
411
   lWriteElemXMLTo(xml_elem, stdout);
 
412
   lFreeElem(&xml_elem);
 
413
 
 
414
   DEXIT;
 
415
   return 0;
 
416
}
 
417
 
 
418
/*
 
419
** start and finished functions needed for clients/common/sge_qstat.c do work
 
420
*/
 
421
static int qstat_xml_dummy_started(job_handler_t* handler, lList** alpp) {
 
422
   return 0;
 
423
}
 
424
 
 
425
static int qstat_xml_dummy_finished(job_handler_t* handler, lList** alpp) {
 
426
   return 0;
 
427
}
 
428
 
 
429
static int qstat_xml_job(job_handler_t* handler, u_long32 jid, job_summary_t *summary, lList **alpp) {
 
430
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
431
   qstat_env_t *qstat_env = handler->qstat_env;
 
432
   int sge_ext, tsk_ext, sge_urg, sge_pri, sge_time;
 
433
   dstring ds = DSTRING_INIT;
 
434
   lList *attribute_list = NULL;
 
435
   
 
436
   DENTER(TOP_LAYER, "qstat_xml_job");
 
437
 
 
438
   ctx->job_elem = lCreateElem(XMLE_Type);
 
439
   attribute_list = lCreateList("attributes", XMLE_Type);
 
440
   lSetList(ctx->job_elem, XMLE_List, attribute_list);
 
441
   
 
442
   sge_ext = (qstat_env->full_listing & QSTAT_DISPLAY_EXTENDED);
 
443
   tsk_ext = (qstat_env->full_listing & QSTAT_DISPLAY_TASKS);
 
444
   sge_urg = (qstat_env->full_listing & QSTAT_DISPLAY_URGENCY);
 
445
   sge_pri = (qstat_env->full_listing & QSTAT_DISPLAY_PRIORITY);
 
446
   sge_time = !sge_ext;
 
447
   sge_time = sge_time | tsk_ext | sge_urg | sge_pri;
 
448
   
 
449
   xml_append_Attr_I(attribute_list, "JB_job_number", jid); 
 
450
   xml_append_Attr_D(attribute_list, "JAT_prio", summary->nprior);
 
451
   if( sge_ext) {
 
452
      xml_append_Attr_D(attribute_list, "JAT_ntix", summary->ntckts);
 
453
   }
 
454
   
 
455
   if (sge_urg) {
 
456
      xml_append_Attr_D(attribute_list, "JB_nurg", summary->nurg);
 
457
      xml_append_Attr_D8(attribute_list, "JB_urg", summary->urg);
 
458
      xml_append_Attr_D8(attribute_list, "JB_rrcontr", summary->rrcontr);
 
459
      xml_append_Attr_D8(attribute_list, "JB_wtcontr", summary->wtcontr);
 
460
      xml_append_Attr_D8(attribute_list, "JB_dlcontr", summary->dlcontr);
 
461
   } 
 
462
 
 
463
   if (sge_pri) {
 
464
      xml_append_Attr_D(attribute_list, "JB_nppri", summary->nppri);
 
465
      xml_append_Attr_I(attribute_list, "JB_priority", summary->priority);
 
466
   } 
 
467
 
 
468
   xml_append_Attr_S(attribute_list, "JB_name", summary->name);
 
469
   xml_append_Attr_S(attribute_list, "JB_owner", summary->user);
 
470
 
 
471
   if (sge_ext) {
 
472
      xml_append_Attr_S(attribute_list, "JB_project", summary->project);
 
473
      xml_append_Attr_S(attribute_list, "JB_department", summary->department);
 
474
   }
 
475
 
 
476
 
 
477
   xml_append_Attr_S(attribute_list, "state", summary->state);
 
478
 
 
479
   if (sge_time) {
 
480
      if (summary->is_running) {
 
481
         xml_append_Attr_S(attribute_list, "JAT_start_time", sge_ctimeXML(summary->start_time, &ds));
 
482
      }   
 
483
      else {
 
484
         xml_append_Attr_S(attribute_list, "JB_submission_time", sge_ctimeXML(summary->submit_time, &ds));
 
485
      }
 
486
   }
 
487
 
 
488
   /* deadline time */
 
489
   if (sge_urg) {
 
490
      if (summary->deadline) {
 
491
         xml_append_Attr_S(attribute_list, "JB_deadline", sge_ctimeXML(summary->deadline, &ds));
 
492
      }
 
493
   }
 
494
 
 
495
   if (sge_ext) {
 
496
      /* scaled cpu usage */
 
497
      if (summary->has_cpu_usage) {
 
498
         xml_append_Attr_D(attribute_list, "cpu_usage", summary->cpu_usage);
 
499
      } 
 
500
      /* scaled mem usage */
 
501
      if (summary->has_mem_usage) 
 
502
         xml_append_Attr_D(attribute_list, "mem_usage", summary->mem_usage);  
 
503
  
 
504
      /* scaled io usage */
 
505
      if (summary->has_io_usage) 
 
506
         xml_append_Attr_D(attribute_list, "io_usage", summary->io_usage);  
 
507
 
 
508
      if (!summary->is_zombie) {
 
509
         if (sge_ext ||summary->is_queue_assigned) {
 
510
            xml_append_Attr_I(attribute_list, "tickets", (int)summary->tickets);
 
511
            xml_append_Attr_I(attribute_list, "JB_override_tickets", (int)summary->override_tickets);
 
512
            xml_append_Attr_I(attribute_list, "JB_jobshare", (int)summary->share);
 
513
            xml_append_Attr_I(attribute_list, "otickets", (int)summary->otickets);
 
514
            xml_append_Attr_I(attribute_list, "ftickets", (int)summary->ftickets);
 
515
            xml_append_Attr_I(attribute_list, "stickets", (int)summary->stickets);
 
516
            /* RH TODO: asked Stefan want is the difference between JAT_share and JB_jobshare */
 
517
            xml_append_Attr_D(attribute_list, "JAT_share", summary->share);
 
518
         }
 
519
      }
 
520
   }
 
521
 
 
522
   /* if not full listing we need the queue's name in each line */
 
523
   if (!(qstat_env->full_listing & QSTAT_DISPLAY_FULL)) {
 
524
      xml_append_Attr_S(attribute_list, "queue_name", summary->queue);
 
525
   }   
 
526
 
 
527
   if ((qstat_env->group_opt & GROUP_NO_PETASK_GROUPS)) {
 
528
      /* MASTER/SLAVE information needed only to show parallel job distribution */
 
529
      xml_append_Attr_S(attribute_list, "master", summary->master);
 
530
   }
 
531
 
 
532
   xml_append_Attr_I(attribute_list, "slots", (int)summary->slots);
 
533
 
 
534
   if (summary->task_id && summary->is_array) {
 
535
      xml_append_Attr_S(attribute_list, "tasks", summary->task_id);
 
536
   }
 
537
 
 
538
   sge_dstring_free(&ds);   
 
539
   DEXIT;
 
540
   return 0;
 
541
}
 
542
 
 
543
static int qstat_xml_job_finished(job_handler_t* handler, u_long32 jid, lList **alpp) {
 
544
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
545
   
 
546
   DENTER(TOP_LAYER,"qstat_xml_job_finished");
 
547
   
 
548
   lAppendElem(ctx->job_list, ctx->job_elem); 
 
549
   ctx->job_elem = NULL;
 
550
 
 
551
   DEXIT;
 
552
   return 0;
 
553
}
 
554
 
 
555
static int qstat_xml_sub_task(job_handler_t* handler, task_summary_t *summary, lList **alpp) {
 
556
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
557
   lListElem *xml_elem = NULL;
 
558
   lList *attribute_list = NULL;
 
559
   
 
560
   DENTER(TOP_LAYER,"qstat_xml_sub_task");
 
561
   
 
562
   xml_elem = lCreateElem(XMLE_Type);
 
563
   attribute_list = lCreateList("attributes", XMLE_Type);
 
564
   lSetList(xml_elem, XMLE_List, attribute_list);
 
565
 
 
566
   if(summary->task_id) {
 
567
      xml_append_Attr_S(attribute_list, "task-id", summary->task_id);      
 
568
   }
 
569
 
 
570
   xml_append_Attr_S(attribute_list, "state", summary->state);
 
571
 
 
572
   if (summary->has_cpu_usage) {
 
573
      xml_append_Attr_D(attribute_list, "cpu-usage", summary->cpu_usage);
 
574
   }
 
575
 
 
576
   if (summary->has_mem_usage) {
 
577
      xml_append_Attr_D(attribute_list, "mem-usage", summary->mem_usage);  
 
578
   }   
 
579
 
 
580
   if (summary->has_io_usage) {
 
581
      xml_append_Attr_D(attribute_list, "io-usage", summary->io_usage);  
 
582
   }   
 
583
 
 
584
   if (summary->has_exit_status) {
 
585
      xml_append_Attr_I(attribute_list, "stat", summary->exit_status);
 
586
   }   
 
587
   
 
588
   /* add the sub task to the current job element */
 
589
   attribute_list = lGetList(ctx->job_elem, XMLE_Attribute);
 
590
   lAppendElem(attribute_list, xml_elem);
 
591
   
 
592
   DEXIT;
 
593
   return 0;
 
594
}
 
595
 
 
596
static char* ADDITIONAL_TAG_NAMES[] = {
 
597
   "ERROR",
 
598
   "checkpoint_env",
 
599
   "master_queue",
 
600
   "full_job_name"
 
601
};
 
602
 
 
603
static int qstat_xml_job_additional_info(job_handler_t* handler, job_additional_info_t name, const char* value, lList **alpp) {
 
604
   
 
605
   DENTER(TOP_LAYER,"qstat_xml_job_additional_info");
 
606
   
 
607
   switch(name) {
 
608
      case CHECKPOINT_ENV:
 
609
      case MASTER_QUEUE:
 
610
         DPRINTF(("Skip additional info %s(%d) = %s\n", ADDITIONAL_TAG_NAMES[name], name, value));
 
611
         DEXIT;
 
612
         return 0;
 
613
      default:
 
614
         {
 
615
            qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
616
            /*lListElem *xml_elem = NULL;*/
 
617
            lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
618
            
 
619
            DPRINTF(("Add additional info %s(%d) = %s\n", ADDITIONAL_TAG_NAMES[name], name, value));
 
620
            xml_append_Attr_S(attribute_list, ADDITIONAL_TAG_NAMES[name], value);
 
621
            /* xml_elem = xml_append_Attr_S(attribute_list, ADDITIONAL_TAG_NAMES[name], value); 
 
622
            TODO: xml_addAttribute(xmlElem, "name", lGetString(job, JB_pe)); */
 
623
         }
 
624
   }
 
625
   DEXIT;
 
626
   return 0;
 
627
}
 
628
 
 
629
static int qstat_xml_job_requested_pe(job_handler_t *handler, const char* pe_name, const char* pe_range, lList **alpp) {
 
630
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
631
   lListElem *xml_elem = NULL;
 
632
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
633
 
 
634
   DENTER(TOP_LAYER, "qstat_xml_job_requested_pe");
 
635
   
 
636
   xml_elem = xml_append_Attr_S(attribute_list, "requested_pe", pe_range); 
 
637
   xml_addAttribute(xml_elem, "name", pe_name);
 
638
   
 
639
   DEXIT;
 
640
   return 0;
 
641
}
 
642
 
 
643
static int qstat_xml_job_granted_pe(job_handler_t *handler, const char* pe_name, int pe_slots, lList **alpp) {
 
644
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
645
   lListElem *xml_elem = NULL;
 
646
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
647
 
 
648
   DENTER(TOP_LAYER, "qstat_xml_job_granted_pe");
 
649
   
 
650
   xml_elem = xml_append_Attr_I(attribute_list, "granted_pe", pe_slots); 
 
651
   xml_addAttribute(xml_elem, "name", pe_name);
 
652
   
 
653
   DEXIT;
 
654
   return 0;
 
655
}
 
656
 
 
657
static int qstat_xml_job_request(job_handler_t* handler, const char* name, const char* value, lList **alpp) {
 
658
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
659
   lListElem *xml_elem = NULL;
 
660
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
661
   
 
662
   DENTER(TOP_LAYER,"qstat_xml_job_request");
 
663
   
 
664
   xml_elem = xml_append_Attr_S(attribute_list, "def_hard_request", value); 
 
665
   xml_addAttribute(xml_elem, "name", name);
 
666
   
 
667
   DEXIT;
 
668
   return 0;
 
669
}
 
670
 
 
671
static int qstat_xml_job_report_hard_resource(job_handler_t *handler, const char* name, const char* value, double uc, lList **alpp) {
 
672
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
673
   lListElem *xml_elem = NULL;
 
674
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
675
   
 
676
   DENTER(TOP_LAYER,"qstat_xml_job_report_hard_resource");
 
677
 
 
678
   xml_elem = xml_append_Attr_S(attribute_list, "hard_request", value);
 
679
   xml_addAttribute(xml_elem, "name", name);
 
680
   xml_addAttributeD(xml_elem, "resource_contribution", uc); 
 
681
   
 
682
   DEXIT;
 
683
   return 0;
 
684
}
 
685
 
 
686
static int qstat_xml_job_soft_resource(job_handler_t *handler, const char* name, const char* value, double uc, lList **alpp) {
 
687
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
688
   lListElem *xml_elem = NULL;
 
689
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
690
   
 
691
   DENTER(TOP_LAYER, "qstat_xml_job_soft_resource");
 
692
 
 
693
   xml_elem = xml_append_Attr_S(attribute_list, "soft_request", value);
 
694
   xml_addAttribute(xml_elem, "name", name);
 
695
   
 
696
   DEXIT;
 
697
   return 0;
 
698
}
 
699
 
 
700
static int qstat_xml_job_hard_requested_queue(job_handler_t *handler, const char* name, lList **alpp) {
 
701
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
702
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
703
 
 
704
   DENTER(TOP_LAYER, "qstat_xml_job_hard_requested_queue");
 
705
 
 
706
   xml_append_Attr_S(attribute_list, "hard_req_queue", name);
 
707
   
 
708
   DEXIT;
 
709
   return 0;
 
710
}
 
711
 
 
712
static int qstat_xml_job_soft_requested_queue(job_handler_t *handler, const char* name, lList **alpp) {
 
713
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
714
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
715
 
 
716
   DENTER(TOP_LAYER, "qstat_xml_job_soft_requested_queue");
 
717
 
 
718
   xml_append_Attr_S(attribute_list, "soft_req_queue", name);
 
719
   
 
720
   DEXIT;
 
721
   return 0;
 
722
}
 
723
 
 
724
static int qstat_xml_job_master_hard_requested_queue(job_handler_t* handler, const char* name, lList **alpp) {
 
725
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
726
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
727
 
 
728
   DENTER(TOP_LAYER, "qstat_xml_job_master_hard_requested_queue");
 
729
 
 
730
   xml_append_Attr_S(attribute_list, "master_hard_req_queue", name);
 
731
   
 
732
   DEXIT;
 
733
   return 0;
 
734
}
 
735
 
 
736
static int qstat_xml_job_predecessor_requested(job_handler_t* handler, const char* name, lList **alpp) {
 
737
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
738
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
739
 
 
740
   DENTER(TOP_LAYER, "qstat_xml_job_predecessor_requested");
 
741
 
 
742
   xml_append_Attr_S(attribute_list, "predecessor_jobs_req", name);
 
743
   
 
744
   DEXIT;
 
745
   return 0;
 
746
}
 
747
 
 
748
static int qstat_xml_job_predecessor(job_handler_t* handler, u_long32 jid, lList **alpp) {
 
749
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
750
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
751
 
 
752
   DENTER(TOP_LAYER, "qstat_xml_job_predecessor");
 
753
 
 
754
   xml_append_Attr_I(attribute_list, "predecessor_jobs", (int)jid);
 
755
   
 
756
   DEXIT;
 
757
   return 0;
 
758
}
 
759
 
 
760
static int qstat_xml_job_ad_predecessor_requested(job_handler_t* handler, const char* name, lList **alpp) {
 
761
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
762
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
763
 
 
764
   DENTER(TOP_LAYER, "qstat_xml_job_ad_predecessor_requested");
 
765
 
 
766
   xml_append_Attr_S(attribute_list, "ad_predecessor_jobs_req", name);
 
767
   
 
768
   DEXIT;
 
769
   return 0;
 
770
}
 
771
 
 
772
static int qstat_xml_job_ad_predecessor(job_handler_t* handler, u_long32 jid, lList **alpp) {
 
773
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
774
   lList *attribute_list = lGetList(ctx->job_elem, XMLE_List);
 
775
 
 
776
   DENTER(TOP_LAYER, "qstat_xml_job_ad_predecessor");
 
777
 
 
778
   xml_append_Attr_I(attribute_list, "ad_predecessor_jobs", (int)jid);
 
779
   
 
780
   DEXIT;
 
781
   return 0;
 
782
}
 
783
 
 
784
static int qstat_xml_create_job_list(qstat_handler_t *handler, lList **alpp) {
 
785
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
786
   
 
787
   DENTER(TOP_LAYER,"qstat_xml_create_job_list");
 
788
   
 
789
   if (ctx->job_list != NULL) {
 
790
      answer_list_add(alpp, "job_list is not NULL", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
791
      DEXIT;
 
792
      return -1;
 
793
   }
 
794
   
 
795
   ctx->job_list = lCreateList("job_list", XMLE_Type);
 
796
   if (ctx->job_list == NULL) {
 
797
      answer_list_add(alpp, "lCreateElem failed for job_list", STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
798
      DEXIT;
 
799
      return -1;
 
800
   }
 
801
   
 
802
   
 
803
   DEXIT;
 
804
   return 0;
 
805
}
 
806
 
 
807
static int qstat_xml_finish_job_list(qstat_handler_t *handler, const char* state, lList* target_list, lList **alpp) {
 
808
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
809
   lListElem *job_elem = NULL;
 
810
   lListElem *state_elem = NULL;
 
811
   lList *attributes = NULL;
 
812
   lList *job_list = NULL;
 
813
   
 
814
   DENTER(TOP_LAYER, "qstat_xml_finish_job_list");
 
815
   
 
816
   for_each(job_elem, ctx->job_list) {
 
817
      attributes = lGetList(job_elem, XMLE_Attribute);
 
818
      if (!attributes){
 
819
         attributes = lCreateList("attributes", XMLA_Type);
 
820
         lSetList(job_elem, XMLE_Attribute, attributes);
 
821
      }
 
822
      state_elem = lCreateElem(XMLA_Type);
 
823
      lSetString(state_elem, XMLA_Name, "state");
 
824
      lSetString(state_elem, XMLA_Value, state);
 
825
      lAppendElem(attributes, state_elem);
 
826
      
 
827
      lAppendElem(job_list, job_elem);
 
828
   }
 
829
   
 
830
   lAddList(target_list, &(ctx->job_list));
 
831
 
 
832
   DEXIT;
 
833
   return 0;
 
834
}
 
835
 
 
836
static int qstat_xml_queue_jobs_started(qstat_handler_t *handler, const char* qname, lList **alpp) {
 
837
   int ret = 0;
 
838
   DENTER(TOP_LAYER, "qstat_xml_queue_jobs_started" );
 
839
 
 
840
   ret = qstat_xml_create_job_list(handler, alpp);
 
841
 
 
842
   DEXIT;
 
843
   return ret;
 
844
}
 
845
 
 
846
static int qstat_xml_queue_jobs_finished(qstat_handler_t *handler, const char* qname, lList **alpp) {
 
847
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
848
   qstat_env_t *qstat_env = handler->qstat_env;
 
849
   int ret = 0;
 
850
   DENTER(TOP_LAYER, "qstat_xml_queue_jobs_finished");
 
851
   
 
852
   if (lFirst(ctx->job_list)) {
 
853
      lList *job_list = NULL;
 
854
      if (qstat_env->full_listing & QSTAT_DISPLAY_FULL ) {
 
855
         job_list = lGetList(ctx->queue_elem, XMLE_List);
 
856
         if(job_list == NULL) {
 
857
            job_list = lCreateList("job_list", XMLE_Type);
 
858
            lSetList(ctx->queue_elem, XMLE_List, job_list);
 
859
         }
 
860
      } else {
 
861
        job_list = lGetList(ctx->queue_list_elem, XMLE_List);
 
862
         if(job_list == NULL) {
 
863
            job_list = lCreateList("job_list", XMLE_Type);
 
864
            lSetList(ctx->queue_list_elem, XMLE_List, job_list);
 
865
         }
 
866
      }
 
867
      ret = qstat_xml_finish_job_list(handler, "running", job_list, alpp);
 
868
   } else {
 
869
      lFreeList(&(ctx->job_list));
 
870
   }
 
871
   
 
872
   DEXIT;
 
873
   return ret;   
 
874
}
 
875
 
 
876
 
 
877
static int qstat_xml_pending_jobs_started(qstat_handler_t *handler, lList **alpp) {
 
878
   int ret = 0;
 
879
   DENTER(TOP_LAYER, "qstat_xml_pending_jobs_started" );
 
880
   ret = qstat_xml_create_job_list(handler, alpp);
 
881
   DEXIT;
 
882
   return ret;
 
883
}
 
884
 
 
885
static int qstat_xml_pending_jobs_finished(qstat_handler_t *handler, lList **alpp) {
 
886
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
887
   int ret = 0;
 
888
   lList *target_list = NULL;
 
889
 
 
890
   DENTER(TOP_LAYER, "qstat_xml_pending_jobs_finished");
 
891
   
 
892
   target_list = lGetList(ctx->job_list_elem, XMLE_List);
 
893
   ret = qstat_xml_finish_job_list(handler, "pending", target_list, alpp);
 
894
 
 
895
   DEXIT;
 
896
   return ret;
 
897
}
 
898
 
 
899
static int qstat_xml_finished_jobs_started(qstat_handler_t *handler, lList **alpp) {
 
900
   int ret = 0;
 
901
 
 
902
   DENTER(TOP_LAYER, "qstat_xml_finished_jobs_started" );
 
903
 
 
904
   ret = qstat_xml_create_job_list(handler, alpp);
 
905
 
 
906
   DEXIT;
 
907
   return ret;
 
908
}
 
909
 
 
910
static int qstat_xml_finished_jobs_finished(qstat_handler_t *handler, lList **alpp) {
 
911
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
912
   int ret = 0;
 
913
   lList *target_list = NULL;
 
914
 
 
915
   DENTER(TOP_LAYER, "qstat_xml_finished_jobs_finished");
 
916
   
 
917
   target_list = lGetList(ctx->job_list_elem, XMLE_List);
 
918
   ret = qstat_xml_finish_job_list(handler, "finished", target_list, alpp);
 
919
   
 
920
   DEXIT;
 
921
   return ret;
 
922
}
 
923
 
 
924
static int qstat_xml_error_jobs_started(qstat_handler_t *handler, lList **alpp) {
 
925
   int ret = 0;
 
926
   DENTER(TOP_LAYER, "qstat_xml_error_jobs_started" );
 
927
 
 
928
   ret = qstat_xml_create_job_list(handler, alpp);
 
929
 
 
930
   DEXIT;
 
931
   return ret;
 
932
}
 
933
 
 
934
static int qstat_xml_error_jobs_finished(qstat_handler_t *handler, lList **alpp) {
 
935
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
936
   int ret = 0;
 
937
   lList *target_list = NULL;
 
938
 
 
939
   DENTER(TOP_LAYER, "qstat_xml_error_jobs_finished");
 
940
   
 
941
   target_list = lGetList(ctx->job_list_elem, XMLE_List);
 
942
   ret = qstat_xml_finish_job_list(handler, "error", target_list, alpp);
 
943
   
 
944
   DEXIT;
 
945
   return ret;
 
946
}
 
947
 
 
948
static int qstat_xml_zombie_jobs_started(qstat_handler_t *handler, lList **alpp) {
 
949
   int ret = 0;
 
950
 
 
951
   DENTER(TOP_LAYER, "qstat_xml_zombie_jobs_started" );
 
952
 
 
953
   ret = qstat_xml_create_job_list(handler, alpp);
 
954
 
 
955
   DEXIT;
 
956
   return ret;
 
957
}
 
958
 
 
959
static int qstat_xml_zombie_jobs_finished(qstat_handler_t *handler, lList **alpp) {
 
960
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
961
   int ret = 0;
 
962
   lList *target_list = NULL;
 
963
   
 
964
   DENTER(TOP_LAYER, "qstat_xml_zombie_jobs_finished");
 
965
   
 
966
   target_list = lGetList(ctx->job_list_elem, XMLE_List);
 
967
   ret = qstat_xml_finish_job_list(handler, "zombie", target_list, alpp);
 
968
   
 
969
   DEXIT;
 
970
   return ret;
 
971
}
 
972
 
 
973
static int qstat_xml_queue_finished(qstat_handler_t* handler, const char* qname, lList **alpp) {
 
974
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
975
   qstat_env_t *qstat_env = handler->qstat_env;   
 
976
   lList* queue_list = NULL;
 
977
 
 
978
   DENTER(TOP_LAYER, "qstat_xml_queue_finished");
 
979
   
 
980
   if (qstat_env->full_listing & QSTAT_DISPLAY_FULL) {
 
981
      if (ctx->queue_elem == NULL) {
 
982
         DPRINTF(("Illegal State: ctx->queue_elem is NULL !!!\n"));
 
983
         abort();
 
984
      }
 
985
      DPRINTF(("add queue_info for queue %s to queue_list\n", qname ));
 
986
      
 
987
      queue_list = lGetList(ctx->queue_list_elem, XMLE_List);
 
988
      if (queue_list == NULL) {
 
989
         DPRINTF(("Had empty queue list, create new one\n"));
 
990
         queue_list = lCreateList("Queue-List", XMLE_Type);
 
991
         lSetList(ctx->queue_list_elem, XMLE_List, queue_list);
 
992
      }
 
993
      lAppendElem(queue_list, ctx->queue_elem);
 
994
      ctx->queue_elem = NULL;
 
995
   } else {
 
996
      lFreeElem(&(ctx->queue_elem));
 
997
   }
 
998
 
 
999
   DEXIT;
 
1000
   return 0;
 
1001
}
 
1002
 
 
1003
static int qstat_xml_queue_started(qstat_handler_t* handler, const char* qname, lList **alpp) {
 
1004
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
1005
   qstat_env_t *qstat_env = handler->qstat_env;
 
1006
   lList *attribute_list = NULL;
 
1007
   lListElem *temp = NULL;
 
1008
 
 
1009
   DENTER(TOP_LAYER, "qstat_xml_queue_started");
 
1010
   
 
1011
   if (qstat_env->full_listing & QSTAT_DISPLAY_FULL) {
 
1012
      
 
1013
      if (ctx->queue_elem != NULL) {
 
1014
         DPRINTF(("Ilegal state: ctx->queue_elem has to be NULL"));
 
1015
         abort();
 
1016
      }
 
1017
      
 
1018
      DPRINTF(("Create ctx->queue_elem for queue %s\n", qname));
 
1019
   
 
1020
      temp = lCreateElem(XMLE_Type);
 
1021
      lSetBool(temp, XMLE_Print, false);
 
1022
      ctx->queue_elem = lCreateElem(XMLE_Type);
 
1023
      attribute_list = lCreateList("attributes", XMLE_Type);
 
1024
      lSetList(temp, XMLE_List, attribute_list);
 
1025
      lSetObject(ctx->queue_elem, XMLE_Element, temp);
 
1026
   }   
 
1027
 
 
1028
   DEXIT;
 
1029
   return 0;
 
1030
}
 
1031
 
 
1032
static int qstat_xml_queue_summary(qstat_handler_t* handler, const char* qname, queue_summary_t *summary, lList **alpp) {
 
1033
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
1034
   lList *attribute_list = NULL;
 
1035
   lListElem *xml_elem = NULL;
 
1036
   DENTER(TOP_LAYER, "qstat_xml_queue_summary");
 
1037
 
 
1038
   if (ctx->queue_elem == NULL) {
 
1039
      DPRINTF(("Ilegal state: ctx->queue_elem must not be NULL"));
 
1040
      abort();
 
1041
   }
 
1042
   xml_elem = lGetObject(ctx->queue_elem, XMLE_Element);
 
1043
   attribute_list = lGetList(xml_elem, XMLE_List);
 
1044
   
 
1045
   xml_append_Attr_S(attribute_list, "name", qname);        
 
1046
   xml_append_Attr_S(attribute_list, "qtype", summary->queue_type); 
 
1047
 
 
1048
   /* number of used/free slots */
 
1049
   xml_append_Attr_I(attribute_list, "slots_used", summary->used_slots); 
 
1050
   xml_append_Attr_I(attribute_list, "slots_resv", summary->resv_slots); 
 
1051
   xml_append_Attr_I(attribute_list, "slots_total", summary->used_slots + summary->free_slots);
 
1052
 
 
1053
   /* load avg */
 
1054
   if (summary->has_load_value && summary->has_load_value_from_object) {
 
1055
      xml_append_Attr_D(attribute_list, "load_avg", summary->load_avg);
 
1056
   }
 
1057
   
 
1058
   /* arch */
 
1059
   if(summary->arch) {
 
1060
      xml_append_Attr_S(attribute_list, "arch", summary->arch);
 
1061
   }
 
1062
 
 
1063
   xml_append_Attr_S(attribute_list, "state", summary->state);
 
1064
 
 
1065
   DEXIT;
 
1066
   return 0;
 
1067
}
 
1068
 
 
1069
static int qstat_xml_queue_load_alarm(qstat_handler_t* handler, const char* qname, const char* reason, lList **alpp) {
 
1070
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
1071
   int ret = 0;
 
1072
   lList *attribute_list = NULL;
 
1073
   lListElem *xml_elem = NULL;
 
1074
   DENTER(TOP_LAYER,"qstat_xml_queue_load_alarm");
 
1075
   
 
1076
   xml_elem = lGetObject(ctx->queue_elem, XMLE_Element);
 
1077
   attribute_list = lGetList(xml_elem, XMLE_List);
 
1078
   
 
1079
   xml_append_Attr_S(attribute_list, "load-alarm-reason", reason);
 
1080
   
 
1081
   DEXIT;
 
1082
   return ret;
 
1083
}
 
1084
 
 
1085
static int qstat_xml_queue_suspend_alarm(qstat_handler_t* handler, const char* qname, const char* reason, lList **alpp) {
 
1086
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
1087
   lList *attribute_list = NULL;
 
1088
   lListElem *xml_elem = NULL;
 
1089
   DENTER(TOP_LAYER,"qstat_xml_queue_suspend_alarm");
 
1090
   
 
1091
   xml_elem = lGetObject(ctx->queue_elem, XMLE_Element);
 
1092
   attribute_list = lGetList(xml_elem, XMLE_List);
 
1093
   
 
1094
   xml_append_Attr_S(attribute_list, "suspend-alarm-reason", reason);
 
1095
   
 
1096
   DEXIT;
 
1097
   return 0;
 
1098
}
 
1099
 
 
1100
static int qstat_xml_queue_message(qstat_handler_t* handler, const char* qname, const char *message, lList **alpp) {
 
1101
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
1102
   lList *attribute_list = NULL;
 
1103
   lListElem *xml_elem = NULL;
 
1104
   DENTER(TOP_LAYER,"qstat_xml_queue_message");
 
1105
 
 
1106
   xml_elem = lGetObject(ctx->queue_elem, XMLE_Element);
 
1107
   attribute_list = lGetList(xml_elem, XMLE_List);
 
1108
   
 
1109
   xml_append_Attr_S(attribute_list, "message", message);
 
1110
   
 
1111
   DEXIT;
 
1112
   return 0;
 
1113
}
 
1114
 
 
1115
static int qstat_xml_queue_resource(qstat_handler_t* handler, const char* dom, const char* name, const char* value, lList **alpp) {
 
1116
   qstat_xml_ctx_t *ctx = (qstat_xml_ctx_t*)handler->ctx;
 
1117
   lList *attribute_list = NULL;
 
1118
   lListElem *xml_elem = NULL;
 
1119
   
 
1120
   DENTER(TOP_LAYER,"qstat_xml_queue_resource");
 
1121
   
 
1122
   xml_elem = lGetObject(ctx->queue_elem, XMLE_Element);
 
1123
   attribute_list = lGetList(xml_elem, XMLE_List);
 
1124
   
 
1125
   DPRINTF(("queue resource: %s, %s, %s\n", dom, name, value));
 
1126
   xml_elem = xml_append_Attr_S(attribute_list, "resource", value);
 
1127
   xml_addAttribute(xml_elem, "name", name);  
 
1128
   xml_addAttribute(xml_elem, "type", dom);
 
1129
   
 
1130
   DEXIT;
 
1131
   return 0;
 
1132
}
 
1133
 
 
1134
 
 
1135
 
 
1136
void xml_qstat_show_job_info(lList **list, lList **answer_list) {
 
1137
   lListElem *answer = NULL;
 
1138
   lListElem *xml_elem = NULL;
 
1139
   bool error = false;
 
1140
   lListElem* mes;
 
1141
   lListElem *sme;
 
1142
   lList *mlp = NULL;
 
1143
   lListElem *jid_ulng = NULL; 
 
1144
   DENTER(TOP_LAYER, "xml_qstat_show_job");
 
1145
 
 
1146
   for_each(answer, *answer_list) {
 
1147
      if (lGetUlong(answer, AN_status) != STATUS_OK) {
 
1148
         error = true;
 
1149
         break;
 
1150
      }
 
1151
   }
 
1152
 
 
1153
   if (error) {
 
1154
      xml_elem = xml_getHead("comunication_error", *answer_list, NULL);
 
1155
      lWriteElemXMLTo(xml_elem, stdout);
 
1156
      lFreeElem(&xml_elem);
 
1157
   }
 
1158
   else {
 
1159
      /* need to modify list to display correct message */
 
1160
      
 
1161
      sme = lFirst(*list);
 
1162
      if (sme) {
 
1163
         mlp = lGetList(sme, SME_message_list);         
 
1164
      }      
 
1165
      for_each(mes, mlp) {
 
1166
         lPSortList (lGetList(mes, MES_job_number_list), "I+", ULNG);
 
1167
 
 
1168
         for_each(jid_ulng, lGetList(mes, MES_job_number_list)) {
 
1169
            u_long32 mid;            
 
1170
 
 
1171
            mid = lGetUlong(mes, MES_message_number);
 
1172
            lSetString(mes,MES_message,sge_schedd_text(mid+SCHEDD_INFO_OFFSET));
 
1173
         }
 
1174
            
 
1175
      }
 
1176
           
 
1177
      /* print out xml info from list */
 
1178
      
 
1179
      xml_elem = xml_getHead("message", *list, NULL);
 
1180
      lWriteElemXMLTo(xml_elem, stdout);
 
1181
      lFreeElem(&xml_elem);
 
1182
      *list = NULL;
 
1183
   }
 
1184
 
 
1185
   lFreeList(answer_list);
 
1186
 
 
1187
   DEXIT;
 
1188
   return;
 
1189
}
 
1190
 
 
1191
void xml_qstat_show_job(lList **job_list, lList **msg_list, lList **answer_list, lList **id_list){
 
1192
   lListElem *answer = NULL;
 
1193
   lListElem *xml_elem = NULL;
 
1194
   bool error = false;
 
1195
 
 
1196
   DENTER(TOP_LAYER, "xml_qstat_show_job");
 
1197
   
 
1198
   for_each(answer, *answer_list) {
 
1199
      if (lGetUlong(answer, AN_status) != STATUS_OK) {
 
1200
         error = true;
 
1201
         break;
 
1202
      }
 
1203
   }
 
1204
   
 
1205
   if (error) {
 
1206
      xml_elem = xml_getHead("comunication_error", *answer_list, NULL);
 
1207
      lWriteElemXMLTo(xml_elem, stdout);
 
1208
      lFreeElem(&xml_elem);
 
1209
   }
 
1210
   else {
 
1211
      if (lGetNumberOfElem(*job_list) == 0) {
 
1212
         xml_elem = xml_getHead("unknown_jobs", *id_list, NULL);
 
1213
         lWriteElemXMLTo(xml_elem, stdout);
 
1214
         lFreeElem(&xml_elem);
 
1215
         *id_list = NULL;
 
1216
      }
 
1217
      else {
 
1218
         lList *XML_out = lCreateList("detailed_job_info", XMLE_Type);
 
1219
         lListElem *xmlElem = NULL;
 
1220
         lListElem *attrElem = NULL;
 
1221
        
 
1222
         /* add job infos */
 
1223
         xmlElem = lCreateElem(XMLE_Type);
 
1224
         attrElem = lCreateElem(XMLA_Type); 
 
1225
         lSetString(attrElem, XMLA_Name, "djob_info");
 
1226
         lSetObject(xmlElem, XMLE_Element, attrElem);
 
1227
         lSetBool(xmlElem, XMLE_Print, true);
 
1228
         lSetList(xmlElem, XMLE_List, *job_list);
 
1229
         lAppendElem(XML_out, xmlElem);
 
1230
 
 
1231
         /* add messages */
 
1232
         xmlElem = lCreateElem(XMLE_Type);
 
1233
         attrElem = lCreateElem(XMLA_Type);         
 
1234
         lSetString(attrElem, XMLA_Name, "messages");
 
1235
         lSetObject(xmlElem, XMLE_Element, attrElem);
 
1236
         lSetBool(xmlElem, XMLE_Print, true);
 
1237
         lSetList(xmlElem, XMLE_List, *msg_list);
 
1238
         lAppendElem(XML_out, xmlElem);
 
1239
         
 
1240
         
 
1241
         xml_elem = xml_getHead("detailed_job_info", XML_out, NULL);
 
1242
 
 
1243
         lWriteElemXMLTo(xml_elem, stdout);
 
1244
 
 
1245
         lFreeElem(&xml_elem);
 
1246
         *job_list = NULL;
 
1247
         *msg_list = NULL;
 
1248
         
 
1249
      }
 
1250
   }
 
1251
 
 
1252
   lFreeList(answer_list);
 
1253
 
 
1254
   DEXIT;
 
1255
   return;
 
1256
}
 
1257
 
 
1258