← Back to branch summary

~ubuntu-branches/ubuntu/vivid/slurm-llnl/vivid

« back to all changes in this revision

Viewing changes to src/scontrol/update_job.c

  • Committer: Bazaar Package Importer
  • Author(s): Gennaro Oliva
  • Date: 2009-09-24 23:28:15 UTC
  • mfrom: (1.1.11 upstream) (3.2.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090924232815-enh65jn32q1ebg07
Tags: 2.0.5-1
http://bugs.debian.org/541252
* New upstream release 
* Changed dependecy from lib-mysqlclient15 to lib-mysqlclient 
* Added Default-Start for runlevel 2 and 4 and $remote_fs requirement in
  init.d scripts (Closes: #541252)
* Postinst checks for wrong runlevels 2 and 4 links
* Upgraded to standard version 3.8.3
* Add lintian overrides for missing slurm-llnl-configurator.html in doc
  base registration
* modified postrm scripts to ignore pkill return value in order to avoid
  postrm failure when no slurm process is running
* Checking for slurmctld.pid before cancelling running and pending
  jobs during package removal 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/scontrol/update_job.c
2
2
 *  update_job.c - update job functions for scontrol.
3
3
 *****************************************************************************
4
4
 *  Copyright (C) 2002-2007 The Regents of the University of California.
5
 
 *  Copyright (C) 2008 Lawrence Livermore National Security.
 
5
 *  Copyright (C) 2008-2009 Lawrence Livermore National Security.
6
6
 *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
7
7
 *  Written by Morris Jette <jette1@llnl.gov>
8
 
 *  LLNL-CODE-402394.
 
8
 *  CODE-OCEC-09-009. All rights reserved.
9
9
 *  
10
10
 *  This file is part of SLURM, a resource management program.
11
 
 *  For details, see <http://www.llnl.gov/linux/slurm/>.
 
11
 *  For details, see <https://computing.llnl.gov/linux/slurm/>.
 
12
 *  Please also read the included file: DISCLAIMER.
12
13
 *  
13
14
 *  SLURM is free software; you can redistribute it and/or modify it under
14
15
 *  the terms of the GNU General Public License as published by the Free
38
39
 
39
40
#include "scontrol.h"
40
41
 
 
42
static int _parse_checkpoint_args(int argc, char **argv,
 
43
                                  uint16_t *max_wait, char **image_dir);
 
44
static int _parse_restart_args(int argc, char **argv,
 
45
                               uint16_t *stick, char **image_dir);
 
46
 
41
47
/* 
42
48
 * scontrol_checkpoint - perform some checkpoint/resume operation
43
49
 * IN op - checkpoint operation
44
50
 * IN job_step_id_str - either a job name (for all steps of the given job) or 
45
51
 *                      a step name: "<jid>.<step_id>"
 
52
 * IN argc - argument count
 
53
 * IN argv - arguments of the operation
46
54
 * RET 0 if no slurm error, errno otherwise. parsing error prints 
47
55
 *                      error message and returns 0
48
56
 */
49
57
extern int 
50
 
scontrol_checkpoint(char *op, char *job_step_id_str)
 
58
scontrol_checkpoint(char *op, char *job_step_id_str, int argc, char *argv[])
51
59
{
52
60
        int rc = SLURM_SUCCESS;
53
61
        uint32_t job_id = 0, step_id = 0, step_id_set = 0;
54
62
        char *next_str;
55
63
        uint32_t ckpt_errno;
56
64
        char *ckpt_strerror = NULL;
 
65
        int oplen = strlen(op);
 
66
        uint16_t max_wait = CKPT_WAIT, stick = 0;
 
67
        char *image_dir = NULL;
57
68
 
58
69
        if (job_step_id_str) {
59
70
                job_id = (uint32_t) strtol (job_step_id_str, &next_str, 10);
71
82
                return 0;
72
83
        }
73
84
 
74
 
        if (strncasecmp(op, "able", 2) == 0) {
 
85
        if (strncasecmp(op, "able", MAX(oplen, 1)) == 0) {
75
86
                time_t start_time;
76
87
                rc = slurm_checkpoint_able (job_id, step_id, &start_time);
77
88
                if (rc == SLURM_SUCCESS) {
78
89
                        if (start_time) {
79
 
                                char buf[128], time_str[32];
 
90
                                char time_str[32];
80
91
                                slurm_make_time_str(&start_time, time_str,
81
 
                                        sizeof(time_str));
82
 
                                snprintf(buf, sizeof(buf), 
83
 
                                        "Began at %s\n", time_str); 
84
 
                                printf(buf);
 
92
                                                    sizeof(time_str));
 
93
                                printf("Began at %s\n", time_str);
85
94
                        } else
86
95
                                printf("Yes\n");
87
96
                } else if (slurm_get_errno() == ESLURM_DISABLED) {
89
98
                        rc = SLURM_SUCCESS;     /* not real error */
90
99
                }
91
100
        }
92
 
        else if (strncasecmp(op, "complete", 3) == 0) {
 
101
        else if (strncasecmp(op, "complete", MAX(oplen, 2)) == 0) {
93
102
                /* Undocumented option used for testing purposes */
94
103
                static uint32_t error_code = 1;
95
104
                char error_msg[64];
97
106
                rc = slurm_checkpoint_complete(job_id, step_id, (time_t) 0,
98
107
                        error_code++, error_msg);
99
108
        }
100
 
        else if (strncasecmp(op, "disable", 3) == 0)
 
109
        else if (strncasecmp(op, "disable", MAX(oplen, 1)) == 0)
101
110
                rc = slurm_checkpoint_disable (job_id, step_id);
102
 
        else if (strncasecmp(op, "enable", 2) == 0)
 
111
        else if (strncasecmp(op, "enable", MAX(oplen, 2)) == 0)
103
112
                rc = slurm_checkpoint_enable (job_id, step_id);
104
 
        else if (strncasecmp(op, "create", 2) == 0)
105
 
                rc = slurm_checkpoint_create (job_id, step_id, CKPT_WAIT);
106
 
        else if (strncasecmp(op, "vacate", 2) == 0)
107
 
                rc = slurm_checkpoint_vacate (job_id, step_id, CKPT_WAIT);
108
 
        else if (strncasecmp(op, "restart", 2) == 0)
109
 
                rc = slurm_checkpoint_restart (job_id, step_id);
110
 
        else if (strncasecmp(op, "error", 2) == 0) {
 
113
        else if (strncasecmp(op, "create", MAX(oplen, 2)) == 0) {
 
114
                if (_parse_checkpoint_args(argc, argv, &max_wait, &image_dir)) {
 
115
                        return 0;
 
116
                }
 
117
                rc = slurm_checkpoint_create (job_id, step_id, max_wait, image_dir);
 
118
 
 
119
        } else if (strncasecmp(op, "vacate", MAX(oplen, 2)) == 0) {
 
120
                if (_parse_checkpoint_args(argc, argv, &max_wait, &image_dir)) {
 
121
                        return 0;
 
122
                }
 
123
                rc = slurm_checkpoint_vacate (job_id, step_id, max_wait, image_dir);
 
124
 
 
125
        } else if (strncasecmp(op, "restart", MAX(oplen, 2)) == 0) {
 
126
                if (_parse_restart_args(argc, argv, &stick, &image_dir)) {
 
127
                        return 0;
 
128
                }
 
129
                rc = slurm_checkpoint_restart (job_id, step_id, stick, image_dir);
 
130
 
 
131
        } else if (strncasecmp(op, "error", MAX(oplen, 2)) == 0) {
111
132
                rc = slurm_checkpoint_error (job_id, step_id, 
112
133
                        &ckpt_errno, &ckpt_strerror);
113
134
                if (rc == SLURM_SUCCESS) {
124
145
        return rc;
125
146
}
126
147
 
 
148
static int
 
149
_parse_checkpoint_args(int argc, char **argv, uint16_t *max_wait, char **image_dir)
 
150
{
 
151
        int i;
 
152
        
 
153
        for (i=0; i< argc; i++) {
 
154
                if (strncasecmp(argv[i], "MaxWait=", 8) == 0) {
 
155
                        *max_wait = (uint16_t) strtol(&argv[i][8], 
 
156
                                                      (char **) NULL, 10);
 
157
                } else if (strncasecmp(argv[i], "ImageDir=", 9) == 0) {
 
158
                        *image_dir = &argv[i][9];
 
159
                } else {
 
160
                        exit_code = 1;
 
161
                        error("Invalid input: %s", argv[i]);
 
162
                        error("Request aborted");
 
163
                        return -1;
 
164
                }
 
165
        }
 
166
        return 0;
 
167
}
 
168
 
 
169
static int
 
170
_parse_restart_args(int argc, char **argv, uint16_t *stick, char **image_dir)
 
171
{
 
172
        int i;
 
173
        
 
174
        for (i=0; i< argc; i++) {
 
175
                if (strncasecmp(argv[i], "StickToNodes", 5) == 0) {
 
176
                        *stick = 1;
 
177
                } else if (strncasecmp(argv[i], "ImageDir=", 9) == 0) {
 
178
                        *image_dir = &argv[i][9];
 
179
                } else {
 
180
                        exit_code = 1;
 
181
                        error("Invalid input: %s", argv[i]);
 
182
                        error("Request aborted");
 
183
                        return -1;
 
184
                }
 
185
        }
 
186
        return 0;
 
187
}
 
188
 
127
189
/*
128
190
 * scontrol_suspend - perform some suspend/resume operation
129
191
 * IN op - suspend/resume operation
151
213
                return 0;
152
214
        }
153
215
 
154
 
        if (strncasecmp(op, "suspend", 3) == 0)
 
216
        if (strncasecmp(op, "suspend", MAX(strlen(op), 2)) == 0)
155
217
                rc = slurm_suspend (job_id);
156
218
        else
157
219
                rc = slurm_resume (job_id);
201
263
scontrol_update_job (int argc, char *argv[]) 
202
264
{
203
265
        int i, update_cnt = 0;
 
266
        char *tag, *val;
 
267
        int taglen, vallen;
204
268
        job_desc_msg_t job_msg;
205
269
 
206
270
        slurm_init_job_desc_msg (&job_msg);     
207
271
 
208
272
        for (i=0; i<argc; i++) {
209
 
                if (strncasecmp(argv[i], "JobId=", 6) == 0)
 
273
                tag = argv[i];
 
274
                val = strchr(argv[i], '=');
 
275
                if (val) {
 
276
                        taglen = val - argv[i];
 
277
                        val++;
 
278
                        vallen = strlen(val);
 
279
                } else if (strncasecmp(tag, "Nice", MAX(strlen(tag), 2)) == 0) {
 
280
                        /* "Nice" is the only tag that might not have an 
 
281
                           equal sign, so it is handled specially. */
 
282
                        job_msg.nice = NICE_OFFSET + 100;
 
283
                        update_cnt++;
 
284
                        continue;
 
285
                } else {
 
286
                        exit_code = 1;
 
287
                        fprintf (stderr, "Invalid input: %s\n", argv[i]);
 
288
                        fprintf (stderr, "Request aborted\n");
 
289
                        return -1;
 
290
                }
 
291
 
 
292
                if (strncasecmp(tag, "JobId", MAX(taglen, 1)) == 0) {
210
293
                        job_msg.job_id = 
211
 
                                (uint32_t) strtol(&argv[i][6], 
212
 
                                                 (char **) NULL, 10);
213
 
                else if (strncasecmp(argv[i], "Comment=", 8) == 0) {
214
 
                        job_msg.comment = &argv[i][8];
 
294
                                (uint32_t) strtol(val, (char **) NULL, 10);
 
295
                }
 
296
                else if (strncasecmp(tag, "Comment", MAX(taglen, 3)) == 0) {
 
297
                        job_msg.comment = val;
215
298
                        update_cnt++;
216
 
                }
217
 
                else if (strncasecmp(argv[i], "TimeLimit=", 10) == 0) {
218
 
                        int time_limit = time_str2mins(&argv[i][10]);
 
299
                } 
 
300
                else if (strncasecmp(tag, "TimeLimit", MAX(taglen, 2)) == 0) {
 
301
                        int time_limit = time_str2mins(val);
219
302
                        if ((time_limit < 0) && (time_limit != INFINITE)) {
220
303
                                error("Invalid TimeLimit value");
221
304
                                exit_code = 1;
224
307
                        job_msg.time_limit = time_limit;
225
308
                        update_cnt++;
226
309
                }
227
 
                else if (strncasecmp(argv[i], "Priority=", 9) == 0) {
 
310
                else if (strncasecmp(tag, "Priority", MAX(taglen, 2)) == 0) {
228
311
                        job_msg.priority = 
229
 
                                (uint32_t) strtoll(&argv[i][9], 
230
 
                                                (char **) NULL, 10);
 
312
                                (uint32_t) strtoll(val, (char **) NULL, 10);
231
313
                        update_cnt++;
232
314
                }
233
 
                else if (strncasecmp(argv[i], "Nice=", 5) == 0) {
 
315
                else if (strncasecmp(tag, "Nice", MAX(taglen, 2)) == 0) {
234
316
                        int nice;
235
 
                        nice = strtoll(&argv[i][5], (char **) NULL, 10);
 
317
                        nice = strtoll(val, (char **) NULL, 10);
236
318
                        if (abs(nice) > NICE_OFFSET) {
237
319
                                error("Invalid nice value, must be between "
238
320
                                        "-%d and %d", NICE_OFFSET, NICE_OFFSET);
242
324
                        job_msg.nice = NICE_OFFSET + nice;
243
325
                        update_cnt++;
244
326
                }
245
 
                else if (strncasecmp(argv[i], "Nice", 4) == 0) {
246
 
                        job_msg.nice = NICE_OFFSET + 100;
247
 
                        update_cnt++;
248
 
                }               
249
 
                else if (strncasecmp(argv[i], "ReqProcs=", 9) == 0) {
 
327
                else if (strncasecmp(tag, "ReqProcs", MAX(taglen, 4)) == 0) {
250
328
                        job_msg.num_procs = 
251
 
                                (uint32_t) strtol(&argv[i][9], 
252
 
                                                (char **) NULL, 10);
 
329
                                (uint32_t) strtol(val, (char **) NULL, 10);
253
330
                        update_cnt++;
254
331
                }
255
 
                else if (strncasecmp(argv[i], "Requeue=", 8) == 0) {
 
332
                else if (strncasecmp(tag, "Requeue", MAX(taglen, 4)) == 0) {
256
333
                        job_msg.requeue = 
257
 
                                (uint16_t) strtol(&argv[i][8], 
258
 
                                                (char **) NULL, 10);
 
334
                                (uint16_t) strtol(val, (char **) NULL, 10);
259
335
                        update_cnt++;
260
336
                }
261
337
                /* MinNodes was replaced by ReqNodes in SLURM version 1.2 */
262
 
                else if ((strncasecmp(argv[i], "MinNodes=", 9) == 0) ||
263
 
                         (strncasecmp(argv[i], "ReqNodes=", 9) == 0)) {
 
338
                else if ((strncasecmp(tag, "MinNodes", MAX(taglen, 4)) == 0) ||
 
339
                         (strncasecmp(tag, "ReqNodes", MAX(taglen, 8)) == 0)) {
264
340
                        char *tmp;
265
 
                        job_msg.min_nodes = 
266
 
                                (uint32_t) strtol(&argv[i][9],
267
 
                                                 &tmp, 10);
 
341
                        job_msg.min_nodes = (uint32_t) strtol(val, &tmp, 10);
268
342
                        if (tmp[0] == '-') {
269
343
                                job_msg.max_nodes = (uint32_t)
270
344
                                        strtol(&tmp[1], (char **) NULL, 10);
273
347
                                                "minimum value (%u < %u)",
274
348
                                                job_msg.max_nodes,
275
349
                                                job_msg.min_nodes);
 
350
                                        exit_code = 1;
 
351
                                        return 0;
276
352
                                }
277
353
                        }
278
354
                        update_cnt++;
279
355
                }
280
 
                else if (strncasecmp(argv[i], "ReqSockets=", 11) == 0) {
 
356
                else if (strncasecmp(tag, "ReqSockets", MAX(taglen, 4)) == 0) {
281
357
                        job_msg.min_sockets = 
282
 
                                (uint16_t) strtol(&argv[i][11],
283
 
                                                 (char **) NULL, 10);
 
358
                                (uint16_t) strtol(val, (char **) NULL, 10);
284
359
                        update_cnt++;
285
360
                }
286
 
                else if (strncasecmp(argv[i], "ReqCores=", 9) == 0) {
 
361
                else if (strncasecmp(tag, "ReqCores", MAX(taglen, 4)) == 0) {
287
362
                        job_msg.min_cores = 
288
 
                                (uint16_t) strtol(&argv[i][9],
289
 
                                                 (char **) NULL, 10);
 
363
                                (uint16_t) strtol(val, (char **) NULL, 10);
290
364
                        update_cnt++;
291
365
                }
292
 
                else if (strncasecmp(argv[i], "TasksPerNode=", 13) == 0) {
 
366
                else if (strncasecmp(tag, "TasksPerNode", MAX(taglen, 2))==0) {
293
367
                        job_msg.ntasks_per_node =
294
 
                                (uint16_t) strtol(&argv[i][13],
295
 
                                                 (char **) NULL, 10);
 
368
                                (uint16_t) strtol(val, (char **) NULL, 10);
296
369
                        update_cnt++;
297
370
                }
298
 
                else if (strncasecmp(argv[i], "ReqThreads=", 11) == 0) {
 
371
                else if (strncasecmp(tag, "ReqThreads", MAX(taglen, 4)) == 0) {
299
372
                        job_msg.min_threads = 
300
 
                                (uint16_t) strtol(&argv[i][11],
301
 
                                                 (char **) NULL, 10);
 
373
                                (uint16_t) strtol(val, (char **) NULL, 10);
302
374
                        update_cnt++;
303
375
                }
304
 
                else if (strncasecmp(argv[i], "MinProcs=", 9) == 0) {
 
376
                else if (strncasecmp(tag, "MinProcs", MAX(taglen, 4)) == 0) {
305
377
                        job_msg.job_min_procs = 
306
 
                                (uint32_t) strtol(&argv[i][9], 
307
 
                                                (char **) NULL, 10);
 
378
                                (uint32_t) strtol(val, (char **) NULL, 10);
308
379
                        update_cnt++;
309
380
                }
310
 
                else if (strncasecmp(argv[i], "MinSockets=", 11) == 0) {
 
381
                else if (strncasecmp(tag, "MinSockets", MAX(taglen, 4)) == 0) {
311
382
                        job_msg.job_min_sockets = 
312
 
                                (uint16_t) strtol(&argv[i][11], 
313
 
                                                (char **) NULL, 10);
 
383
                                (uint16_t) strtol(val, (char **) NULL, 10);
314
384
                        update_cnt++;
315
385
                }
316
 
                else if (strncasecmp(argv[i], "MinCores=", 9) == 0) {
 
386
                else if (strncasecmp(tag, "MinCores", MAX(taglen, 4)) == 0) {
317
387
                        job_msg.job_min_cores = 
318
 
                                (uint16_t) strtol(&argv[i][9], 
319
 
                                                (char **) NULL, 10);
 
388
                                (uint16_t) strtol(val, (char **) NULL, 10);
320
389
                        update_cnt++;
321
390
                }
322
 
                else if (strncasecmp(argv[i], "MinThreads=", 11) == 0) {
 
391
                else if (strncasecmp(tag, "MinThreads", MAX(taglen, 5)) == 0) {
323
392
                        job_msg.job_min_threads = 
324
 
                                (uint16_t) strtol(&argv[i][11], 
325
 
                                                (char **) NULL, 10);
 
393
                                (uint16_t) strtol(val, (char **) NULL, 10);
326
394
                        update_cnt++;
327
395
                }
328
 
                else if (strncasecmp(argv[i], "MinMemoryNode=", 14) == 0) {
 
396
                else if (strncasecmp(tag, "MinMemoryNode", 
 
397
                                     MAX(taglen, 10)) == 0) {
329
398
                        job_msg.job_min_memory = 
330
 
                                (uint32_t) strtol(&argv[i][14], 
331
 
                                                (char **) NULL, 10);
 
399
                                (uint32_t) strtol(val, (char **) NULL, 10);
332
400
                        update_cnt++;
333
401
                }
334
 
                else if (strncasecmp(argv[i], "MinMemoryCPU=", 13) == 0) {
 
402
                else if (strncasecmp(tag, "MinMemoryCPU", 
 
403
                                     MAX(taglen, 10)) == 0) {
335
404
                        job_msg.job_min_memory =
336
 
                                (uint32_t) strtol(&argv[i][13],
337
 
                                                (char **) NULL, 10);
 
405
                                (uint32_t) strtol(val, (char **) NULL, 10);
338
406
                        job_msg.job_min_memory |= MEM_PER_CPU;
339
407
                        update_cnt++;
340
408
                }
341
 
                else if (strncasecmp(argv[i], "MinTmpDisk=", 11) == 0) {
 
409
                else if (strncasecmp(tag, "MinTmpDisk", MAX(taglen, 5)) == 0) {
342
410
                        job_msg.job_min_tmp_disk = 
343
 
                                (uint32_t) strtol(&argv[i][11], 
344
 
                                                (char **) NULL, 10);
345
 
                        update_cnt++;
346
 
                }
347
 
                else if (strncasecmp(argv[i], "Partition=", 10) == 0) {
348
 
                        job_msg.partition = &argv[i][10];
349
 
                        update_cnt++;
350
 
                }
351
 
                else if (strncasecmp(argv[i], "Name=", 5) == 0) {
352
 
                        job_msg.name = &argv[i][5];
353
 
                        update_cnt++;
354
 
                }
355
 
                else if (strncasecmp(argv[i], "Shared=", 7) == 0) {
356
 
                        if (strcasecmp(&argv[i][7], "YES") == 0)
 
411
                                (uint32_t) strtol(val, (char **) NULL, 10);
 
412
                        update_cnt++;
 
413
                }
 
414
                else if (strncasecmp(tag, "PartitionName", 
 
415
                                     MAX(taglen, 2)) == 0) {
 
416
                        job_msg.partition = val;
 
417
                        update_cnt++;
 
418
                }
 
419
                else if (strncasecmp(tag, "ReservationName", 
 
420
                                     MAX(taglen, 3)) == 0) {
 
421
                        job_msg.reservation = val;
 
422
                        update_cnt++;
 
423
                }
 
424
                else if (strncasecmp(tag, "Name", MAX(taglen, 2)) == 0) {
 
425
                        job_msg.name = val;
 
426
                        update_cnt++;
 
427
                }
 
428
                else if (strncasecmp(tag, "WCKey", MAX(taglen, 1)) == 0) {
 
429
                        job_msg.wckey = val;
 
430
                        update_cnt++;
 
431
                }
 
432
                else if (strncasecmp(tag, "Shared", MAX(taglen, 2)) == 0) {
 
433
                        if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0)
357
434
                                job_msg.shared = 1;
358
 
                        else if (strcasecmp(&argv[i][7], "NO") == 0)
 
435
                        else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0)
359
436
                                job_msg.shared = 0;
360
437
                        else
361
438
                                job_msg.shared = 
362
 
                                        (uint16_t) strtol(&argv[i][7], 
 
439
                                        (uint16_t) strtol(val, 
363
440
                                                        (char **) NULL, 10);
364
441
                        update_cnt++;
365
442
                }
366
 
                else if (strncasecmp(argv[i], "Contiguous=", 11) == 0) {
367
 
                        if (strcasecmp(&argv[i][11], "YES") == 0)
 
443
                else if (strncasecmp(tag, "Contiguous", MAX(taglen, 3)) == 0) {
 
444
                        if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0)
368
445
                                job_msg.contiguous = 1;
369
 
                        else if (strcasecmp(&argv[i][11], "NO") == 0)
 
446
                        else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0)
370
447
                                job_msg.contiguous = 0;
371
448
                        else
372
449
                                job_msg.contiguous = 
373
 
                                        (uint16_t) strtol(&argv[i][11], 
 
450
                                        (uint16_t) strtol(val, 
374
451
                                                        (char **) NULL, 10);
375
452
                        update_cnt++;
376
453
                }
377
 
                else if (strncasecmp(argv[i], "ExcNodeList=", 12) == 0) {
378
 
                        job_msg.exc_nodes = &argv[i][12];
379
 
                        update_cnt++;
380
 
                }
381
 
                else if (strncasecmp(argv[i], "ReqNodeList=", 12) == 0) {
382
 
                        job_msg.req_nodes = &argv[i][12];
383
 
                        update_cnt++;
384
 
                }
385
 
                else if (strncasecmp(argv[i], "Features=", 9) == 0) {
386
 
                        job_msg.features = &argv[i][9];
387
 
                        update_cnt++;
388
 
                }
389
 
                else if (strncasecmp(argv[i], "Account=", 8) == 0) {
390
 
                        job_msg.account = &argv[i][8];
391
 
                        update_cnt++;
392
 
                }
393
 
                else if (strncasecmp(argv[i], "Dependency=", 11) == 0) {
394
 
                        job_msg.dependency = &argv[i][11];
 
454
                else if (strncasecmp(tag, "ExcNodeList", MAX(taglen, 1)) == 0) {
 
455
                        job_msg.exc_nodes = val;
 
456
                        update_cnt++;
 
457
                }
 
458
                else if (strncasecmp(tag, "ReqNodeList", MAX(taglen, 8)) == 0) {
 
459
                        job_msg.req_nodes = val;
 
460
                        update_cnt++;
 
461
                }
 
462
                else if (strncasecmp(tag, "Features", MAX(taglen, 1)) == 0) {
 
463
                        job_msg.features = val;
 
464
                        update_cnt++;
 
465
                }
 
466
                else if (strncasecmp(tag, "Account", MAX(taglen, 1)) == 0) {
 
467
                        job_msg.account = val;
 
468
                        update_cnt++;
 
469
                }
 
470
                else if (strncasecmp(tag, "Dependency", MAX(taglen, 1)) == 0) {
 
471
                        job_msg.dependency = val;
395
472
                        update_cnt++;
396
473
                }
397
474
#ifdef HAVE_BG
398
 
                else if (strncasecmp(argv[i], "Geometry=", 9) == 0) {
 
475
                else if (strncasecmp(tag, "Geometry", MAX(taglen, 1)) == 0) {
399
476
                        char* token, *delimiter = ",x", *next_ptr;
400
477
                        int j, rc = 0;
401
478
                        uint16_t geo[SYSTEM_DIMENSIONS];
402
 
                        char* geometry_tmp = xstrdup(&argv[i][9]);
 
479
                        char* geometry_tmp = xstrdup(val);
403
480
                        char* original_ptr = geometry_tmp;
404
481
                        token = strtok_r(geometry_tmp, delimiter, &next_ptr);
405
482
                        for (j=0; j<SYSTEM_DIMENSIONS; j++) {
435
512
                        }
436
513
                }
437
514
 
438
 
                else if (strncasecmp(argv[i], "Rotate=", 7) == 0) {
 
515
                else if (strncasecmp(tag, "Rotate", MAX(taglen, 2)) == 0) {
439
516
                        uint16_t rotate;
440
 
                        if (strcasecmp(&argv[i][7], "yes") == 0)
 
517
                        if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0)
441
518
                                rotate = 1;
442
 
                        else if (strcasecmp(&argv[i][7], "no") == 0)
 
519
                        else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0)
443
520
                                rotate = 0;
444
521
                        else
445
 
                                rotate = (uint16_t) strtol(&argv[i][7], 
 
522
                                rotate = (uint16_t) strtol(val, 
446
523
                                                           (char **) NULL, 10);
447
524
                        job_msg.rotate = rotate;
448
525
                        update_cnt++;
449
526
                }
450
527
#endif
451
 
                else if (strncasecmp(argv[i], "Licenses=", 9) == 0) {
452
 
                        job_msg.licenses = &argv[i][9];
 
528
                else if (strncasecmp(tag, "Licenses", MAX(taglen, 1)) == 0) {
 
529
                        job_msg.licenses = val;
453
530
                        update_cnt++;
454
531
                }
455
 
                else if (strncasecmp(argv[i], "StartTime=", 10) == 0) {
456
 
                        job_msg.begin_time = parse_time(&argv[i][10], 0);
 
532
                else if (!strncasecmp(tag, "EligibleTime", MAX(taglen, 2)) ||
 
533
                         !strncasecmp(tag, "StartTime",    MAX(taglen, 2))) {
 
534
                        job_msg.begin_time = parse_time(val, 0);
457
535
                        update_cnt++;
458
536
                }
459
537
                else {
486
564
{
487
565
        int i;
488
566
        uint32_t job_id;
489
 
        char message[256];
 
567
        char *message = NULL;
490
568
 
491
569
        job_id = atoi(argv[0]);
492
570
        if (job_id <= 0) {
494
572
                return 1;
495
573
        }
496
574
 
497
 
        message[0] = '\0';
498
575
        for (i=1; i<argc; i++) {
499
 
                if (i > 1)
500
 
                        strncat(message, " ", sizeof(message));
501
 
                strncat(message, argv[i], sizeof(message));
 
576
                if (message)
 
577
                        xstrfmtcat(message, " %s", argv[i]);
 
578
                else
 
579
                        xstrcat(message, argv[i]);
502
580
        }
503
 
                        
504
 
        if (slurm_notify_job(job_id, message))
 
581
 
 
582
        i = slurm_notify_job(job_id, message);
 
583
        xfree(message);
 
584
 
 
585
        if (i)
505
586
                return slurm_get_errno ();
506
587
        else
507
588
                return 0;