← Back to branch summary

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

« back to all changes in this revision

Viewing changes to source/clients/common/sge_resource_quota_qconf.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/common/sge_resource_quota_qconf.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
 
 
32
#include <string.h>
 
33
 
 
34
#include "sge_resource_quota_qconf.h"
 
35
#include "msg_common.h"
 
36
#include "msg_clients_common.h"
 
37
 
 
38
#include "uti/sge_log.h"
 
39
#include "uti/sge_edit.h"
 
40
#include "rmon/sgermon.h"
 
41
#include "gdi/sge_gdi.h"
 
42
#include "uti/sge_prog.h"
 
43
 
 
44
#include "sgeobj/sge_utility.h"
 
45
#include "sgeobj/sge_resource_quota.h"
 
46
#include "sgeobj/sge_answer.h"
 
47
#include "spool/flatfile/sge_flatfile.h"
 
48
#include "spool/flatfile/sge_flatfile_obj.h"
 
49
 
 
50
static bool rqs_provide_modify_context(sge_gdi_ctx_class_t *ctx,
 
51
                                  lList **rqs_list, lList **answer_list,
 
52
                                  bool ignore_unchanged_message);
 
53
 
 
54
 
 
55
/****** resource_quota_qconf/rqs_show() *********************************
 
56
*  NAME
 
57
*     rqs_show() -- show resource quota sets
 
58
*
 
59
*  SYNOPSIS
 
60
*     bool rqs_show(lList **answer_list, const char *name) 
 
61
*
 
62
*  FUNCTION
 
63
*     This funtion gets the selected resource quota sets from GDI and
 
64
*     writes they out on stdout
 
65
*
 
66
*  INPUTS
 
67
*     lList **answer_list - answer list
 
68
*     const char *name    - comma separated list of resource quota set names
 
69
*
 
70
*  RESULT
 
71
*     bool - true  on success
 
72
*            false on error
 
73
*
 
74
*  NOTES
 
75
*     MT-NOTE: rqs_show() is MT safe 
 
76
*
 
77
*******************************************************************************/
 
78
bool rqs_show(sge_gdi_ctx_class_t *ctx, lList **answer_list, const char *name)
 
79
{
 
80
   lList *rqs_list = NULL;
 
81
   bool ret = false;
 
82
 
 
83
   DENTER(TOP_LAYER, "rqs_show");
 
84
 
 
85
   if (name != NULL) {
 
86
      lList *rqsref_list = NULL;
 
87
 
 
88
      lString2List(name, &rqsref_list, RQS_Type, RQS_name, ", ");
 
89
      ret = rqs_get_via_gdi(ctx, answer_list, rqsref_list, &rqs_list);
 
90
      lFreeList(&rqsref_list);
 
91
   } else {
 
92
      ret = rqs_get_all_via_gdi(ctx, answer_list, &rqs_list);
 
93
   }
 
94
 
 
95
   if (ret && lGetNumberOfElem(rqs_list)) {
 
96
      const char* filename;
 
97
      filename = spool_flatfile_write_list(answer_list, rqs_list, RQS_fields, 
 
98
                                        &qconf_rqs_sfi,
 
99
                                        SP_DEST_STDOUT, SP_FORM_ASCII, NULL,
 
100
                                        false);
 
101
      FREE(filename);
 
102
   }
 
103
   if (lGetNumberOfElem(rqs_list) == 0) {
 
104
      answer_list_add(answer_list, MSG_NORQSFOUND, STATUS_EEXIST, ANSWER_QUALITY_WARNING);
 
105
      ret = false;
 
106
   }
 
107
 
 
108
   lFreeList(&rqs_list);
 
109
 
 
110
   DRETURN(ret);
 
111
}
 
112
 
 
113
/****** resource_quota_qconf/rqs_get_via_gdi() **************************
 
114
*  NAME
 
115
*     rqs_get_via_gdi() -- get resource quota sets from GDI
 
116
*
 
117
*  SYNOPSIS
 
118
*     bool rqs_get_via_gdi(lList **answer_list, const lList 
 
119
*     *rqsref_list, lList **rqs_list) 
 
120
*
 
121
*  FUNCTION
 
122
*     This function gets the selected resource quota sets from qmaster. The selection
 
123
*     is done in the string list rqsref_list.
 
124
*
 
125
*  INPUTS
 
126
*     lList **answer_list       - answer list
 
127
*     const lList *rqsref_list - resource quota sets selection
 
128
*     lList **rqs_list         - copy of the selected rule sets
 
129
*
 
130
*  RESULT
 
131
*     bool - true  on success
 
132
*            false on error
 
133
*
 
134
*  NOTES
 
135
*     MT-NOTE: rqs_get_via_gdi() is MT safe 
 
136
*
 
137
*******************************************************************************/
 
138
bool rqs_get_via_gdi(sge_gdi_ctx_class_t *ctx, lList **answer_list, const lList *rqsref_list,
 
139
                            lList **rqs_list)
 
140
{
 
141
   bool ret = false;
 
142
 
 
143
   DENTER(TOP_LAYER, "rqs_get_via_gdi");
 
144
   if (rqsref_list != NULL) {
 
145
      lListElem *rqsref = NULL;
 
146
      lCondition *where = NULL;
 
147
      lEnumeration *what = NULL;
 
148
 
 
149
      what = lWhat("%T(ALL)", RQS_Type);
 
150
 
 
151
      for_each(rqsref, rqsref_list) {
 
152
         lCondition *add_where = NULL;
 
153
         add_where = lWhere("%T(%I p= %s)", RQS_Type, RQS_name, lGetString(rqsref, RQS_name));
 
154
         if (where == NULL) {
 
155
            where = add_where;
 
156
         } else {
 
157
            where = lOrWhere(where, add_where);
 
158
         }
 
159
      }
 
160
      *answer_list = ctx->gdi(ctx, SGE_RQS_LIST, SGE_GDI_GET, rqs_list, where, what);
 
161
      if (!answer_list_has_error(answer_list)) {
 
162
         ret = true;
 
163
      }
 
164
 
 
165
      lFreeWhat(&what);
 
166
      lFreeWhere(&where);
 
167
   }
 
168
 
 
169
   DRETURN(ret);
 
170
}
 
171
 
 
172
/****** resource_quota_qconf/rqs_get_all_via_gdi() **********************
 
173
*  NAME
 
174
*     rqs_get_all_via_gdi() -- get all resource quota sets from GDI 
 
175
*
 
176
*  SYNOPSIS
 
177
*     bool rqs_get_all_via_gdi(lList **answer_list, lList **rqs_list) 
 
178
*
 
179
*  FUNCTION
 
180
*     This function gets all resource quota sets known by qmaster
 
181
*
 
182
*  INPUTS
 
183
*     lList **answer_list - answer list
 
184
*     lList **rqs_list   - copy of all resource quota sets
 
185
*
 
186
*  RESULT
 
187
*     bool - true  on success
 
188
*            false on error
 
189
*
 
190
*  NOTES
 
191
*     MT-NOTE: rqs_get_all_via_gdi() is MT safe 
 
192
*
 
193
*******************************************************************************/
 
194
bool rqs_get_all_via_gdi(sge_gdi_ctx_class_t *ctx, lList **answer_list, lList **rqs_list)
 
195
{
 
196
   bool ret = false;
 
197
   lEnumeration *what = lWhat("%T(ALL)", RQS_Type);
 
198
 
 
199
   DENTER(TOP_LAYER, "rqs_get_all_via_gdi");
 
200
 
 
201
   *answer_list = ctx->gdi(ctx, SGE_RQS_LIST, SGE_GDI_GET, rqs_list, NULL, what);
 
202
   if (!answer_list_has_error(answer_list)) {
 
203
      ret = true;
 
204
   }
 
205
 
 
206
   lFreeWhat(&what);
 
207
 
 
208
   DRETURN(ret);
 
209
}
 
210
 
 
211
/****** resource_quota_qconf/rqs_add() ******************************
 
212
*  NAME
 
213
*     rqs_add() -- add resource quota set list
 
214
*
 
215
*  SYNOPSIS
 
216
*     bool rqs_add(lList **answer_list, const char *name) 
 
217
*
 
218
*  FUNCTION
 
219
*     This function provide a modify context for qconf to add new resource
 
220
*     quota sets. If no name is given a template rule set is shown
 
221
*
 
222
*  INPUTS
 
223
*     lList **answer_list - answer list
 
224
*     const char *name    - comma seperated list of rule sets to add
 
225
*
 
226
*  RESULT
 
227
*     bool - true  on success
 
228
*            false on error
 
229
*
 
230
*  NOTES
 
231
*     MT-NOTE: rqs_add() is MT safe 
 
232
*
 
233
*******************************************************************************/
 
234
bool rqs_add(sge_gdi_ctx_class_t *ctx, lList **answer_list, const char *name)
 
235
{
 
236
   bool ret = false;
 
237
 
 
238
   DENTER(TOP_LAYER, "rqs_list_add");
 
239
   if (name != NULL) {
 
240
      lList *rqs_list = NULL;
 
241
      lListElem *rqs = NULL;
 
242
 
 
243
      lString2List(name, &rqs_list, RQS_Type, RQS_name, ", ");
 
244
      for_each (rqs, rqs_list) {
 
245
         rqs = rqs_set_defaults(rqs);
 
246
      }
 
247
 
 
248
      ret = rqs_provide_modify_context(ctx, &rqs_list, answer_list, true);
 
249
 
 
250
      if (ret) {
 
251
         ret = rqs_add_del_mod_via_gdi(ctx, rqs_list, answer_list, SGE_GDI_ADD | SGE_GDI_SET_ALL);
 
252
      }
 
253
 
 
254
      lFreeList(&rqs_list);
 
255
   }
 
256
 
 
257
   DRETURN(ret);
 
258
}
 
259
 
 
260
/****** resource_quota_qconf/rqs_modify() ***************************
 
261
*  NAME
 
262
*     rqs_modify() -- modify resource quota sets
 
263
*
 
264
*  SYNOPSIS
 
265
*     bool rqs_modify(lList **answer_list, const char *name) 
 
266
*
 
267
*  FUNCTION
 
268
*     This function provides a modify context for qconf to modify resource
 
269
*     quota sets.
 
270
*
 
271
*  INPUTS
 
272
*     lList **answer_list - answer list
 
273
*     const char *name    - comma seperated list of rule sets to modify
 
274
*
 
275
*  RESULT
 
276
*     bool - true  on success
 
277
*            false on error
 
278
*
 
279
*  NOTES
 
280
*     MT-NOTE: rqs_modify() is MT safe 
 
281
*
 
282
*******************************************************************************/
 
283
bool rqs_modify(sge_gdi_ctx_class_t *ctx, lList **answer_list, const char *name)
 
284
{
 
285
   bool ret = false;
 
286
   lList *rqs_list = NULL;
 
287
   u_long32 gdi_command = 0;
 
288
 
 
289
   DENTER(TOP_LAYER, "rqs_modify");
 
290
 
 
291
   if (name != NULL) {
 
292
      lList *rqsref_list = NULL;
 
293
 
 
294
      gdi_command = SGE_GDI_MOD | SGE_GDI_SET_ALL;
 
295
 
 
296
      lString2List(name, &rqsref_list, RQS_Type, RQS_name, ", ");
 
297
      ret = rqs_get_via_gdi(ctx, answer_list, rqsref_list, &rqs_list);
 
298
      lFreeList(&rqsref_list);
 
299
   } else {
 
300
      gdi_command = SGE_GDI_REPLACE;
 
301
      ret = rqs_get_all_via_gdi(ctx, answer_list, &rqs_list);
 
302
   }
 
303
 
 
304
   if (ret) {
 
305
      ret = rqs_provide_modify_context(ctx, &rqs_list, answer_list, false);
 
306
   }
 
307
   if (ret) {
 
308
      ret = rqs_add_del_mod_via_gdi(ctx, rqs_list, answer_list,
 
309
                                       gdi_command);
 
310
   }
 
311
 
 
312
   lFreeList(&rqs_list);
 
313
 
 
314
   DRETURN(ret);
 
315
}
 
316
 
 
317
/****** resource_quota_qconf/rqs_add_from_file() ********************
 
318
*  NAME
 
319
*     rqs_add_from_file() -- add resource quota set from file
 
320
*
 
321
*  SYNOPSIS
 
322
*     bool rqs_add_from_file(lList **answer_list, const char 
 
323
*     *filename) 
 
324
*
 
325
*  FUNCTION
 
326
*     This function add new resource quota sets from file.
 
327
*
 
328
*  INPUTS
 
329
*     lList **answer_list  - answer list
 
330
*     const char *filename - filename of new resource quota sets
 
331
*
 
332
*  RESULT
 
333
*     bool - true  on success
 
334
*            false on error
 
335
*
 
336
*  NOTES
 
337
*     MT-NOTE: rqs_add_from_file() is MT safe 
 
338
*
 
339
*******************************************************************************/
 
340
bool rqs_add_from_file(sge_gdi_ctx_class_t *ctx, lList **answer_list, const char *filename)
 
341
{
 
342
   bool ret = false;
 
343
 
 
344
   DENTER(TOP_LAYER, "rqs_add_from_file");
 
345
   if (filename != NULL) {
 
346
      lList *rqs_list = NULL;
 
347
 
 
348
      /* fields_out field does not work for rqs because of duplicate entry */
 
349
      rqs_list = spool_flatfile_read_list(answer_list, RQS_Type, RQS_fields,
 
350
                                          NULL, true, &qconf_rqs_sfi,
 
351
                                          SP_FORM_ASCII, NULL, filename);
 
352
      if (!answer_list_has_error(answer_list)) {
 
353
         ret = rqs_add_del_mod_via_gdi(ctx, rqs_list, answer_list, 
 
354
                                       SGE_GDI_ADD | SGE_GDI_SET_ALL); 
 
355
      }
 
356
 
 
357
      lFreeList(&rqs_list);
 
358
   }
 
359
   DRETURN(ret);
 
360
}
 
361
 
 
362
/****** resource_quota_qconf/rqs_provide_modify_context() ***********
 
363
*  NAME
 
364
*     rqs_provide_modify_context() -- provide qconf modify context
 
365
*
 
366
*  SYNOPSIS
 
367
*     bool rqs_provide_modify_context(lList **rqs_list, lList 
 
368
*     **answer_list, bool ignore_unchanged_message) 
 
369
*
 
370
*  FUNCTION
 
371
*     This function provides a editor session to edit the selected resource quota
 
372
*     sets interactively. 
 
373
*
 
374
*  INPUTS
 
375
*     lList **rqs_list             - resource quota sets to modify
 
376
*     lList **answer_list           - answer list
 
377
*     bool ignore_unchanged_message - ignore unchanged message
 
378
*
 
379
*  RESULT
 
380
*     bool - true  on success
 
381
*            false on error
 
382
*
 
383
*  NOTES
 
384
*     MT-NOTE: rqs_provide_modify_context() is MT safe 
 
385
*
 
386
*******************************************************************************/
 
387
static bool rqs_provide_modify_context(sge_gdi_ctx_class_t *ctx, lList **rqs_list, lList **answer_list,
 
388
                                           bool ignore_unchanged_message)
 
389
{
 
390
   bool ret = false;
 
391
   int status = 0;
 
392
   const char *filename = NULL;
 
393
   uid_t uid = ctx->get_uid(ctx);
 
394
   gid_t gid = ctx->get_gid(ctx);
 
395
   
 
396
   DENTER(TOP_LAYER, "rqs_provide_modify_context");
 
397
 
 
398
   if (rqs_list == NULL) {
 
399
      answer_list_add(answer_list, MSG_PARSE_NULLPOINTERRECEIVED, 
 
400
                      STATUS_ERROR1, ANSWER_QUALITY_ERROR);
 
401
      DRETURN(ret); 
 
402
   }
 
403
 
 
404
   if (*rqs_list == NULL) {
 
405
      *rqs_list = lCreateList("", RQS_Type);
 
406
   }
 
407
 
 
408
   filename = spool_flatfile_write_list(answer_list, *rqs_list, RQS_fields,
 
409
                                        &qconf_rqs_sfi, SP_DEST_TMP,
 
410
                                        SP_FORM_ASCII, filename, false);
 
411
 
 
412
   if (answer_list_has_error(answer_list)) {
 
413
      unlink(filename);
 
414
      FREE(filename);
 
415
      DRETURN(ret);
 
416
   }
 
417
 
 
418
   status = sge_edit(filename, uid, gid);
 
419
 
 
420
   if (status == 0) {
 
421
      lList *new_rqs_list = NULL;
 
422
 
 
423
      /* fields_out field does not work for rqs because of duplicate entry */
 
424
      new_rqs_list = spool_flatfile_read_list(answer_list, RQS_Type, RQS_fields,
 
425
                                               NULL, true, &qconf_rqs_sfi,
 
426
                                               SP_FORM_ASCII, NULL, filename);
 
427
      if (answer_list_has_error(answer_list)) {
 
428
         lFreeList(&new_rqs_list);
 
429
      }
 
430
      if (new_rqs_list != NULL) {
 
431
         if (ignore_unchanged_message || object_list_has_differences(new_rqs_list, answer_list, *rqs_list, false)) {
 
432
            lFreeList(rqs_list);
 
433
            *rqs_list = new_rqs_list;
 
434
            ret = true;
 
435
         } else {
 
436
            lFreeList(&new_rqs_list);
 
437
            answer_list_add(answer_list, MSG_FILE_NOTCHANGED,
 
438
                            STATUS_ERROR1, ANSWER_QUALITY_ERROR);
 
439
         }
 
440
      } else {
 
441
         answer_list_add(answer_list, MSG_FILE_ERRORREADINGINFILE,
 
442
                         STATUS_ERROR1, ANSWER_QUALITY_ERROR);
 
443
      }
 
444
   } else if (status == 1) {
 
445
      answer_list_add(answer_list, MSG_FILE_FILEUNCHANGED,
 
446
                      STATUS_ERROR1, ANSWER_QUALITY_ERROR);
 
447
   } else {
 
448
      answer_list_add(answer_list, MSG_PARSE_EDITFAILED,
 
449
                      STATUS_ERROR1, ANSWER_QUALITY_ERROR);
 
450
   }
 
451
 
 
452
   unlink(filename);
 
453
   FREE(filename);
 
454
   DRETURN(ret);
 
455
}
 
456
 
 
457
/****** resource_quota_qconf/rqs_add_del_mod_via_gdi() **************
 
458
*  NAME
 
459
*    rqs_add_del_mod_via_gdi/rqs_add_del_mod_via_gdi() -- modfies qmaster resource quota sets
 
460
*
 
461
*  SYNOPSIS
 
462
*     bool rqs_add_del_mod_via_gdi(lList *rqs_list, lList 
 
463
*     **answer_list, u_long32 gdi_command) 
 
464
*
 
465
*  FUNCTION
 
466
*     This function modifies via GDI the qmaster copy of the resource quota sets.
 
467
*
 
468
*  INPUTS
 
469
*     lList *rqs_list     - resource quota sets to modify on qmaster
 
470
*     lList **answer_list  - answer list from qmaster
 
471
*     u_long32 gdi_command - commands what to do
 
472
*
 
473
*  RESULT
 
474
*     bool - true  on success
 
475
*            false on error
 
476
*
 
477
*  NOTES
 
478
*     MT-NOTE: rqs_add_del_mod_via_gdi() is MT safe 
 
479
*
 
480
*******************************************************************************/
 
481
bool rqs_add_del_mod_via_gdi(sge_gdi_ctx_class_t *ctx, lList *rqs_list, lList **answer_list,
 
482
                                        u_long32 gdi_command) 
 
483
{
 
484
   bool ret = false;
 
485
   
 
486
   DENTER(TOP_LAYER, "rqs_add_del_mod_via_gdi");
 
487
 
 
488
   if (rqs_list != NULL) {
 
489
      u_long32 operation = SGE_GDI_GET_OPERATION(gdi_command);
 
490
      bool do_verify = (operation == SGE_GDI_MOD) || (operation == SGE_GDI_ADD
 
491
                        || (operation == SGE_GDI_REPLACE)) ? true : false;
 
492
 
 
493
      if (do_verify) {
 
494
         ret = rqs_list_verify_attributes(rqs_list, answer_list, false);
 
495
      }
 
496
      if (ret) {
 
497
         lList *my_answer_list = ctx->gdi(ctx, SGE_RQS_LIST, gdi_command, &rqs_list, NULL, NULL);
 
498
         if (my_answer_list != NULL) {
 
499
            answer_list_append_list(answer_list, &my_answer_list);
 
500
         }
 
501
      }
 
502
   }
 
503
   DRETURN(ret);
 
504
}
 
505
 
 
506
/****** resource_quota_qconf/rqs_modify_from_file() *****************
 
507
*  NAME
 
508
*     rqs_modify_from_file() -- modifies resource quota sets from file
 
509
*
 
510
*  SYNOPSIS
 
511
*     bool rqs_modify_from_file(lList **answer_list, const char 
 
512
*     *filename, const char* name) 
 
513
*
 
514
*  FUNCTION
 
515
*     This function allows to modify one or all resource quota sets from a file
 
516
*
 
517
*  INPUTS
 
518
*     lList **answer_list  - answer list
 
519
*     const char *filename - filename with the resource quota sets to change
 
520
*     const char* name     - comma separated list of rule sets to change
 
521
*
 
522
*  RESULT
 
523
*     bool - true  on success
 
524
*            false on error
 
525
*
 
526
*  NOTES
 
527
*     MT-NOTE: rqs_modify_from_file() is MT safe 
 
528
*
 
529
*******************************************************************************/
 
530
bool rqs_modify_from_file(sge_gdi_ctx_class_t *ctx, lList **answer_list, const char *filename, const char* name) 
 
531
{
 
532
   bool ret = false;
 
533
   u_long32 gdi_command = 0;
 
534
   
 
535
   DENTER(TOP_LAYER, "rqs_modify_from_file");
 
536
   if (filename != NULL) {
 
537
      lList *rqs_list = NULL;
 
538
 
 
539
      /* fields_out field does not work for rqs because of duplicate entry */
 
540
      rqs_list = spool_flatfile_read_list(answer_list, RQS_Type, RQS_fields,
 
541
                                          NULL, true, &qconf_rqs_sfi,
 
542
                                          SP_FORM_ASCII, NULL, filename);
 
543
      if (rqs_list != NULL) {
 
544
 
 
545
         if (name != NULL && strlen(name) > 0 ) {
 
546
            lList *selected_rqs_list = NULL;
 
547
            lListElem *tmp_rqs = NULL;
 
548
            lList *found_rqs_list = lCreateList("rqs_list", RQS_Type);
 
549
 
 
550
            gdi_command = SGE_GDI_MOD | SGE_GDI_SET_ALL;
 
551
 
 
552
            lString2List(name, &selected_rqs_list, RQS_Type, RQS_name, ", ");
 
553
            for_each(tmp_rqs, selected_rqs_list) {
 
554
               lListElem *found = rqs_list_locate(rqs_list, lGetString(tmp_rqs, RQS_name));
 
555
               if (found != NULL) {
 
556
                  lAppendElem(found_rqs_list, lCopyElem(found));
 
557
               } else {
 
558
                  sprintf(SGE_EVENT, MSG_RQSNOTFOUNDINFILE_SS, lGetString(tmp_rqs, RQS_name), filename);
 
559
                  answer_list_add(answer_list, SGE_EVENT, STATUS_ERROR1, ANSWER_QUALITY_ERROR);
 
560
                  lFreeList(&found_rqs_list);
 
561
                  break;
 
562
               }
 
563
            }
 
564
            lFreeList(&selected_rqs_list);
 
565
            lFreeList(&rqs_list);
 
566
            rqs_list = found_rqs_list;
 
567
         } else {
 
568
            gdi_command = SGE_GDI_REPLACE;
 
569
         }
 
570
 
 
571
         if (rqs_list != NULL) {
 
572
            ret = rqs_add_del_mod_via_gdi(ctx, rqs_list, answer_list,
 
573
                                           gdi_command); 
 
574
         }
 
575
      }
 
576
      lFreeList(&rqs_list);
 
577
   }
 
578
   DRETURN(ret);
 
579
}