Ignore:
Timestamp:
01/17/13 18:44:15 (11 years ago)
Author:
mmamonski
Message:

PBS DRMAA autoclose connection

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/pbs_drmaa/pbs_conn.c

    r84 r85  
    2828#include <drmaa_utils/iter.h> 
    2929#include <drmaa_utils/conf.h> 
    30 #include <drmaa_utils/session.h> 
    3130#include <drmaa_utils/datetime.h> 
    3231 
     32#include <pbs_drmaa/session.h> 
    3333#include <pbs_drmaa/pbs_conn.h> 
    3434#include <pbs_drmaa/util.h> 
     
    5353static void pbsdrmaa_pbs_holdjob( pbsdrmaa_pbs_conn_t *self,  char *job_id ); 
    5454 
    55 static void pbsdrmaa_pbs_reconnect_internal( pbsdrmaa_pbs_conn_t *self, bool reconnect); 
    56  
    57 static void pbsdrmaa_pbs_check_connect_internal( pbsdrmaa_pbs_conn_t *self, bool reconnect); 
    58  
     55static void pbsdrmaa_pbs_connection_autoclose_thread_loop( pbsdrmaa_pbs_conn_t *self, bool reconnect); 
     56 
     57 
     58static void check_reconnect( pbsdrmaa_pbs_conn_t *self, bool reconnect); 
     59 
     60static void start_autoclose_thread( pbsdrmaa_pbs_conn_t *self ); 
     61 
     62static void stop_autoclose_thread( pbsdrmaa_pbs_conn_t *self ); 
     63 
     64 
     65#if defined PBS_PROFESSIONAL && defined PBSE_HISTJOBID 
     66        #define IS_MISSING_JOB (pbs_errno == PBSE_UNKJOBID || pbs_errno == PBSE_HISTJOBID) 
     67#else 
     68        #define IS_MISSING_JOB (pbs_errno == PBSE_UNKJOBID) 
     69#endif 
    5970#define IS_TRANSIENT_ERROR (pbs_errno == PBSE_PROTOCOL || pbs_errno == PBSE_EXPIRED || pbs_errno == PBSOLDE_PROTOCOL || pbs_errno == PBSOLDE_EXPIRED) 
    6071 
    61          
    6272pbsdrmaa_pbs_conn_t *  
    63 pbsdrmaa_pbs_conn_new( pbsdrmaa_session_t *session, char *server ) 
     73pbsdrmaa_pbs_conn_new( fsd_drmaa_session_t *session, const char *server ) 
    6474{ 
    6575        pbsdrmaa_pbs_conn_t *volatile self = NULL; 
     
    8494 
    8595                self->connection_fd = -1; 
    86                 self->last_usage = time(NULL); 
    8796 
    8897                /*ignore SIGPIPE - otherwise pbs_disconnect cause the program to exit */ 
    8998                signal(SIGPIPE, SIG_IGN);        
    9099 
    91                 pbsdrmaa_pbs_reconnect_internal(self, false); 
     100                check_reconnect(self, false); 
    92101          } 
    93102        EXCEPT_DEFAULT 
     
    100109                        if (self->connection_fd != -1) 
    101110                                pbs_disconnect(self->connection_fd); 
     111                        stop_autoclose_thread(self); 
    102112                  } 
    103113                         
     
    110120        return self; 
    111121} 
    112  
    113122 
    114123void 
     
    148157        TRY 
    149158         { 
    150                 conn_lock = fsd_mutex_lock(&self->session->super.drm_connection_mutex); 
    151  
    152                 pbsdrmaa_pbs_reconnect_internal(self, false); 
     159                conn_lock = fsd_mutex_lock(&self->session->drm_connection_mutex); 
     160 
     161                check_reconnect(self, false); 
    153162 
    154163retry: 
     
    162171                        if (IS_TRANSIENT_ERROR && first_try) 
    163172                         { 
    164                                 pbsdrmaa_pbs_reconnect_internal(self, true); 
     173                                check_reconnect(self, true); 
    165174                                first_try = false; 
    166175                                goto retry; 
     
    168177                        else 
    169178                         { 
    170                                 pbsdrmaa_exc_raise_pbs( "pbs_submit"); 
     179                                pbsdrmaa_exc_raise_pbs( "pbs_submit", self->connection_fd); 
    171180                         } 
    172181                 } 
     
    180189         { 
    181190                if(conn_lock) 
    182                         conn_lock = fsd_mutex_unlock(&self->session->super.drm_connection_mutex); 
     191                        conn_lock = fsd_mutex_unlock(&self->session->drm_connection_mutex); 
    183192         } 
    184193        END_TRY 
     
    202211        TRY 
    203212         { 
    204                 conn_lock = fsd_mutex_lock(&self->session->super.drm_connection_mutex); 
    205  
    206                 pbsdrmaa_pbs_reconnect_internal(self, false); 
     213                conn_lock = fsd_mutex_lock(&self->session->drm_connection_mutex); 
     214 
     215                check_reconnect(self, false); 
    207216 
    208217retry: 
     
    213222                if(status == NULL) 
    214223                 { 
    215                         fsd_log_error(( "pbs_statjob failed, pbs_errno = %d", pbs_errno )); 
    216                         if (IS_TRANSIENT_ERROR && first_try) 
    217                          { 
    218                                 pbsdrmaa_pbs_reconnect_internal(self, true); 
     224                        if (IS_MISSING_JOB) 
     225                         { 
     226                                fsd_log_info(( "missing job = %s (code=%d)", job_id, pbs_errno )); 
     227                         } 
     228                        else if (IS_TRANSIENT_ERROR && first_try) 
     229                         { 
     230                                fsd_log_error(( "pbs_statjob failed, pbs_errno = %d", pbs_errno )); 
     231                                check_reconnect(self, true); 
    219232                                first_try = false; 
    220233                                goto retry; 
     
    222235                        else 
    223236                         { 
    224                                 pbsdrmaa_exc_raise_pbs( "pbs_statjob"); 
     237                                pbsdrmaa_exc_raise_pbs( "pbs_statjob", self->connection_fd); 
    225238                         } 
    226239                 } 
     
    236249         { 
    237250                if(conn_lock) 
    238                         conn_lock = fsd_mutex_unlock(&self->session->super.drm_connection_mutex); 
     251                        conn_lock = fsd_mutex_unlock(&self->session->drm_connection_mutex); 
    239252         } 
    240253        END_TRY 
     
    266279        TRY 
    267280         { 
    268                 conn_lock = fsd_mutex_lock(&self->session->super.drm_connection_mutex); 
    269  
    270                 pbsdrmaa_pbs_reconnect_internal(self, false); 
     281                conn_lock = fsd_mutex_lock(&self->session->drm_connection_mutex); 
     282 
     283                check_reconnect(self, false); 
    271284 
    272285retry: 
     
    280293                        if (IS_TRANSIENT_ERROR && first_try) 
    281294                         { 
    282                                 pbsdrmaa_pbs_reconnect_internal(self, true); 
     295                                check_reconnect(self, true); 
    283296                                first_try = false; 
    284297                                goto retry; 
     
    286299                        else 
    287300                         { 
    288                                 pbsdrmaa_exc_raise_pbs( "pbs_sigjob"); 
     301                                pbsdrmaa_exc_raise_pbs( "pbs_sigjob", self->connection_fd); 
    289302                         } 
    290303                 } 
     
    297310         { 
    298311                if(conn_lock) 
    299                         conn_lock = fsd_mutex_unlock(&self->session->super.drm_connection_mutex); 
     312                        conn_lock = fsd_mutex_unlock(&self->session->drm_connection_mutex); 
    300313         } 
    301314        END_TRY 
     
    318331        TRY 
    319332         { 
    320                 conn_lock = fsd_mutex_lock(&self->session->super.drm_connection_mutex); 
    321  
    322                 pbsdrmaa_pbs_reconnect_internal(self, false); 
     333                conn_lock = fsd_mutex_lock(&self->session->drm_connection_mutex); 
     334 
     335                check_reconnect(self, false); 
    323336 
    324337retry: 
     
    332345                        if (IS_TRANSIENT_ERROR && first_try) 
    333346                         { 
    334                                 pbsdrmaa_pbs_reconnect_internal(self, true); 
     347                                check_reconnect(self, true); 
    335348                                first_try = false; 
    336349                                goto retry; 
     
    338351                        else 
    339352                         { 
    340                                 pbsdrmaa_exc_raise_pbs( "pbs_deljob"); 
     353                                pbsdrmaa_exc_raise_pbs( "pbs_deljob", self->connection_fd); 
    341354                         } 
    342355                 } 
     
    349362         { 
    350363                if(conn_lock) 
    351                         conn_lock = fsd_mutex_unlock(&self->session->super.drm_connection_mutex); 
     364                        conn_lock = fsd_mutex_unlock(&self->session->drm_connection_mutex); 
    352365         } 
    353366        END_TRY 
     
    369382        TRY 
    370383         { 
    371                 conn_lock = fsd_mutex_lock(&self->session->super.drm_connection_mutex); 
    372  
    373                 pbsdrmaa_pbs_reconnect_internal(self, false); 
     384                conn_lock = fsd_mutex_lock(&self->session->drm_connection_mutex); 
     385 
     386                check_reconnect(self, false); 
    374387 
    375388retry: 
     
    383396                        if (IS_TRANSIENT_ERROR && first_try) 
    384397                         { 
    385                                 pbsdrmaa_pbs_reconnect_internal(self, true); 
     398                                check_reconnect(self, true); 
    386399                                first_try = false; 
    387400                                goto retry; 
     
    389402                        else 
    390403                         { 
    391                                 pbsdrmaa_exc_raise_pbs( "pbs_rlsjob"); 
     404                                pbsdrmaa_exc_raise_pbs( "pbs_rlsjob", self->connection_fd); 
    392405                         } 
    393406                 } 
     
    400413         { 
    401414                if(conn_lock) 
    402                         conn_lock = fsd_mutex_unlock(&self->session->super.drm_connection_mutex); 
     415                        conn_lock = fsd_mutex_unlock(&self->session->drm_connection_mutex); 
    403416         } 
    404417        END_TRY 
     
    420433        TRY 
    421434         { 
    422                 conn_lock = fsd_mutex_lock(&self->session->super.drm_connection_mutex); 
    423  
    424                 pbsdrmaa_pbs_reconnect_internal(self, false); 
     435                conn_lock = fsd_mutex_lock(&self->session->drm_connection_mutex); 
     436 
     437                check_reconnect(self, false); 
    425438 
    426439retry: 
     
    434447                        if (IS_TRANSIENT_ERROR && first_try) 
    435448                         { 
    436                                 pbsdrmaa_pbs_reconnect_internal(self, true); 
     449                                check_reconnect(self, true); 
    437450                                first_try = false; 
    438451                                goto retry; 
     
    440453                        else 
    441454                         { 
    442                                 pbsdrmaa_exc_raise_pbs( "pbs_holdjob"); 
     455                                pbsdrmaa_exc_raise_pbs( "pbs_holdjob", self->connection_fd); 
    443456                         } 
    444457                 } 
     
    451464         { 
    452465                if(conn_lock) 
    453                         conn_lock = fsd_mutex_unlock(&self->session->super.drm_connection_mutex); 
     466                        conn_lock = fsd_mutex_unlock(&self->session->drm_connection_mutex); 
    454467         } 
    455468        END_TRY 
     
    460473 
    461474void  
    462 pbsdrmaa_pbs_reconnect_internal( pbsdrmaa_pbs_conn_t *self, bool force_reconnect) 
    463 { 
    464         int tries_left = self->session->max_retries_count; 
     475check_reconnect( pbsdrmaa_pbs_conn_t *self, bool force_reconnect) 
     476{ 
     477        int tries_left = ((pbsdrmaa_session_t *)self->session)->max_retries_count; 
    465478        int sleep_time = 1; 
    466479 
     
    476489                else 
    477490                 { 
     491                        stop_autoclose_thread(self); 
    478492                        pbs_disconnect(self->connection_fd); 
    479493                        self->connection_fd = -1; 
    480494                 } 
    481495          } 
     496 
     497 
    482498 
    483499retry_connect: /* Life... */ 
     
    492508         
    493509        if( self->connection_fd < 0 ) 
    494                 pbsdrmaa_exc_raise_pbs( "pbs_connect" ); 
     510                pbsdrmaa_exc_raise_pbs( "pbs_connect", self->connection_fd ); 
    495511         
    496512        fsd_log_return(("(%d)", self->connection_fd)); 
    497513} 
    498514 
     515 
     516static void start_autoclose_thread( pbsdrmaa_pbs_conn_t *self ) 
     517{ 
     518 
     519 
     520} 
     521 
     522static void stop_autoclose_thread( pbsdrmaa_pbs_conn_t *self ) 
     523{ 
     524 
     525 
     526} 
     527 
Note: See TracChangeset for help on using the changeset viewer.