source: trunk/pbs_drmaa/session.c @ 41

Revision 41, 13.7 KB checked in by mmamonski, 8 years ago (diff)

drmaa_init - fault tolerant

  • 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 <stdlib.h>
25#include <string.h>
26#include <unistd.h>
27#include <sys/select.h>
28#include <sys/stat.h>
29#include <sys/types.h>
30#include <fcntl.h>
31
32#include <pbs_ifl.h>
33#include <pbs_error.h>
34
35#include <drmaa_utils/datetime.h>
36#include <drmaa_utils/drmaa.h>
37#include <drmaa_utils/iter.h>
38#include <drmaa_utils/conf.h>
39#include <drmaa_utils/session.h>
40#include <drmaa_utils/datetime.h>
41
42#include <pbs_drmaa/job.h>
43#include <pbs_drmaa/log_reader.h>
44#include <pbs_drmaa/session.h>
45#include <pbs_drmaa/submit.h>
46#include <pbs_drmaa/util.h>
47
48#include <errno.h>
49
50#ifndef lint
51static char rcsid[]
52#       ifdef __GNUC__
53                __attribute__ ((unused))
54#       endif
55        = "$Id$";
56#endif
57
58static void
59pbsdrmaa_session_destroy( fsd_drmaa_session_t *self );
60
61static void
62pbsdrmaa_session_apply_configuration( fsd_drmaa_session_t *self );
63
64static fsd_job_t *
65pbsdrmaa_session_new_job( fsd_drmaa_session_t *self, const char *job_id );
66
67static bool
68pbsdrmaa_session_do_drm_keeps_completed_jobs( pbsdrmaa_session_t *self );
69
70static void
71pbsdrmaa_session_update_all_jobs_status( fsd_drmaa_session_t *self );
72
73static void
74*pbsdrmaa_session_wait_thread( fsd_drmaa_session_t *self );
75
76static char *
77pbsdrmaa_session_run_impl(
78                fsd_drmaa_session_t *self,
79                const fsd_template_t *jt,
80                int bulk_idx
81                );
82
83static struct attrl *
84pbsdrmaa_create_status_attrl(void);
85
86
87fsd_drmaa_session_t *
88pbsdrmaa_session_new( const char *contact )
89{
90        pbsdrmaa_session_t *volatile self = NULL;
91
92        if( contact == NULL )
93                contact = "";
94        TRY
95         {
96                self = (pbsdrmaa_session_t*)fsd_drmaa_session_new(contact);
97                fsd_realloc( self, 1, pbsdrmaa_session_t );
98                self->super_wait_thread = NULL;
99
100                self->log_file_initial_size = 0;
101                self->pbs_conn = -1;
102                self->pbs_home = NULL;
103
104                self->wait_thread_log = false;
105                self->status_attrl = NULL;
106               
107                self->super_destroy = self->super.destroy;
108                self->super.destroy = pbsdrmaa_session_destroy;
109                self->super.new_job = pbsdrmaa_session_new_job;
110                self->super.update_all_jobs_status
111                                = pbsdrmaa_session_update_all_jobs_status;
112                self->super.run_impl = pbsdrmaa_session_run_impl;
113
114                self->super_apply_configuration = self->super.apply_configuration;
115                self->super.apply_configuration = pbsdrmaa_session_apply_configuration;
116
117                self->do_drm_keeps_completed_jobs =
118                        pbsdrmaa_session_do_drm_keeps_completed_jobs;
119
120                self->status_attrl = pbsdrmaa_create_status_attrl();
121
122         {      /* ugly. But this is life... ;( */
123                #define MAX_PBS_CONNECT_RETRIES (3)
124                int tries_counter = MAX_PBS_CONNECT_RETRIES;
125             retry:
126                self->pbs_conn = pbs_connect( self->super.contact );
127                fsd_log_info(( "pbs_connect(%s) =%d", self->super.contact,
128                                        self->pbs_conn ));
129                if( self->pbs_conn < 0 && tries_counter-- )
130                 {
131                        sleep(1);
132                        goto retry;
133                 }
134         }
135                if( self->pbs_conn < 0 )
136                        pbsdrmaa_exc_raise_pbs( "pbs_connect" );
137
138                self->super.load_configuration( &self->super, "pbs_drmaa" );
139
140                self->super.missing_jobs = FSD_IGNORE_MISSING_JOBS;
141                if( self->do_drm_keeps_completed_jobs( self ) )
142                        self->super.missing_jobs = FSD_IGNORE_QUEUED_MISSING_JOBS;
143         }
144        EXCEPT_DEFAULT
145         {
146                if( self )
147                  {
148                        self->super.destroy( &self->super );
149                        self = NULL;
150                  }
151
152                fsd_exc_reraise();
153         }
154        END_TRY
155        return (fsd_drmaa_session_t*)self;
156}
157
158
159void
160pbsdrmaa_session_destroy( fsd_drmaa_session_t *self )
161{
162        pbsdrmaa_session_t *pbsself = (pbsdrmaa_session_t*)self;
163        self->stop_wait_thread( self );
164        if( pbsself->pbs_conn >= 0 )
165                pbs_disconnect( pbsself->pbs_conn );
166        fsd_free( pbsself->status_attrl );
167        pbsself->super_destroy( self );
168}
169
170
171static char *
172pbsdrmaa_session_run_impl(
173                fsd_drmaa_session_t *self,
174                const fsd_template_t *jt,
175                int bulk_idx
176                )
177{
178        char *volatile job_id = NULL;
179        fsd_job_t *volatile job = NULL;
180        pbsdrmaa_submit_t *volatile submit = NULL;
181
182        fsd_log_enter(( "(jt=%p, bulk_idx=%d)", (void*)jt, bulk_idx ));
183        TRY
184         {
185                submit = pbsdrmaa_submit_new( self, jt, bulk_idx );
186                submit->eval( submit );
187                job_id = submit->submit( submit );
188                job = self->new_job( self, job_id );
189                job->submit_time = time(NULL);
190                job->flags |= FSD_JOB_CURRENT_SESSION;
191                self->jobs->add( self->jobs, job );
192                job->release( job );  job = NULL;
193         }
194        EXCEPT_DEFAULT
195         {
196                fsd_free( job_id );
197                fsd_exc_reraise();
198         }
199        FINALLY
200         {
201                if( submit )
202                        submit->destroy( submit );
203                if( job )
204                        job->release( job );
205         }
206        END_TRY
207        fsd_log_return(( " =%s", job_id ));
208        return job_id;
209}
210
211
212static fsd_job_t *
213pbsdrmaa_session_new_job( fsd_drmaa_session_t *self, const char *job_id )
214{
215        fsd_job_t *job;
216        job = pbsdrmaa_job_new( fsd_strdup(job_id) );
217        job->session = self;
218        return job;
219}
220
221void
222pbsdrmaa_session_apply_configuration( fsd_drmaa_session_t *self )
223{
224        pbsdrmaa_session_t *pbsself = (pbsdrmaa_session_t*)self;
225        fsd_conf_option_t *pbs_home;
226        pbs_home = fsd_conf_dict_get(self->configuration, "pbs_home" );
227
228        if( pbs_home && pbs_home->type == FSD_CONF_STRING )
229          {
230                        struct stat statbuf;
231                        char * volatile log_path;
232                        struct tm tm;
233                       
234                        pbsself->pbs_home = pbs_home->val.string;
235                        fsd_log_info(("pbs_home: %s",pbsself->pbs_home));
236                        pbsself->super_wait_thread = pbsself->super.wait_thread;
237                        pbsself->super.wait_thread = pbsdrmaa_session_wait_thread;             
238                        pbsself->wait_thread_log = true;
239       
240                        time(&pbsself->log_file_initial_time); 
241                        localtime_r(&pbsself->log_file_initial_time,&tm);
242
243                        log_path = fsd_asprintf("%s/server_logs/%04d%02d%02d",
244                                        pbsself->pbs_home,
245                                        tm.tm_year + 1900,
246                                        tm.tm_mon + 1,
247                                        tm.tm_mday);
248
249                        if(stat(log_path,&statbuf) == -1)
250                          {
251                                char errbuf[256] = "InternalError";
252                                (void)strerror_r(errno, errbuf, sizeof(errbuf));
253                                fsd_exc_raise_fmt(FSD_ERRNO_INTERNAL_ERROR,"stat error on file %s: %s", log_path, errbuf);
254                          }
255       
256                        fsd_log_debug(("Log file %s size %d",log_path,(int) statbuf.st_size));
257                        pbsself->log_file_initial_size = statbuf.st_size;
258                        fsd_free(log_path);
259          }
260
261        pbsself->super_apply_configuration(self); /* call method from the superclass */
262}
263
264
265void
266pbsdrmaa_session_update_all_jobs_status( fsd_drmaa_session_t *self )
267{
268        volatile bool conn_lock = false;
269        volatile bool jobs_lock = false;
270        pbsdrmaa_session_t *pbsself = (pbsdrmaa_session_t*)self;
271        fsd_job_set_t *jobs = self->jobs;
272        struct batch_status *volatile status = NULL;
273
274        fsd_log_enter((""));
275
276        TRY
277         {
278                conn_lock = fsd_mutex_lock( &self->drm_connection_mutex );
279retry:
280/* TODO: query only for user's jobs pbs_selstat + ATTR_u */
281#ifdef PBS_PROFESSIONAL
282                status = pbs_statjob( pbsself->pbs_conn, NULL, NULL, NULL );
283#else
284                status = pbs_statjob( pbsself->pbs_conn, NULL, pbsself->status_attrl, NULL );
285#endif
286                fsd_log_info(( "pbs_statjob( fd=%d, job_id=NULL, attribs={...} ) =%p",
287                                 pbsself->pbs_conn, (void*)status ));
288                if( status == NULL  &&  pbs_errno != 0 )
289                 {
290                        if (pbs_errno == PBSE_PROTOCOL || pbs_errno == PBSE_EXPIRED)
291                         {
292                                if ( pbsself->pbs_conn >= 0)
293                                        pbs_disconnect( pbsself->pbs_conn );
294                                sleep(1);
295                                pbsself->pbs_conn = pbs_connect( pbsself->super.contact );
296                                if( pbsself->pbs_conn < 0 )
297                                        pbsdrmaa_exc_raise_pbs( "pbs_connect" );
298                                else
299                                        goto retry;
300                         }
301                        else
302                         {
303                                pbsdrmaa_exc_raise_pbs( "pbs_statjob" );
304                         }
305                 }
306                conn_lock = fsd_mutex_unlock( &self->drm_connection_mutex );
307
308                 {
309                        size_t i;
310                        fsd_job_t *job;
311                        jobs_lock = fsd_mutex_lock( &jobs->mutex );
312                        for( i = 0;  i < jobs->tab_size;  i++ )
313                                for( job = jobs->tab[i];  job != NULL;  job = job->next )
314                                 {
315                                        fsd_mutex_lock( &job->mutex );
316                                        job->flags |= FSD_JOB_MISSING;
317                                        fsd_mutex_unlock( &job->mutex );
318                                 }
319                        jobs_lock = fsd_mutex_unlock( &jobs->mutex );
320                 }
321
322                 {
323                        struct batch_status *volatile i;
324                        for( i = status;  i != NULL;  i = i->next )
325                         {
326                                fsd_job_t *job = NULL;
327                                fsd_log_debug(( "job_id=%s", i->name ));
328                                job = self->get_job( self, i->name );
329                                if( job != NULL )
330                                 {
331                                        job->flags &= ~FSD_JOB_MISSING;
332                                        TRY
333                                         {
334                                                ((pbsdrmaa_job_t*)job)->update( job, i );
335                                         }
336                                        FINALLY
337                                         {
338                                                job->release( job );
339                                         }
340                                        END_TRY
341                                 }
342                         }
343                 }
344
345                 {
346                        size_t volatile i;
347                        fsd_job_t *volatile job;
348                        jobs_lock = fsd_mutex_lock( &jobs->mutex );
349                        for( i = 0;  i < jobs->tab_size;  i++ )
350                                for( job = jobs->tab[i];  job != NULL;  job = job->next )
351                                 {
352                                        fsd_mutex_lock( &job->mutex );
353                                        TRY
354                                         {
355                                                if( job->flags & FSD_JOB_MISSING )
356                                                        job->on_missing( job );
357                                         }
358                                        FINALLY{ fsd_mutex_unlock( &job->mutex ); }
359                                        END_TRY
360                                 }
361                        jobs_lock = fsd_mutex_unlock( &jobs->mutex );
362                 }
363         }
364        FINALLY
365         {
366                if( status != NULL )
367                        pbs_statfree( status );
368                if( conn_lock )
369                        conn_lock = fsd_mutex_unlock( &self->drm_connection_mutex );
370                if( jobs_lock )
371                        jobs_lock = fsd_mutex_unlock( &jobs->mutex );
372         }
373        END_TRY
374
375        fsd_log_return((""));
376}
377
378
379
380struct attrl *
381pbsdrmaa_create_status_attrl(void)
382{
383        struct attrl *result = NULL;
384        struct attrl *i;
385        const int max_attribs = 16;
386        int n_attribs;
387        int j = 0;
388
389        fsd_log_enter((""));
390        fsd_calloc( result, max_attribs, struct attrl );
391        result[j++].name="job_state";
392        result[j++].name="exit_status";
393        result[j++].name="resources_used";
394        result[j++].name="ctime";
395        result[j++].name="mtime";
396        result[j++].name="qtime";
397        result[j++].name="etime";
398
399        result[j++].name="queue";
400        result[j++].name="Account_Name";
401        result[j++].name="exec_host";
402        result[j++].name="start_time";
403        result[j++].name="mtime";
404#if 0
405        result[j].name="resources_used";  result[j].resource="walltime";  j++;
406        result[j].name="resources_used";  result[j].resource="cput";  j++;
407        result[j].name="resources_used";  result[j].resource="mem";  j++;
408        result[j].name="resources_used";  result[j].resource="vmem";  j++;
409        result[j].name="Resource_List";  result[j].resource="walltime";  j++;
410        result[j].name="Resource_List";  result[j].resource="cput";  j++;
411        result[j].name="Resource_List";  result[j].resource="mem";  j++;
412        result[j].name="Resource_List";  result[j].resource="vmem";  j++;
413#endif
414        n_attribs = j;
415        for( i = result;  true;  i++ )
416                if( i+1 < result + n_attribs )
417                        i->next = i+1;
418                else
419                 {
420                        i->next = NULL;
421                        break;
422                 }
423
424#ifdef DEBUGGING
425        fsd_log_return((":"));
426        pbsdrmaa_dump_attrl( result, NULL );
427#endif
428        return result;
429}
430
431
432bool
433pbsdrmaa_session_do_drm_keeps_completed_jobs( pbsdrmaa_session_t *self )
434{
435
436#ifndef PBS_PROFESSIONAL
437        struct attrl default_queue_query;
438        struct attrl keep_completed_query;
439        struct batch_status *default_queue_result = NULL;
440        struct batch_status *keep_completed_result = NULL;
441        const char *default_queue = NULL;
442        const char *keep_completed = NULL;
443        volatile bool result = false;
444        volatile bool conn_lock = false;
445
446        TRY
447         {
448                default_queue_query.next = NULL;
449                default_queue_query.name = "default_queue";
450                default_queue_query.resource = NULL;
451                default_queue_query.value = NULL;
452                keep_completed_query.next = NULL;
453                keep_completed_query.name = "keep_completed";
454                keep_completed_query.resource = NULL;
455                keep_completed_query.value = NULL;
456
457                conn_lock = fsd_mutex_lock( &self->super.drm_connection_mutex );
458
459                default_queue_result =
460                                pbs_statserver( self->pbs_conn, &default_queue_query, NULL );
461                if( default_queue_result == NULL )
462                        pbsdrmaa_exc_raise_pbs( "pbs_statserver" );
463                if( default_queue_result->attribs
464                                &&  !strcmp( default_queue_result->attribs->name,
465                                        "default_queue" ) )
466                        default_queue = default_queue_result->attribs->value;
467
468                fsd_log_debug(( "default_queue: %s", default_queue ));
469
470                if( default_queue )
471                 {
472                        keep_completed_result = pbs_statque( self->pbs_conn,
473                                        (char*)default_queue, &keep_completed_query, NULL );
474                        if( keep_completed_result == NULL )
475                                pbsdrmaa_exc_raise_pbs( "pbs_statque" );
476                        if( keep_completed_result->attribs
477                                        &&  !strcmp( keep_completed_result->attribs->name,
478                                                "keep_completed" ) )
479                                keep_completed = keep_completed_result->attribs->value;
480                 }
481
482                fsd_log_debug(( "keep_completed: %s", keep_completed ));
483         }
484        EXCEPT_DEFAULT
485         {
486                const fsd_exc_t *e = fsd_exc_get();
487                fsd_log_warning(( "PBS server seems not to keep completed jobs\n"
488                                "detail: %s", e->message(e) ));
489                result = false;
490         }
491        ELSE
492         {
493                result = false;
494                if( default_queue == NULL )
495                        fsd_log_warning(( "no default queue set on PBS server" ));
496                else if( keep_completed == NULL && self->pbs_home == NULL )
497                        fsd_log_warning(( "Torque server is not configured to keep completed jobs\n"
498                                                "in Torque: set keep_completed parameter of default queue\n"
499                                                "  $ qmgr -c 'set queue batch keep_completed = 60'\n"
500                                                " or configure DRMAA to utilize log files"
501                                                ));
502                else
503                        result = true;
504         }
505        FINALLY
506         {
507                if( default_queue_result )
508                        pbs_statfree( default_queue_result );
509                if( keep_completed_result )
510                        pbs_statfree( keep_completed_result );
511                if( conn_lock )
512                        conn_lock = fsd_mutex_unlock( &self->super.drm_connection_mutex );
513
514         }
515        END_TRY
516
517        return result;
518#endif
519        fsd_log_warning(( "PBS Professional does not keep information about the completed jobs\n"
520                                " You must configure DRMAA to utilize log files in order to always get valid job exit status"
521                                ));
522        return false;
523}
524
525void *
526pbsdrmaa_session_wait_thread( fsd_drmaa_session_t *self )
527{
528        pbsdrmaa_log_reader_t *log_reader = NULL;
529       
530        fsd_log_enter(( "" ));
531       
532        TRY
533        {       
534                log_reader = pbsdrmaa_log_reader_new( self );
535                log_reader->read_log( log_reader );
536        }
537        FINALLY
538        {
539                pbsdrmaa_log_reader_destroy( log_reader );
540        }
541        END_TRY
542       
543        fsd_log_return(( " =NULL" ));
544        return NULL;
545}
Note: See TracBrowser for help on using the repository browser.