← Back to branch summary

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

« back to all changes in this revision

Viewing changes to testsuite/expect/test25.1

  • 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:
testsuite/expect/test25.1
 
1
#!/usr/bin/expect
 
2
############################################################################
 
3
# Purpose: Test of SLURM sprio functionality.
 
4
#
 
5
#          sprio all options all arguments
 
6
#
 
7
# Output:  "TEST: #.#" followed by "SUCCESS" if test was successful, OR
 
8
#          "FAILURE: ..." otherwise with an explanation of the failure, OR
 
9
#          anything else indicates a failure mode that must be investigated.
 
10
############################################################################
 
11
# Copyright (C) 2009 Lawrence Livermore National Security.
 
12
# Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
 
13
# Written by Joseph Donaghy <donaghy1@llnl.gov>
 
14
# CODE-OCEC-09-009. All rights reserved.
 
15
# 
 
16
# This file is part of SLURM, a resource management program.
 
17
# For details, see <https://computing.llnl.gov/linux/slurm/>.
 
18
# Please also read the included file: DISCLAIMER.
 
19
#  
 
20
# SLURM is free software; you can redistribute it and/or modify it under
 
21
# the terms of the GNU General Public License as published by the Free
 
22
# Software Foundation; either version 2 of the License, or (at your option)
 
23
# any later version.
 
24
# 
 
25
# SLURM is distributed in the hope that it will be useful, but WITHOUT ANY
 
26
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
27
# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 
28
# details.
 
29
# 
 
30
# You should have received a copy of the GNU General Public License along
 
31
# with SLURM; if not, write to the Free Software Foundation, Inc.,
 
32
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA.
 
33
############################################################################
 
34
source ./globals
 
35
 
 
36
set test_id     "25.1"
 
37
set exit_code   0
 
38
set file_in     "test$test_id.input"
 
39
set timeout     60
 
40
print_header    $test_id
 
41
 
 
42
#
 
43
# Check accounting config and bail if not found.
 
44
#
 
45
if { [test_account_storage] == 0 } {
 
46
        send_user "\nWARNING: This test can't be run without a usable AccountStorageType\n"
 
47
        exit 0
 
48
}
 
49
if { [string compare [priority_type] multifactor] } {
 
50
        send_user "\nWARNING: This test can't be run without a usable PriorityType\n"
 
51
        exit 0
 
52
}
 
53
 
 
54
#
 
55
# Build input script file
 
56
#
 
57
make_bash_script $file_in "$bin_sleep 600"
 
58
 
 
59
proc def_node_cnt { } {
 
60
        global sinfo alpha_numeric_under number exit_code
 
61
 
 
62
        set node_cnt 1
 
63
        spawn $sinfo -h -o "name=%20P node_cnt=%D"
 
64
        expect {
 
65
                -re "name=($alpha_numeric_under)\\\* *node_cnt=($number)" {
 
66
                        set node_cnt $expect_out(2,string) 
 
67
                        exp_continue
 
68
                }
 
69
                timeout {
 
70
                        send_user "\nFAILURE: sbatch not responding\n"
 
71
                        set exit_code 1
 
72
                }
 
73
                eof {
 
74
                        wait
 
75
                }
 
76
        }
 
77
        return $node_cnt
 
78
}
 
79
 
 
80
################################################################
 
81
#
 
82
# Proc: sub_job
 
83
#
 
84
# Purpose:  Submit a job
 
85
#
 
86
# Returns: Job ID
 
87
#
 
88
################################################################
 
89
 
 
90
proc sub_job { node_cnt } {
 
91
 
 
92
        global exit_code file_in number sbatch test_id
 
93
        set file_in     test${test_id}.input
 
94
 
 
95
        set job_id      0
 
96
        spawn $sbatch --output=/dev/null --error=/dev/null -N $node_cnt --exclusive $file_in
 
97
        expect {
 
98
                -re "Submitted batch job ($number)" {
 
99
                        set job_id $expect_out(1,string) 
 
100
                        exp_continue
 
101
                }
 
102
                timeout {
 
103
                        send_user "\nFAILURE: sbatch not responding\n"
 
104
                        set exit_code 1
 
105
                }
 
106
                eof {
 
107
                        wait
 
108
                }
 
109
        }
 
110
 
 
111
        if {$job_id == 0} {
 
112
                send_user "\nFAILURE: did not get sbatch job_id\n"
 
113
                set exit_code 1
 
114
        }
 
115
        return $job_id
 
116
}
 
117
 
 
118
################################################################
 
119
#
 
120
# Proc: sprio_opt
 
121
#
 
122
# Purpose:  Pass sprio options and test
 
123
#
 
124
# Returns: Number of matches.
 
125
#
 
126
# Input: Switch options not requiring arguments
 
127
#
 
128
################################################################
 
129
 
 
130
proc sprio_opt { soption } {
 
131
        global number sprio exit_code
 
132
        set debug       0
 
133
        set matches     0
 
134
        set not_support 0
 
135
        send_user "$sprio $soption \n"
 
136
 
 
137
############# sprio help option
 
138
        if { $soption == "--help" } {
 
139
 
 
140
                spawn $sprio $soption
 
141
                expect {
 
142
                        -re "SLURM accounting storage is disabled" {
 
143
                                set not_support 1
 
144
                                exp_continue
 
145
                        }
 
146
                        -re "noheader.*jobs.*long.*norm.*format.*user.*verbose.*version.*weights" {
 
147
                                if {$debug} {send_user "\nmatch1\n"}
 
148
                                incr matches
 
149
                                exp_continue
 
150
                        }
 
151
                        -re "Help options:" {
 
152
                                if {$debug} {send_user "\nmatch2\n"}
 
153
                                incr matches
 
154
                                exp_continue
 
155
                        }
 
156
                        -re "help *show this help message" {
 
157
                                if {$debug} {send_user "\nmatch3\n"}
 
158
                                incr matches
 
159
                                exp_continue
 
160
                        }
 
161
                        -re "usage *display a brief summary of sprio options" {
 
162
                                if {$debug} {send_user "\nmatch4\n"}
 
163
                                incr matches
 
164
                                exp_continue
 
165
                        }
 
166
                        timeout {
 
167
                                send_user "\nFAILURE: sprio not responding\n"
 
168
                                set exit_code 1
 
169
                        }
 
170
                        eof {
 
171
                                wait
 
172
                        }
 
173
                }
 
174
 
 
175
                if {$not_support == 1} {
 
176
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
177
                        exit 0
 
178
                }
 
179
 
 
180
                if {$matches != 4} {
 
181
                        send_user "\nFAILURE: sprio $soption failed ($matches)\n"
 
182
                        set exit_code 1
 
183
                }
 
184
        return $matches
 
185
        }
 
186
 
 
187
############# sprio usage option
 
188
        if { $soption == "--usage" } {
 
189
 
 
190
                spawn $sprio $soption job sizes
 
191
                expect {
 
192
                        -re "SLURM accounting storage is disabled" {
 
193
                                set not_support 1
 
194
                                exp_continue
 
195
                        }
 
196
                        -re "Usage: sprio .-j jid.s.. .-u user_name.s.. .-o format. .--usage. .-hlnvVw." {      
 
197
                                if {$debug} {send_user "\nmatch5\n"}
 
198
                                incr matches
 
199
                                exp_continue
 
200
                        }
 
201
                        timeout {
 
202
                                send_user "\nFAILURE: sprio not responding\n"
 
203
                                set exit_code 1
 
204
                        }
 
205
                        eof {
 
206
                                wait
 
207
                        }
 
208
                }
 
209
 
 
210
                if {$not_support == 1} {
 
211
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
212
                        exit 0
 
213
                }
 
214
                if {$matches != 1} {
 
215
                        send_user "\nFAILURE: sprio -$soption failed ($matches)\n"
 
216
                        set exit_code 1
 
217
                }
 
218
                return $matches
 
219
        }
 
220
 
 
221
############# sprio version options
 
222
        if { $soption == "--version" || $soption == "-V" } {
 
223
 
 
224
                spawn $sprio $soption
 
225
                expect {
 
226
                        -re "SLURM accounting storage is disabled" {
 
227
                                set not_support 1
 
228
                                exp_continue
 
229
                        }
 
230
                        -re "slurm $number.$number.$number" {
 
231
                                if {$debug} {send_user "\nmatch6\n"}
 
232
                                incr matches
 
233
                                exp_continue
 
234
                        }
 
235
                        timeout {
 
236
                                send_user "\nFAILURE: sprio not responding\n"
 
237
                                set exit_code 1
 
238
                        }
 
239
                        eof {
 
240
                                wait
 
241
                        }
 
242
                }
 
243
 
 
244
                if {$not_support == 1} {
 
245
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
246
                        exit 0
 
247
                }
 
248
 
 
249
                if {$matches != 1} {
 
250
                        send_user "\nFAILURE: sprio -$soption failed ($matches)\n"
 
251
                        set exit_code 1
 
252
                }
 
253
                return $matches
 
254
        }
 
255
 
 
256
############# sprio weights options
 
257
        if { $soption == "--weights" || $soption == "-w" } {
 
258
 
 
259
                spawn $sprio $soption
 
260
                expect {
 
261
                        -re "SLURM accounting storage is disabled" {
 
262
                                set not_support 1
 
263
                                exp_continue
 
264
                        }
 
265
                        -re "JOBID *PRIORITY" {
 
266
                                if {$debug} {send_user "\nmatch7\n"}
 
267
                                incr matches
 
268
                                exp_continue
 
269
                        }
 
270
                        -re "Weights" {
 
271
                                if {$debug} {send_user "\nmatch8\n"}
 
272
                                incr matches
 
273
                                exp_continue
 
274
                        }
 
275
                        timeout {
 
276
                                send_user "\nFAILURE: sprio not responding\n"
 
277
                                set exit_code 1
 
278
                        }
 
279
                        eof {
 
280
                                wait
 
281
                        }
 
282
                }
 
283
 
 
284
                if {$not_support == 1} {
 
285
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
286
                        exit 0
 
287
                }
 
288
 
 
289
                if {$matches != 2} {
 
290
                        send_user "\nFAILURE: sprio -$soption failed ($matches)\n"
 
291
                        set exit_code 1
 
292
                }
 
293
                return $matches
 
294
        }
 
295
}
 
296
 
 
297
################################################################
 
298
#
 
299
# Proc: sprio_args
 
300
#
 
301
# Purpose:  Pass sprio options, arguments and test
 
302
#
 
303
# Returns: Number of matches.
 
304
#
 
305
# Input: Switch options requiring arguments
 
306
#
 
307
################################################################
 
308
 
 
309
proc sprio_args { soption sargs jobid} {
 
310
        global number float sprio exit_code
 
311
        set debug       0
 
312
        set matches     0
 
313
        set not_support 0
 
314
        send_user "$sprio $soption $sargs $jobid\n"
 
315
 
 
316
############# sprio noheader options
 
317
        if { $soption == "--noheader" || $soption == "-h" } {
 
318
 
 
319
                spawn $sprio $soption $sargs $jobid
 
320
                expect {
 
321
                        -re "SLURM accounting storage is disabled" {
 
322
                                set not_support 1
 
323
                                exp_continue
 
324
                        }
 
325
                        -re "JOBID|PRIORITY|AGE|FAIRSHARE|JOBSIZE|PARTITION|QOS" {      
 
326
                                if {$debug} {send_user "\nmatch9\n"}
 
327
                                incr matches
 
328
                                exp_continue
 
329
                        }
 
330
                        timeout {
 
331
                                send_user "\nFAILURE: sprio not responding\n"
 
332
                                set exit_code 1
 
333
                        }
 
334
                        eof {
 
335
                                wait
 
336
                        }
 
337
                }
 
338
 
 
339
                if {$not_support == 1} {
 
340
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
341
                        exit 0
 
342
                }
 
343
                if {$matches != 0} {
 
344
                        send_user "\nFAILURE: sprio $soption failed ($matches)\n"
 
345
                        set exit_code 1
 
346
                }
 
347
                return $matches
 
348
        }
 
349
 
 
350
############# sprio jobs options
 
351
        if { $soption == "--jobs" || $soption == "-j" } {
 
352
 
 
353
                spawn $sprio $soption $jobid
 
354
                expect {
 
355
                        -re "SLURM accounting storage is disabled" {
 
356
                                set not_support 1
 
357
                                exp_continue
 
358
                        }
 
359
                        -re "JOBID.*PRIORITY" { 
 
360
                                if {$debug} {send_user "\nmatch10\n"}
 
361
                                incr matches
 
362
                                exp_continue
 
363
                        }
 
364
                        -re "$jobid *$number" { 
 
365
                                if {$debug} {send_user "\nmatch11\n"}
 
366
                                incr matches
 
367
                                exp_continue
 
368
                        }
 
369
                        timeout {
 
370
                                send_user "\nFAILURE: sprio not responding\n"
 
371
                                set exit_code 1
 
372
                        }
 
373
                        eof {
 
374
                                wait
 
375
                        }
 
376
                }
 
377
 
 
378
                if {$not_support == 1} {
 
379
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
380
                        exit 0
 
381
                }
 
382
                if {$matches != 2} {
 
383
                        send_user "\nFAILURE: sprio $soption failed ($matches)\n"
 
384
                        set exit_code 1
 
385
                }
 
386
                return $matches
 
387
        }
 
388
 
 
389
############# sprio long options
 
390
        if { $soption == "--long" || $soption == "-l" } {
 
391
 
 
392
                spawn $sprio $soption $sargs $jobid
 
393
                expect {
 
394
                        -re "SLURM accounting storage is disabled" {
 
395
                                set not_support 1
 
396
                                exp_continue
 
397
                        }
 
398
                        -re "JOBID     USER   PRIORITY        AGE  FAIRSHARE    JOBSIZE  PARTITION        QOS   NICE" { 
 
399
                                if {$debug} {send_user "\nmatch12\n"}
 
400
                                incr matches
 
401
                                exp_continue
 
402
                        }
 
403
                        -re "$jobid.*$number *$number *$number *$number *$number *$number *$number" {   
 
404
                                if {$debug} {send_user "\nmatch13\n"}
 
405
                                incr matches
 
406
                                exp_continue
 
407
                        }
 
408
                        timeout {
 
409
                                send_user "\nFAILURE: sprio not responding\n"
 
410
                                set exit_code 1
 
411
                        }
 
412
                        eof {
 
413
                                wait
 
414
                        }
 
415
                }
 
416
 
 
417
                if {$not_support == 1} {
 
418
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
419
                        exit 0
 
420
                }
 
421
                if {$matches != 2} {
 
422
                        send_user "\nFAILURE: sprio $soption failed ($matches)\n"
 
423
                        set exit_code 1
 
424
                }
 
425
                return $matches
 
426
        }
 
427
 
 
428
############# sprio norm options
 
429
        if { $soption == "--norm" || $soption == "-n" } {
 
430
 
 
431
                spawn $sprio $soption $sargs $jobid
 
432
                expect {
 
433
                        -re "SLURM accounting storage is disabled" {
 
434
                                set not_support 1
 
435
                                exp_continue
 
436
                        }
 
437
                        -re "JOBID *PRIORITY" { 
 
438
                                if {$debug} {send_user "\nmatch14\n"}
 
439
                                incr matches
 
440
                                exp_continue
 
441
                        }
 
442
                        -re "$jobid *$float" {  
 
443
                                if {$debug} {send_user "\nmatch15\n"}
 
444
                                incr matches
 
445
                                exp_continue
 
446
                        }
 
447
                        timeout {
 
448
                                send_user "\nFAILURE: sprio not responding\n"
 
449
                                set exit_code 1
 
450
                        }
 
451
                        eof {
 
452
                                wait
 
453
                        }
 
454
                }
 
455
 
 
456
                if {$not_support == 1} {
 
457
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
458
                        exit 0
 
459
                }
 
460
                if {$matches != 2} {
 
461
                        send_user "\nFAILURE: sprio $soption failed ($matches)\n"
 
462
                        set exit_code 1
 
463
                }
 
464
                return $matches
 
465
        }
 
466
 
 
467
############# sprio format options
 
468
        if { $soption == "--format" || $soption == "-o" } {
 
469
 
 
470
                spawn $sprio $soption "%.7i %.8u %.10y %.10Y %.10a %.10A %.10f %.10F %.10j %.10J %.10p %.10P %.10q %.10Q %.6N" $sargs $jobid
 
471
                expect {
 
472
                        -re "SLURM accounting storage is disabled" {
 
473
                                set not_support 1
 
474
                                exp_continue
 
475
                        }
 
476
                        -re "JOBID     USER   PRIORITY   PRIORITY        AGE        AGE  " {
 
477
                                if {$debug} {send_user "\nmatch16\n"}
 
478
                                incr matches
 
479
                                exp_continue
 
480
                        }
 
481
                        -re "FAIRSHARE  FAIRSHARE    JOBSIZE    JOBSIZE  PARTITION  PARTITION        QOS        QOS   NICE" {
 
482
                                if {$debug} {send_user "\nmatch17\n"}
 
483
                                incr matches
 
484
                                exp_continue
 
485
                        }
 
486
                        -re "$jobid *.* *$float *$number *$float *$number *$float *$number *$float *$number *$float *$number *$float *$number *$number" {       
 
487
                                if {$debug} {send_user "\nmatch18\n"}
 
488
                                incr matches
 
489
                                exp_continue
 
490
                        }
 
491
                        timeout {
 
492
                                send_user "\nFAILURE: sprio not responding\n"
 
493
                                set exit_code 1
 
494
                        }
 
495
                        eof {
 
496
                                wait
 
497
                        }
 
498
                }
 
499
 
 
500
                if {$not_support == 1} {
 
501
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
502
                        exit 0
 
503
                }
 
504
                if {$matches != 3} {
 
505
                        send_user "\nFAILURE: sprio $soption failed ($matches)\n"
 
506
                        set exit_code 1
 
507
                }
 
508
                return $matches
 
509
        }
 
510
 
 
511
############# sprio u option
 
512
        if { $soption == "-u" } {
 
513
 
 
514
                spawn $sprio $soption $sargs
 
515
                expect {
 
516
                        -re "SLURM accounting storage is disabled" {
 
517
                                set not_support 1
 
518
                                exp_continue
 
519
                        }
 
520
                        -re "JOBID *USER" {     
 
521
                                if {$debug} {send_user "\nmatch19\n"}
 
522
                                incr matches
 
523
                                exp_continue
 
524
                        }
 
525
                        -re "$jobid *$sargs" {  
 
526
                                if {$debug} {send_user "\nmatch20\n"}
 
527
                                incr matches
 
528
                                exp_continue
 
529
                        }
 
530
                        timeout {
 
531
                                send_user "\nFAILURE: sprio not responding\n"
 
532
                                set exit_code 1
 
533
                        }
 
534
                        eof {
 
535
                                wait
 
536
                        }
 
537
                }
 
538
 
 
539
                if {$not_support == 1} {
 
540
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
541
                        exit 0
 
542
                }
 
543
                if {$matches != 2} {
 
544
                        send_user "\nFAILURE: sprio $soption failed ($matches)\n"
 
545
                        set exit_code 1
 
546
                }
 
547
                return $matches
 
548
        }
 
549
 
 
550
############# sprio usage option
 
551
        if { $soption == "--user=" } {
 
552
 
 
553
                spawn $sprio $soption$sargs
 
554
                expect {
 
555
                        -re "SLURM accounting storage is disabled" {
 
556
                                set not_support 1
 
557
                                exp_continue
 
558
                        }
 
559
                        -re "JOBID *USER" {     
 
560
                                if {$debug} {send_user "\nmatch21\n"}
 
561
                                incr matches
 
562
                                exp_continue
 
563
                        }
 
564
                        -re "$jobid *$sargs" {  
 
565
                                if {$debug} {send_user "\nmatch22\n"}
 
566
                                incr matches
 
567
                                exp_continue
 
568
                        }
 
569
                        timeout {
 
570
                                send_user "\nFAILURE: sprio not responding\n"
 
571
                                set exit_code 1
 
572
                        }
 
573
                        eof {
 
574
                                wait
 
575
                        }
 
576
                }
 
577
 
 
578
                if {$not_support == 1} {
 
579
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
580
                        exit 0
 
581
                }
 
582
                if {$matches != 2} {
 
583
                        send_user "\nFAILURE: sprio $soption failed ($matches)\n"
 
584
                        set exit_code 1
 
585
                }
 
586
                return $matches
 
587
        }
 
588
 
 
589
############# sprio verbose options
 
590
        if { $soption == "--verbose" || $soption == "-v" } {
 
591
 
 
592
                spawn $sprio $soption $sargs $jobid
 
593
                expect {
 
594
                        -re "SLURM accounting storage is disabled" {
 
595
                                set not_support 1
 
596
                                exp_continue
 
597
                        }
 
598
                        -re "format.*job_flag.*jobs.*$jobid.*verbose" { 
 
599
                                if {$debug} {send_user "\nmatch23\n"}
 
600
                                incr matches
 
601
                                exp_continue
 
602
                        }
 
603
                        -re "JOBID *PRIORITY" { 
 
604
                                if {$debug} {send_user "\nmatch24\n"}
 
605
                                incr matches
 
606
                                exp_continue
 
607
                        }
 
608
                        -re "$jobid *$number *$number" {        
 
609
                                if {$debug} {send_user "\nmatch25\n"}
 
610
                                incr matches
 
611
                                exp_continue
 
612
                        }
 
613
                        timeout {
 
614
                                send_user "\nFAILURE: sprio not responding\n"
 
615
                                set exit_code 1
 
616
                        }
 
617
                        eof {
 
618
                                wait
 
619
                        }
 
620
                }
 
621
 
 
622
                if {$not_support == 1} {
 
623
                        send_user "\nWARNING: can not test without accounting enabled\n"
 
624
                        exit 0
 
625
                }
 
626
                if {$matches != 3} {
 
627
                        send_user "\nFAILURE: sprio $soption failed ($matches)\n"
 
628
                        set exit_code 1
 
629
                }
 
630
                return $matches
 
631
        }
 
632
 
 
633
}
 
634
 
 
635
################################################################
 
636
# Start a group of jobs
 
637
 
 
638
set node_cnt [def_node_cnt]
 
639
set jobid1 [sub_job $node_cnt]
 
640
set jobid2 [sub_job $node_cnt]
 
641
if {$exit_code != 0} {
 
642
        cancel_job $jobid1
 
643
        cancel_job $jobid2
 
644
        exit $exit_code
 
645
}
 
646
send_user "\nSubmitted 2 jobs successfully\n\n"
 
647
 
 
648
#
 
649
# Collect uid
 
650
#
 
651
set nuid [get_my_nuid]
 
652
 
 
653
#
 
654
# Start testing sprio options and arguments
 
655
#
 
656
sprio_args -h -j $jobid2
 
657
sprio_args --noheader -j $jobid2
 
658
sprio_args -j -j $jobid2
 
659
sprio_args --jobs -j $jobid2
 
660
sprio_args -l -j $jobid2
 
661
sprio_args --long -j $jobid2
 
662
sprio_args -n -j $jobid2
 
663
sprio_args --norm -j $jobid2
 
664
sprio_args -o -j $jobid2
 
665
sprio_args --format -j $jobid2
 
666
sprio_args -u $nuid $jobid2
 
667
sprio_args --user= $nuid $jobid2
 
668
sprio_args -v -j $jobid2
 
669
sprio_args -verbose -j $jobid2
 
670
sprio_opt -V
 
671
sprio_opt --version
 
672
sprio_opt -w
 
673
sprio_opt --weights
 
674
sprio_opt --help
 
675
sprio_opt --usage
 
676
 
 
677
#
 
678
# Cancel jobs
 
679
#
 
680
cancel_job $jobid1 
 
681
cancel_job $jobid2
 
682
 
 
683
#
 
684
# Exit with code as appropriate
 
685
#
 
686
if {$exit_code == 0} {
 
687
        exec $bin_rm -f $file_in
 
688
        send_user "\nSUCCESS\n"
 
689
}
 
690
exit $exit_code