source: trunk/pbs_drmaa/submit.c @ 85

Revision 85, 22.4 KB checked in by mmamonski, 11 years ago (diff)

PBS DRMAA autoclose connection

  • Property svn:keywords set to Id
Line 
1/* $Id$ */
2/*
3 *  FedStage DRMAA for PBS Pro
4 *  Copyright (C) 2006-2009  FedStage Systems
5 *
6 *  This program is free software: you can redistribute it and/or modify
7 *  it under the terms of the GNU General Public License as published by
8 *  the Free Software Foundation, either version 3 of the License, or
9 *  (at your option) any later version.
10 *
11 *  This program is distributed in the hope that it will be useful,
12 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 *  GNU General Public License for more details.
15 *
16 *  You should have received a copy of the GNU General Public License
17 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20#ifdef HAVE_CONFIG_H
21#       include <config.h>
22#endif
23
24#include <unistd.h>
25#include <string.h>
26#include <stdlib.h>
27
28#include <pbs_ifl.h>
29#include <pbs_error.h>
30
31#include <drmaa_utils/conf.h>
32#include <drmaa_utils/exec.h>
33#include <drmaa_utils/drmaa.h>
34#include <drmaa_utils/drmaa_util.h>
35#include <drmaa_utils/datetime.h>
36#include <drmaa_utils/iter.h>
37#include <drmaa_utils/template.h>
38#include <pbs_drmaa/pbs_attrib.h>
39#include <pbs_drmaa/session.h>
40#include <pbs_drmaa/submit.h>
41#include <pbs_drmaa/util.h>
42
43
44
45#ifndef lint
46static char rcsid[]
47#       ifdef __GNUC__
48                __attribute__ ((unused))
49#       endif
50        = "$Id$";
51#endif
52
53static void pbsdrmaa_submit_destroy( pbsdrmaa_submit_t *self );
54
55static char *pbsdrmaa_submit_submit( pbsdrmaa_submit_t *self );
56
57static void pbsdrmaa_submit_eval( pbsdrmaa_submit_t *self );
58
59static void pbsdrmaa_submit_set( pbsdrmaa_submit_t *self, const char *pbs_attr, char *value, unsigned placeholders );
60
61static struct attrl *pbsdrmaa_submit_filter(struct attrl *pbs_attr);
62
63
64static void pbsdrmaa_submit_apply_defaults( pbsdrmaa_submit_t *self );
65static void pbsdrmaa_submit_apply_job_script( pbsdrmaa_submit_t *self );
66static void pbsdrmaa_submit_apply_job_state( pbsdrmaa_submit_t *self );
67static void pbsdrmaa_submit_apply_job_files( pbsdrmaa_submit_t *self );
68static void pbsdrmaa_submit_apply_file_staging( pbsdrmaa_submit_t *self );
69static void pbsdrmaa_submit_apply_job_resources( pbsdrmaa_submit_t *self );
70static void pbsdrmaa_submit_apply_job_environment( pbsdrmaa_submit_t *self );
71static void pbsdrmaa_submit_apply_email_notification( pbsdrmaa_submit_t *self );
72static void pbsdrmaa_submit_apply_job_category( pbsdrmaa_submit_t *self );
73
74
75pbsdrmaa_submit_t *
76pbsdrmaa_submit_new( fsd_drmaa_session_t *session,
77                const fsd_template_t *job_template, int bulk_idx )
78{
79        pbsdrmaa_submit_t *volatile self = NULL;
80        TRY
81         {
82                fsd_malloc( self, pbsdrmaa_submit_t );
83                self->session = session;
84                self->job_template = job_template;
85                self->script_filename = NULL;
86                self->destination_queue = NULL;
87                self->pbs_job_attributes = NULL;
88                self->expand_ph = NULL;
89                self->destroy = pbsdrmaa_submit_destroy;
90                self->submit = pbsdrmaa_submit_submit;
91                self->eval = pbsdrmaa_submit_eval;
92                self->set = pbsdrmaa_submit_set;
93                self->apply_defaults = pbsdrmaa_submit_apply_defaults;
94                self->apply_job_category = pbsdrmaa_submit_apply_job_category;
95                self->apply_job_script = pbsdrmaa_submit_apply_job_script;
96                self->apply_job_state = pbsdrmaa_submit_apply_job_state;
97                self->apply_job_files = pbsdrmaa_submit_apply_job_files;
98                self->apply_file_staging = pbsdrmaa_submit_apply_file_staging;
99                self->apply_job_resources = pbsdrmaa_submit_apply_job_resources;
100                self->apply_job_environment = pbsdrmaa_submit_apply_job_environment;
101                self->apply_email_notification = pbsdrmaa_submit_apply_email_notification;
102                self->apply_native_specification = pbsdrmaa_submit_apply_native_specification;
103
104                self->pbs_job_attributes = pbsdrmaa_pbs_template_new();
105                self->expand_ph = fsd_expand_drmaa_ph_new( NULL, NULL,
106                                (bulk_idx >= 0) ? fsd_asprintf("%d", bulk_idx) : NULL );
107         }
108        EXCEPT_DEFAULT
109         {
110                if( self )
111                        self->destroy( self );
112         }
113        END_TRY
114        return self;
115}
116
117
118void
119pbsdrmaa_submit_destroy( pbsdrmaa_submit_t *self )
120{
121        if( self->script_filename )
122         {
123                unlink( self->script_filename );
124                fsd_free( self->script_filename );
125         }
126        if( self->pbs_job_attributes )
127                self->pbs_job_attributes->destroy( self->pbs_job_attributes );
128        if( self->expand_ph )
129                self->expand_ph->destroy( self->expand_ph );
130        fsd_free( self->destination_queue );
131        fsd_free( self );
132}
133
134
135char *
136pbsdrmaa_submit_submit( pbsdrmaa_submit_t *self )
137{
138        struct attrl *volatile pbs_attr = NULL;
139        char *volatile job_id = NULL;
140        TRY
141         {
142                fsd_template_t *pbs_tmpl = self->pbs_job_attributes;
143                int i;
144
145                for( i = PBSDRMAA_N_PBS_ATTRIBUTES - 1; i >= 0; i-- ) /* down loop -> start with custom resources */
146                 {
147                        const char *name = pbs_tmpl->by_code( pbs_tmpl, i )->name;
148                        const char *value = pbs_tmpl->get_attr( pbs_tmpl, name );
149
150                        if (!value)
151                                continue;
152
153                        if ( i == PBSDRMAA_ATTR_CUSTOM_RESOURCES)
154                         {
155                                char *value_copy = fsd_strdup(value);
156                                char *tok_comma_ctx = NULL;
157                                char *res_token = NULL;
158                                /* matlab:2,simulink:1 */
159
160                                for (res_token = strtok_r(value_copy, ";", &tok_comma_ctx); res_token; res_token = strtok_r(NULL, ";", &tok_comma_ctx))
161                                 {
162                                        char *value_p = strstr(res_token, ":");
163
164                                        if (value_p)
165                                         {
166                                                char *name_p = NULL;
167                                                *value_p = '\0';
168                                                value_p++;
169                                                name_p = fsd_asprintf("Resource_List.%s",res_token);
170                                                pbs_attr = pbsdrmaa_add_attr( pbs_attr, name_p, value_p );
171                                                fsd_free(name_p);
172                                         }
173                                        else
174                                         {
175                                                fsd_exc_raise_code( FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE );
176                                         }
177                                 }
178
179                                fsd_free(value_copy);
180                         }
181                        else if (i == PBSDRMAA_ATTR_NODE_PROPERTIES)
182                         {
183                                const char *nodes_value = pbs_tmpl->get_attr( pbs_tmpl, PBSDRMAA_NODES );
184                                char *final_value = NULL;
185
186                                if (nodes_value)
187                                 {
188                                        final_value = fsd_asprintf("%s:%s",nodes_value, value);
189                                 }
190                                else
191                                 {
192                                        final_value = fsd_asprintf("1:%s", value);
193                                 }
194
195                                pbs_tmpl->set_attr( pbs_tmpl, PBSDRMAA_NODES, final_value);
196                                fsd_free(final_value);
197                         }
198                        else
199                         {
200                                pbs_attr = pbsdrmaa_add_attr( pbs_attr, name, value );
201                         }
202                 }
203
204
205                pbs_attr = pbsdrmaa_submit_filter(pbs_attr);
206
207                job_id = ((pbsdrmaa_session_t *)self->session)->pbs_connection->submit( ((pbsdrmaa_session_t *)self->session)->pbs_connection, (struct attropl*)pbs_attr, self->script_filename, self->destination_queue);
208
209                fsd_log_info(("pbs_submit(%s, %s) =%s", self->script_filename, self->destination_queue, job_id));
210
211         }
212        EXCEPT_DEFAULT
213         {
214                fsd_free( job_id );
215                fsd_exc_reraise();
216         }
217        FINALLY
218         {
219                if( pbs_attr )
220                        pbsdrmaa_free_attrl( pbs_attr );
221         }
222        END_TRY
223        return job_id;
224}
225
226
227void
228pbsdrmaa_submit_eval( pbsdrmaa_submit_t *self )
229{
230        self->apply_defaults( self );
231        self->apply_job_category( self );
232        self->apply_job_script( self );
233        self->apply_job_state( self );
234        self->apply_job_files( self );
235        self->apply_file_staging( self );
236        self->apply_job_resources( self );
237        self->apply_job_environment( self );
238        self->apply_email_notification( self );
239        self->apply_native_specification( self, NULL );
240}
241
242
243void
244pbsdrmaa_submit_set( pbsdrmaa_submit_t *self, const char *name,
245                 char *value, unsigned placeholders )
246{
247        fsd_template_t *pbs_attr = self->pbs_job_attributes;
248        TRY
249         {
250                if( placeholders )
251                        value = self->expand_ph->expand(
252                                        self->expand_ph, value, placeholders );
253                pbs_attr->set_attr( pbs_attr, name, value );
254         }
255        FINALLY
256         {
257                fsd_free( value );
258         }
259        END_TRY
260}
261
262
263void
264pbsdrmaa_submit_apply_defaults( pbsdrmaa_submit_t *self )
265{
266        fsd_template_t *pbs_attr = self->pbs_job_attributes;
267        pbs_attr->set_attr( pbs_attr, PBSDRMAA_CHECKPOINT, "u" );
268        pbs_attr->set_attr( pbs_attr, PBSDRMAA_KEEP_FILES, "n" );
269        pbs_attr->set_attr( pbs_attr, PBSDRMAA_PRIORITY, "0" );
270}
271
272
273void
274pbsdrmaa_submit_apply_job_script( pbsdrmaa_submit_t *self )
275{
276        const fsd_template_t *jt = self->job_template;
277        /* fsd_template_t *pbs_attr = self->pbs_job_attributes; */
278        fsd_expand_drmaa_ph_t *expand = self->expand_ph;
279        char *script = NULL;
280        size_t script_len;
281        const char *executable;
282        const char *wd;
283        const char *const *argv;
284        const char *input_path;
285        const char *const *i;
286
287        executable   = jt->get_attr( jt, DRMAA_REMOTE_COMMAND );
288        wd           = jt->get_attr( jt, DRMAA_WD );
289        argv         = jt->get_v_attr( jt, DRMAA_V_ARGV );
290        input_path   = jt->get_attr( jt, DRMAA_INPUT_PATH );
291
292        if( wd )
293         {
294                char *cwd = NULL;
295                cwd = expand->expand( expand, fsd_strdup(wd),
296                                FSD_DRMAA_PH_HD | FSD_DRMAA_PH_INCR );
297                expand->set( expand, FSD_DRMAA_PH_WD, cwd );
298         }
299
300        if( executable == NULL )
301                fsd_exc_raise_code( FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE );
302
303        if( input_path != NULL )
304         {
305                if( input_path[0] == ':' )
306                        input_path++;
307         }
308
309         { /* compute script length */
310                script_len = 0;
311                if( wd != NULL )
312                        script_len += strlen("cd ") + strlen(wd) + strlen("; ");
313                script_len += strlen("touch ") + strlen(((pbsdrmaa_session_t *)self->session)->job_exit_status_file_prefix) + strlen("/$PBS_JOBID.started;");
314                script_len += strlen(executable);
315                if( argv != NULL )
316                        for( i = argv;  *i != NULL;  i++ )
317                                script_len += 3+strlen(*i);
318                if( input_path != NULL )
319                        script_len += strlen(" <") + strlen(input_path);
320
321                script_len += strlen(";EXIT_CODE=$?; echo $EXIT_CODE >") + strlen(((pbsdrmaa_session_t *)self->session)->job_exit_status_file_prefix) + strlen("/$PBS_JOBID.exitcode; exit $EXIT_CODE");
322         }
323
324        fsd_calloc( script, script_len+1, char );
325
326         {
327                char *s;
328                s = script;
329                if( wd != NULL )
330                        s += sprintf( s, "cd %s; ", wd );
331                s += sprintf( s, "touch %s/$PBS_JOBID.started;", ((pbsdrmaa_session_t *)self->session)->job_exit_status_file_prefix);
332                s += sprintf( s, "%s", executable );
333                if( argv != NULL )
334                        for( i = argv;  *i != NULL;  i++ )
335                                s += sprintf( s, " '%s'", *i );
336                if( input_path != NULL )
337                        s += sprintf( s, " <%s", input_path );
338
339                s += sprintf( s, ";EXIT_CODE=$?; echo $EXIT_CODE >%s/$PBS_JOBID.exitcode; exit $EXIT_CODE", ((pbsdrmaa_session_t *)self->session)->job_exit_status_file_prefix);
340
341                fsd_assert( s == script+script_len );
342         }
343
344        script = expand->expand( expand, script,
345                        FSD_DRMAA_PH_HD | FSD_DRMAA_PH_WD | FSD_DRMAA_PH_INCR );
346
347        /* pbs_attr->set_attr( pbs_attr, "!script", script ); */
348
349        self->script_filename = pbsdrmaa_write_tmpfile( script, strlen(script) );
350        fsd_free( script );
351}
352
353
354void
355pbsdrmaa_submit_apply_job_state( pbsdrmaa_submit_t *self )
356{
357        const fsd_template_t *jt = self->job_template;
358        fsd_template_t *pbs_attr = self->pbs_job_attributes;
359        const char *job_name = NULL;
360        const char *submit_state = NULL;
361        const char *drmaa_start_time = NULL;
362
363        job_name = jt->get_attr( jt, DRMAA_JOB_NAME );
364        submit_state = jt->get_attr( jt, DRMAA_JS_STATE );
365        drmaa_start_time = jt->get_attr( jt, DRMAA_START_TIME );
366
367        if( job_name != NULL )
368                pbs_attr->set_attr( pbs_attr, PBSDRMAA_JOB_NAME, job_name );
369
370        if( submit_state != NULL )
371         {
372                const char *hold_types;
373                if( !strcmp(submit_state, DRMAA_SUBMISSION_STATE_ACTIVE) )
374                        hold_types = "n";
375                else if( !strcmp(submit_state, DRMAA_SUBMISSION_STATE_HOLD) )
376                        hold_types = "u";
377                else
378                        fsd_exc_raise_fmt( FSD_ERRNO_INVALID_VALUE,
379                                        "invalid value of %s attribute (%s|%s)",
380                                        DRMAA_JS_STATE, DRMAA_SUBMISSION_STATE_ACTIVE,
381                                        DRMAA_SUBMISSION_STATE_HOLD );
382                pbs_attr->set_attr( pbs_attr, PBSDRMAA_HOLD_TYPES, hold_types );
383         }
384
385        if( drmaa_start_time != NULL )
386         {
387                time_t start_time;
388                char pbs_start_time[20];
389                struct tm start_time_tm;
390                start_time = fsd_datetime_parse( drmaa_start_time );
391                localtime_r( &start_time, &start_time_tm );
392                sprintf( pbs_start_time, "%04d%02d%02d%02d%02d.%02d",
393                                start_time_tm.tm_year + 1900,
394                                start_time_tm.tm_mon + 1,
395                                start_time_tm.tm_mday,
396                                start_time_tm.tm_hour,
397                                start_time_tm.tm_min,
398                                start_time_tm.tm_sec
399                                );
400                pbs_attr->set_attr( pbs_attr, PBSDRMAA_EXECUTION_TIME, pbs_start_time );
401         }
402}
403
404
405void
406pbsdrmaa_submit_apply_job_files( pbsdrmaa_submit_t *self )
407{
408        const fsd_template_t *jt = self->job_template;
409        fsd_template_t *pbs_attr = self->pbs_job_attributes;
410        const char *join_files;
411        bool b_join_files;
412        int i;
413
414        for( i = 0;  i < 2;  i++ )
415         {
416                const char *drmaa_name;
417                const char *pbs_name;
418                const char *path;
419
420                if( i == 0 )
421                 {
422                        drmaa_name = DRMAA_OUTPUT_PATH;
423                        pbs_name = PBSDRMAA_OUTPUT_PATH;
424                 }
425                else
426                 {
427                        drmaa_name = DRMAA_ERROR_PATH;
428                        pbs_name = PBSDRMAA_ERROR_PATH;
429                 }
430
431                path = jt->get_attr( jt, drmaa_name );
432                if( path != NULL )
433                 {
434                        if( path[0] == ':' )
435                                path++;
436                        self->set(self, pbs_name, fsd_strdup(path), FSD_DRMAA_PH_HD | FSD_DRMAA_PH_WD | FSD_DRMAA_PH_INCR);
437                 }
438         }
439
440        join_files = jt->get_attr( jt, DRMAA_JOIN_FILES );
441        b_join_files = join_files != NULL  &&  !strcmp(join_files,"1");
442        pbs_attr->set_attr( pbs_attr, PBSDRMAA_JOIN_FILES, (b_join_files ? "y" : "n") );
443}
444
445
446void
447pbsdrmaa_submit_apply_file_staging( pbsdrmaa_submit_t *self )
448{
449        /* TODO */
450}
451
452
453void
454pbsdrmaa_submit_apply_job_resources( pbsdrmaa_submit_t *self )
455{
456        const fsd_template_t *jt = self->job_template;
457        fsd_template_t *pbs_attr = self->pbs_job_attributes;
458        const char *cpu_time_limit = NULL;
459        const char *walltime_limit = NULL;
460
461        cpu_time_limit = jt->get_attr( jt, DRMAA_DURATION_HLIMIT );
462        walltime_limit = jt->get_attr( jt, DRMAA_WCT_HLIMIT );
463        if( cpu_time_limit )
464         {
465                pbs_attr->set_attr( pbs_attr, "Resource_List.pcput", cpu_time_limit );
466                pbs_attr->set_attr( pbs_attr, "Resource_List.cput", cpu_time_limit );
467         }
468        if( walltime_limit )
469                pbs_attr->set_attr( pbs_attr, "Resource_List.walltime", walltime_limit );
470}
471
472
473
474void
475pbsdrmaa_submit_apply_job_environment( pbsdrmaa_submit_t *self )
476{
477        const fsd_template_t *jt = self->job_template;
478        const char *const *env_v;
479        const char *jt_wd;
480        char *wd;
481        char *env_c = NULL;
482        int ii = 0, len = 0;
483
484        env_v = jt->get_v_attr( jt, DRMAA_V_ENV);
485        jt_wd    = jt->get_attr( jt, DRMAA_WD );
486       
487        if (!jt_wd)
488        {
489                wd = fsd_getcwd();
490        }
491        else
492        {
493                wd = fsd_strdup(jt_wd);
494        }
495
496        if (env_v)
497         {
498                ii = 0;
499                while (env_v[ii])
500                 {
501                        len += strlen(env_v[ii]) + 1;
502                        ii++;
503                 }
504         }
505       
506        len+= strlen("PBS_O_WORKDIR=") + strlen(wd);
507
508        fsd_calloc(env_c, len + 1, char);
509        env_c[0] = '\0';
510
511        if (env_v)
512        {
513                ii = 0;
514                while (env_v[ii]) {
515                        strcat(env_c, env_v[ii]);
516                        strcat(env_c, ",");
517                        ii++;
518                }
519
520        }
521       
522        strcat(env_c, "PBS_O_WORKDIR=");
523        strcat(env_c, wd);
524
525        self->pbs_job_attributes->set_attr(self->pbs_job_attributes, "Variable_List", env_c);
526
527        fsd_free(env_c);
528        fsd_free(wd);
529}
530
531
532void
533pbsdrmaa_submit_apply_email_notification( pbsdrmaa_submit_t *self )
534{
535        /* TODO */
536}
537
538
539void
540pbsdrmaa_submit_apply_job_category( pbsdrmaa_submit_t *self )
541{
542        const char *job_category = NULL;
543        const char *category_spec = NULL;
544        fsd_conf_option_t *value = NULL;
545
546        job_category = self->job_template->get_attr(
547                        self->job_template, DRMAA_JOB_CATEGORY );
548        if( job_category == NULL  ||  job_category[0] == '\0' )
549                job_category = "default";
550        value = fsd_conf_dict_get( self->session->job_categories,
551                        job_category );
552        if( value != NULL  &&  value->type == FSD_CONF_STRING )
553                category_spec = value->val.string;
554        if( category_spec != NULL )
555                self->apply_native_specification( self, category_spec );
556}
557
558static const char *get_job_env(pbsdrmaa_submit_t *self, const char *env_name)
559{
560        const fsd_template_t *jt = self->job_template;
561        const char *const *env_v = jt->get_v_attr( jt, DRMAA_V_ENV);
562        int ii = 0;
563
564        while (env_v[ii])
565         {
566                char *eq_p = strstr(env_v[ii], "=");
567
568                if ((eq_p) && (strncmp(env_v[ii], env_name, eq_p - env_v[ii]) == 0))
569                                return ++eq_p;
570
571                ii++;
572         }
573
574        return NULL;
575}
576
577static void parse_resources(pbsdrmaa_submit_t *self, fsd_template_t *pbs_attr,const char *resources)
578{
579        char * volatile name = NULL;
580        char *arg = NULL;
581        char *value = NULL;
582        char *ctxt = NULL;
583        char * volatile resources_copy = fsd_strdup(resources);
584
585        TRY
586          {
587                for (arg = strtok_r(resources_copy, ",", &ctxt); arg; arg = strtok_r(NULL, ",",&ctxt) )
588                {
589                        char *psep = strchr(arg, '=');
590
591                        if (psep)
592                        {
593                                *psep = '\0';
594                                name = fsd_asprintf("Resource_List.%s", arg);
595                                value = ++psep;
596                                if (value[0] == '$' && get_job_env(self, value + 1))
597                                        pbs_attr->set_attr( pbs_attr, name , get_job_env(self, value + 1) ); /*get value from job env variable */
598                                else
599                                        pbs_attr->set_attr( pbs_attr, name , value );
600                                fsd_free(name);
601                                name = NULL;
602                        }
603                        else
604                        {
605                                fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE, "Invalid native specification: %s (Invalid resource specification: %s)", resources, arg);
606                        }
607                }
608          }
609        FINALLY
610          {
611                fsd_free(name);
612                fsd_free(resources_copy);
613          }
614        END_TRY
615}
616
617static void parse_additional_attr(fsd_template_t *pbs_attr,const char *add_attr)
618{
619        char * volatile name = NULL;
620        char *arg = NULL;
621        char *value = NULL;
622        char *ctxt = NULL, *ctxt2 = NULL;
623        char * volatile add_attr_copy = fsd_strdup(add_attr);
624
625        TRY
626          {
627                for (arg = strtok_r(add_attr_copy, ";", &ctxt); arg; arg = strtok_r(NULL, ";",&ctxt) )
628                {
629                        name = fsd_strdup(strtok_r(arg, "=", &ctxt2));
630                        value = strtok_r(NULL, "=", &ctxt2);
631                        pbs_attr->set_attr( pbs_attr, name , value );
632                        fsd_free(name);
633                        name = NULL;
634                }
635          }
636        FINALLY
637          {
638                fsd_free(name);
639                fsd_free(add_attr_copy);
640          }
641        END_TRY
642}
643
644
645void
646pbsdrmaa_submit_apply_native_specification( pbsdrmaa_submit_t *self,
647                const char *native_specification )
648{
649        fsd_log_enter(( "({native_specification=%s})", native_specification ));
650
651        if( native_specification == NULL )
652                native_specification = self->job_template->get_attr(
653                                self->job_template, DRMAA_NATIVE_SPECIFICATION );
654        if( native_specification == NULL )
655                return;
656
657        {
658                fsd_template_t *pbs_attr = self->pbs_job_attributes;
659                char *arg = NULL;
660                volatile char * native_spec_copy = fsd_strdup(native_specification);
661                char * ctxt = NULL;
662                int opt = 0;
663
664                TRY
665                  {
666                        for (arg = strtok_r((char *)native_spec_copy, " \t", &ctxt); arg; arg = strtok_r(NULL, " \t",&ctxt) ) {
667                                if (!opt)
668                                  {
669                                        if ( (arg[0] != '-') || (strlen(arg) != 2) )
670                                                fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
671                                                        "Invalid native specification: -o(ption) expected (arg=%s native=%s).",
672                                                        arg, native_specification);
673
674                                        opt = arg[1];
675
676                                        /* handle NO-arg options */
677
678                                        switch (opt) {
679                                                case 'h' :
680                                                        pbs_attr->set_attr( pbs_attr, "Hold_Types" , "u" );
681                                                        break;
682                                                default :
683                                                        continue; /*no NO-ARG option */
684                                        }
685
686                                        opt = 0;
687                                  }
688                                else
689                                  {
690                                        switch (opt) {
691                                               
692                                                case 'W' :
693                                                        parse_additional_attr(pbs_attr, arg);
694                                                        break;
695                                                case 'N' :
696                                                        pbs_attr->set_attr( pbs_attr, "Job_Name" , arg );
697                                                        break;
698                                                case 'o' :
699                                                        pbs_attr->set_attr( pbs_attr, "Output_Path" , arg );
700                                                        break;
701                                                case 'e' :
702                                                        pbs_attr->set_attr( pbs_attr, "Error_Path" , arg );
703                                                        break;
704                                                case 'j' :
705                                                        pbs_attr->set_attr( pbs_attr, "Join_Path" , arg );
706                                                        break;
707                                                case 'm' :
708                                                        pbs_attr->set_attr( pbs_attr, "Mail_Points" , arg );
709                                                        break;
710                                                case 'a' :
711                                                        pbs_attr->set_attr( pbs_attr, "Execution_Time" , arg );
712                                                        break;
713                                                case 'A' :
714                                                        pbs_attr->set_attr( pbs_attr, "Account_Name" , arg );
715                                                        break;
716                                                case 'c' :
717                                                        pbs_attr->set_attr( pbs_attr, "Checkpoint" , arg );
718                                                        break;
719                                                case 'k' :
720                                                        pbs_attr->set_attr( pbs_attr, "Keep_Files" , arg );
721                                                        break;
722                                                case 'p' :
723                                                        pbs_attr->set_attr( pbs_attr, "Priority" , arg );
724                                                        break;
725                                                case 'q' :
726                                                        if (self->destination_queue)
727                                                                fsd_free(self->destination_queue);
728
729                                                        self->destination_queue = fsd_strdup( arg );
730                                                        fsd_log_debug(("self->destination_queue = %s", self->destination_queue));
731                                                        break;
732                                                case 'r' :
733                                                        pbs_attr->set_attr( pbs_attr, "Rerunable" , arg );
734                                                        break;
735                                                case 'S' :
736                                                        pbs_attr->set_attr( pbs_attr, "Shell_Path_List" , arg );
737                                                        break;
738                                                case 'u' :
739                                                        pbs_attr->set_attr( pbs_attr, "User_List" , arg );
740                                                        break;
741                                                case 'v' :
742                                                        pbs_attr->set_attr( pbs_attr, "Variable_List" , arg );
743                                                        break;
744                                                case 'M' :
745                                                        pbs_attr->set_attr( pbs_attr, "Mail_Users" , arg );
746                                                        break;
747                                                case 'l' :
748                                                        parse_resources( self, pbs_attr, arg);
749                                                        break;                                                 
750                                                default :
751                                                       
752                                                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
753                                                                        "Invalid native specification: %s (Unsupported option: -%c)",
754                                                                        native_specification, opt);
755                                        }
756                                        opt = 0;
757                                }
758                        }
759
760                        if (opt) /* option without optarg */
761                                fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
762                                                "Invalid native specification: %s",
763                                                native_specification);
764                 }
765                FINALLY
766                 {
767#ifndef PBS_PROFESSIONAL
768                        pbs_attr->set_attr( pbs_attr, "submit_args", native_specification);
769#endif
770                        fsd_free((char *)native_spec_copy);
771                 }
772                END_TRY
773        }
774}
775
776struct attrl *
777pbsdrmaa_submit_filter(struct attrl *pbs_attr)
778{
779        fsd_log_enter(( "({pbs_attr=%p})", (void*)pbs_attr));
780
781        if (getenv(PBSDRMAA_SUBMIT_FILTER_ENV) == NULL)
782          {
783                return pbs_attr;
784          }
785        else
786          {
787                struct attrl *ii = NULL;
788                char *empty_args[] = { NULL };
789                int exit_status = -1;
790                const char *submit_filter = getenv(PBSDRMAA_SUBMIT_FILTER_ENV);
791                char *stdin_buf = NULL;
792                int stdin_size = 0;
793                char *stdout_buf = NULL;
794                char *stderr_buf = NULL;
795                char *output_line = NULL;
796                char *ctx = NULL;
797
798                fsd_log_debug(("Executing filter script: %s", submit_filter));
799               
800               
801                for (ii = pbs_attr; ii; ii = ii->next)
802                  {
803                        stdin_size += strlen(ii->name) + strlen(ii->value) + 2 /* '=' and '\n' */;
804                        if (ii->resource)
805                          {
806                                stdin_size += strlen(ii->resource) +  1; /* '.' */
807                          }
808                  }
809
810                stdin_size+=1; /* '\0' */
811
812                stdin_buf = fsd_calloc(stdin_buf, stdin_size, char);
813                stdin_buf[0] = '\0';
814
815                for (ii = pbs_attr; ii; ii = ii->next)
816                  {
817                        strcat(stdin_buf, ii->name);
818                        if (ii->resource)
819                          {
820                                strcat(stdin_buf, ".");
821                                strcat(stdin_buf, ii->resource);
822                          }
823                        strcat(stdin_buf, "=");
824                        strcat(stdin_buf, ii->value);
825                        strcat(stdin_buf, "\n");
826                  }
827               
828                exit_status = fsd_exec_sync(submit_filter, empty_args, stdin_buf, &stdout_buf, &stderr_buf);
829
830                if (exit_status != 0)
831                  {
832                        fsd_log_error(("Filter script %s exited with non-zero code: %d", submit_filter, exit_status));
833                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE, "Submit filter script failed (code: %d, message: %s)", exit_status, stderr_buf);
834                  }
835               
836                fsd_log_debug(("Submit filter exit_status=%d, stderr=%s", exit_status, stderr_buf));
837
838                pbsdrmaa_free_attrl(pbs_attr);
839                pbs_attr = NULL;
840
841                /* exit_status == 0 */
842                for (output_line = strtok_r(stdout_buf, "\n", &ctx);  output_line ; output_line = strtok_r(NULL, "\n", &ctx))
843                  {
844                        char *attr_name = NULL;
845                        char *attr_value = NULL;
846
847                        attr_value = strstr(output_line,"=");
848                        attr_name = output_line;
849
850                        if (!attr_value)
851                          {
852                                fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_FORMAT, "Invalid output line of submit filter: %s", output_line);
853                          }
854                        else
855                          {
856                                *attr_value = '\0';
857                                attr_value++;
858                          }
859                       
860
861                        pbs_attr = pbsdrmaa_add_attr( pbs_attr, attr_name, attr_value );
862      }
863               
864
865                return pbs_attr;
866          }
867
868}
869
Note: See TracBrowser for help on using the repository browser.