Changeset 61a5e1f191dfd6a007d527183a7ab93d692b884f

Show
Ignore:
Timestamp:
02/23/10 21:33:40 (4 years ago)
Author:
Theo Schlossnagle <jesus@omniti.com>
git-committer:
Theo Schlossnagle <jesus@omniti.com> 1266960820 +0000
git-parent:

[8fa2f7461cad23707774137d82e4b2b9e6e01c57]

git-author:
Theo Schlossnagle <jesus@omniti.com> 1266960820 +0000
Message:

This change should finally fix it. closes #58

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • src/stratcon_jlog_streamer.c

    rc07a479 r61a5e1f  
    9898  nc_printf(ncct, "%s [%s]:\n\tLast connect: %s\n", ctx->remote_str, 
    9999            ctx->remote_cn ? "connected" : 
    100                              (ctx->timeout_event ? "disconnected" : 
     100                             (ctx->retry_event ? "disconnected" : 
    101101                                                   "connecting"), lasttime); 
    102102  if(ctx->e) { 
     
    131131  nc_printf(ncct, "\tJLog event streamer [%s]\n", feedtype); 
    132132  gettimeofday(&now, NULL); 
    133   if(ctx->timeout_event) { 
    134     sub_timeval(ctx->timeout_event->whence, now, &diff); 
     133  if(ctx->retry_event) { 
     134    sub_timeval(ctx->retry_event->whence, now, &diff); 
    135135    nc_printf(ncct, "\tNext attempt in %lld.%06us\n", 
    136136              (long long)diff.tv_sec, (unsigned int) diff.tv_usec); 
     
    208208                         struct timeval *now) { 
    209209  noit_connection_ctx_t *ctx = closure; 
    210   ctx->timeout_event = NULL; 
     210  ctx->retry_event = NULL; 
    211211  noit_connection_initiate_connection(closure); 
    212212  return 0; 
     
    218218  const char *v; 
    219219  u_int32_t min_interval = 1000, max_interval = 8000; 
     220 
     221  noit_connection_disable_timeout(ctx); 
    220222  if(ctx->remote_cn) { 
    221223    free(ctx->remote_cn); 
     
    248250  noitL(noit_debug, "Next jlog_streamer attempt in %ums\n", 
    249251        ctx->current_backoff); 
    250   if(ctx->timeout_event) 
    251     eventer_remove(ctx->timeout_event); 
     252  if(ctx->retry_event) 
     253    eventer_remove(ctx->retry_event); 
    252254  else 
    253     ctx->timeout_event = eventer_alloc(); 
    254   ctx->timeout_event->callback = noit_connection_reinitiate; 
    255   ctx->timeout_event->closure = ctx; 
    256   ctx->timeout_event->mask = EVENTER_TIMER; 
    257   add_timeval(*now, interval, &ctx->timeout_event->whence); 
    258   eventer_add(ctx->timeout_event); 
     255    ctx->retry_event = eventer_alloc(); 
     256  ctx->retry_event->callback = noit_connection_reinitiate; 
     257  ctx->retry_event->closure = ctx; 
     258  ctx->retry_event->mask = EVENTER_TIMER; 
     259  add_timeval(*now, interval, &ctx->retry_event->whence); 
     260  eventer_add(ctx->retry_event); 
    259261} 
    260262static void 
     
    262264  if(ctx->remote_cn) free(ctx->remote_cn); 
    263265  if(ctx->remote_str) free(ctx->remote_str); 
     266  if(ctx->retry_event) { 
     267    eventer_remove(ctx->retry_event); 
     268    eventer_free(ctx->retry_event); 
     269  } 
    264270  if(ctx->timeout_event) { 
    265271    eventer_remove(ctx->timeout_event); 
     
    338344 
    339345int 
     346noit_connection_session_timeout(eventer_t e, int mask, void *closure, 
     347                                struct timeval *now) { 
     348  noit_connection_ctx_t *nctx = closure; 
     349  eventer_t fde = nctx->e; 
     350  nctx->timeout_event = NULL; 
     351  noitL(noit_error, "Timing out jlog session: %s\n", 
     352        nctx->remote_cn ? nctx->remote_cn : "(null)"); 
     353  if(fde) 
     354    eventer_trigger(fde, EVENTER_EXCEPTION); 
     355  return 0; 
     356} 
     357int 
    340358stratcon_jlog_recv_handler(eventer_t e, int mask, void *closure, 
    341359                           struct timeval *now) { 
     
    363381  } 
    364382 
     383  noit_connection_update_timeout(nctx); 
    365384  while(1) { 
    366385    switch(ctx->state) { 
     
    441460                nctx->remote_cn ? nctx->remote_cn : "(null)", 
    442461                ctx->header.chkpt.log, ctx->header.chkpt.marker); 
     462          noit_connection_disable_timeout(nctx); 
    443463          return 0; 
    444464        } else 
     
    654674  nctx->e = e; 
    655675  eventer_add(e); 
     676 
     677  noit_connection_update_timeout(nctx); 
    656678  return; 
    657679 
     
    661683  noit_connection_schedule_reattempt(nctx, &__now); 
    662684  return; 
     685} 
     686 
     687int 
     688noit_connection_update_timeout(noit_connection_ctx_t *nctx) { 
     689  struct timeval now, diff; 
     690  if(nctx->max_silence == 0) return 0; 
     691 
     692  diff.tv_sec = nctx->max_silence / 1000; 
     693  diff.tv_usec = (nctx->max_silence % 1000) * 1000; 
     694  gettimeofday(&now, NULL); 
     695 
     696  if(!nctx->timeout_event) { 
     697    nctx->timeout_event = eventer_alloc(); 
     698    nctx->timeout_event->mask = EVENTER_TIMER; 
     699    nctx->timeout_event->closure = nctx; 
     700    nctx->timeout_event->callback = noit_connection_session_timeout; 
     701    add_timeval(now, diff, &nctx->timeout_event->whence); 
     702    eventer_add(nctx->timeout_event); 
     703  } 
     704  else { 
     705    add_timeval(now, diff, &nctx->timeout_event->whence); 
     706    eventer_update(nctx->timeout_event, EVENTER_TIMER); 
     707  } 
     708} 
     709 
     710int 
     711noit_connection_disable_timeout(noit_connection_ctx_t *nctx) { 
     712  if(nctx->timeout_event) { 
     713    eventer_remove(nctx->timeout_event); 
     714    eventer_free(nctx->timeout_event); 
     715    nctx->timeout_event = NULL; 
     716  } 
    663717} 
    664718 
     
    669723                         void (*freefunc)(void *)) { 
    670724  noit_connection_ctx_t *ctx; 
    671  
     725  const char *stimeout; 
    672726  int8_t family; 
    673727  int rv; 
     
    731785  noit_hash_merge_as_dict(ctx->config, config); 
    732786 
     787  if(noit_hash_retr_str(ctx->config, "timeout", strlen("timeout"), &stimeout)) 
     788    ctx->max_silence = atoi(stimeout); 
     789  else 
     790    ctx->max_silence = DEFAULT_NOIT_CONNECTION_TIMEOUT; 
    733791  ctx->consumer_callback = handler; 
    734792  ctx->consumer_free = freefunc; 
     
    930988    xmlSetProp(node, (xmlChar *)"state", ctx->remote_cn ? 
    931989               (xmlChar *)"connected" : 
    932                (ctx->timeout_event ? (xmlChar *)"disconnected" : 
     990               (ctx->retry_event ? (xmlChar *)"disconnected" : 
    933991                                    (xmlChar *)"connecting")); 
    934992    if(ctx->e) { 
     
    9611019    xmlSetProp(node, (xmlChar *)"remote", (xmlChar *)ctx->remote_str); 
    9621020    xmlSetProp(node, (xmlChar *)"type", (xmlChar *)feedtype); 
    963     if(ctx->timeout_event) { 
    964       sub_timeval(ctx->timeout_event->whence, now, &diff); 
     1021    if(ctx->retry_event) { 
     1022      sub_timeval(ctx->retry_event->whence, now, &diff); 
    9651023      snprintf(buff, sizeof(buff), "%llu.%06d", 
    9661024               (long long unsigned)diff.tv_sec, (int)diff.tv_usec); 
     
    12621320  eventer_name_callback("noit_connection_complete_connect", 
    12631321                        noit_connection_complete_connect); 
     1322  eventer_name_callback("noit_connection_session_timeout", 
     1323                        noit_connection_session_timeout); 
    12641324  register_console_streamer_commands(); 
    12651325  stratcon_jlog_streamer_reload(toplevel); 
  • src/stratcon_jlog_streamer.h

    r3c6e7b2 r61a5e1f  
    4242#include "stratcon_datastore.h" 
    4343 
     44#define DEFAULT_NOIT_CONNECTION_TIMEOUT 60000 /* 60 seconds */ 
     45 
    4446typedef struct noit_connection_ctx_t { 
    4547  noit_atomic32_t refcnt; 
     
    5658  int wants_shutdown; 
    5759  int wants_permanent_shutdown; 
     60  int max_silence; 
    5861  noit_hash_table *config; 
    5962  noit_hash_table *sslconfig; 
    6063  struct timeval last_connect; 
    6164  eventer_t timeout_event; 
     65  eventer_t retry_event; 
    6266  eventer_t e; 
    6367 
     
    107111API_EXPORT(void) 
    108112  jlog_streamer_ctx_free(void *cl); 
     113API_EXPORT(int) 
     114  noit_connection_update_timeout(noit_connection_ctx_t *ctx); 
     115API_EXPORT(int) 
     116  noit_connection_disable_timeout(noit_connection_ctx_t *ctx); 
    109117API_EXPORT(void) 
    110118  noit_connection_ctx_dealloc(noit_connection_ctx_t *ctx);