Changeset 12184

Timestamp:

Mar 17, 2011, 6:51:31 PM (10 years ago)

Author:

jordan

Message:

(trunk libT) better shutdown management of libutp and UDP trackers in tr_sessionClose().

This is a little overlapping since the utp code can be closed more-or-less immediately, but the udp manager needs to stay open in order to process the udp tracker connection requests before sending out event=stopped. Moreover DNS resolver can be shut down after the UDP tracker is shutdown.

Location:

trunk/libtransmission

Files:

• announcer-common.h (modified) (1 diff)
• announcer-udp.c (modified) (11 diffs)
• announcer.c (modified) (7 diffs)
• announcer.h (modified) (1 diff)
• session.c (modified) (4 diffs)
• tr-udp.c (modified) (1 diff)
• tr-utp.c (modified) (1 diff)
• trevent.c (modified) (3 diffs)
• web.c (modified) (4 diffs)

trunk/libtransmission/announcer-common.h

@@ -239 +239 @@
                               void                       * user_data );
 
-void tr_tracker_udp_upkeep( tr_session * session );
+void tr_tracker_udp_start_shutdown( tr_session * session );
 
 #endif /* _TR_ANNOUNCER_COMMON_H_ */

trunk/libtransmission/announcer-udp.c

@@ -20 +20 @@
 
 #include "transmission.h"
+#include "announcer.h"
 #include "announcer-common.h"
 #include "crypto.h"
@@ -436 +437 @@
     tau_transaction_t connection_transaction_id;
 
+    time_t close_at;
+
     tr_ptrArray announces;
     tr_ptrArray scrapes;
@@ -442 +445 @@
 static void tau_tracker_upkeep( struct tau_tracker * );
 
-#if 0
 static void
 tau_tracker_free( struct tau_tracker * t )
@@ -454 +456 @@
     tr_free( t );
 }
-#endif
 
 static void
@@ -524 +525 @@
 }
 
+static tr_bool
+tau_tracker_is_empty( const struct tau_tracker * tracker )
+{
+    return tr_ptrArrayEmpty( &tracker->announces )
+        && tr_ptrArrayEmpty( &tracker->scrapes );
+}
+
 static void
 tau_tracker_upkeep( struct tau_tracker * tracker )
@@ -541 +549 @@
 
     /* are there any requests pending? */
-    if( tr_ptrArrayEmpty( &tracker->announces ) &&
-        tr_ptrArrayEmpty( &tracker->scrapes ) )
+    if( tau_tracker_is_empty( tracker ) )
         return;
 
@@ -584 +591 @@
     for( i=0, n=tr_ptrArraySize(reqs); i<n; ++i )
     {
+        tr_bool remove_request = FALSE;
         struct tau_announce_request * req = tr_ptrArrayNth( reqs, i );
         if( is_connected && !req->sent_at ) {
@@ -589 +597 @@
             req->sent_at = now;
             tau_tracker_send_request( tracker, req->payload, req->payload_len );
+            remove_request = req->callback == NULL;
         }
         else if( req->created_at + TAU_REQUEST_TTL < now ) {
             tau_announce_request_fail( tracker->session, req, FALSE, TRUE, NULL );
+            remove_request = TRUE;
+        }
+        if( tracker->close_at && ( tracker->close_at <= time(NULL) ) )
+            remove_request = TRUE;
+        if( remove_request ) {
             tau_announce_request_free( req );
             tr_ptrArrayRemove( reqs, i );
@@ -603 +617 @@
     for( i=0, n=tr_ptrArraySize(reqs); i<n; ++i )
     {
+        tr_bool remove_request = FALSE;
         struct tau_scrape_request * req = tr_ptrArrayNth( reqs, i );
         if( is_connected && !req->sent_at ) {
@@ -608 +623 @@
             req->sent_at = now;
             tau_tracker_send_request( tracker, req->payload, req->payload_len );
+            remove_request = req->callback == NULL;
         }
         else if( req->created_at + TAU_REQUEST_TTL < now ) {
             tau_scrape_request_fail( tracker->session, req, FALSE, TRUE, NULL );
+            remove_request = TRUE;
+        }
+        if( tracker->close_at && ( tracker->close_at <= time(NULL) ) )
+            remove_request = TRUE;
+        if( remove_request ) {
             tau_scrape_request_free( req );
             tr_ptrArrayRemove( reqs, i );
@@ -740 +761 @@
         tr_ptrArrayForeach( &tau->trackers,
                             (PtrArrayForeachFunc)tau_tracker_upkeep );
+}
+
+tr_bool
+tr_tracker_udp_is_empty( const tr_session * session )
+{
+    int i;
+    int n;
+    struct tr_announcer_udp * tau = session->announcer_udp;
+
+    if( tau != NULL )
+        for( i=0, n=tr_ptrArraySize(&tau->trackers); i<n; ++i )
+            if( !tau_tracker_is_empty( tr_ptrArrayNth( &tau->trackers, i ) ) )
+                return FALSE;
+
+    return TRUE;
+}
+
+/* drop dead now. */
+void
+tr_tracker_udp_close( tr_session * session )
+{
+    struct tr_announcer_udp * tau = session->announcer_udp;
+
+    if( tau != NULL )
+    {
+        session->announcer_udp = NULL;
+        tr_ptrArrayDestruct( &tau->trackers, (PtrArrayForeachFunc)tau_tracker_free );
+        tr_free( tau );
+    }
+        
+}
+
+/* start shutting down.
+   This doesn't destroy everything if there are requests,
+   but sets a deadline on how much longer to wait for the remaining ones */
+void
+tr_tracker_udp_start_shutdown( tr_session * session )
+{
+    const time_t now = time( NULL );
+    struct tr_announcer_udp * tau = session->announcer_udp;
+
+    if( tau != NULL )
+    {
+        int i, n;
+        for( i=0, n=tr_ptrArraySize(&tau->trackers); i<n; ++i )
+        {
+            struct tau_tracker * tracker = tr_ptrArrayNth( &tau->trackers, i );
+            tracker->close_at = now + 3;
+            tau_tracker_upkeep( tracker );
+        }
+    }
 }
 

trunk/libtransmission/announcer.c

@@ -125 +125 @@
     int slotsAvailable;
     int key;
-    time_t lpdUpkeepAt;
     time_t tauUpkeepAt;
 }
@@ -134 +133 @@
 {
     return announcer->slotsAvailable < 1;
-}
-
-static inline time_t
-jitterize( const int val )
-{
-    const double jitter = 0.1;
-    assert( val > 0 );
-    return val + tr_cryptoWeakRandInt((int)(1 + val * jitter));
 }
 
@@ -159 +150 @@
     a->session = session;
     a->slotsAvailable = MAX_CONCURRENT_TASKS;
-    a->lpdUpkeepAt = tr_time() + jitterize(5);
     a->upkeepTimer = evtimer_new( session->event_base, onUpkeepTimer, a );
     tr_timerAdd( a->upkeepTimer, UPKEEP_INTERVAL_SECS, 0 );
@@ -174 +164 @@
 
     flushCloseMessages( announcer );
+
+    tr_tracker_udp_start_shutdown( session );
 
     event_free( announcer->upkeepTimer );
@@ -1492 +1484 @@
 onUpkeepTimer( int foo UNUSED, short bar UNUSED, void * vannouncer )
 {
+    tr_announcer * announcer = vannouncer;
+    tr_session * session = announcer->session;
+    const tr_bool is_closing = session->isClosed;
     const time_t now = tr_time( );
-    tr_announcer * announcer = vannouncer;
-    tr_sessionLock( announcer->session );
+
+    tr_sessionLock( session );
 
     /* maybe send out some "stopped" messages for closed torrents */
@@ -1500 +1495 @@
 
     /* maybe send out some announcements to trackers */
-    announceMore( announcer );
+    if( !is_closing ) 
+        announceMore( announcer );
 
     /* TAU upkeep */
     if( announcer->tauUpkeepAt <= now ) {
         announcer->tauUpkeepAt = now + TAU_UPKEEP_INTERVAL_SECS;
-        tr_tracker_udp_upkeep( announcer->session );
+        tr_tracker_udp_upkeep( session );
     }
 
@@ -1511 +1507 @@
     tr_timerAdd( announcer->upkeepTimer, UPKEEP_INTERVAL_SECS, 0 );
 
-    tr_sessionUnlock( announcer->session );
+    tr_sessionUnlock( session );
 }
 

trunk/libtransmission/announcer.h

@@ -105 +105 @@
                             int               trackerCount );
 
+/***
+****
+***/
+
+void tr_tracker_udp_upkeep( tr_session * session );
+
+void tr_tracker_udp_close( tr_session * session );
+
+tr_bool tr_tracker_udp_is_empty( const tr_session * session );
+
+
 
 #endif /* _TR_ANNOUNCER_H_ */

trunk/libtransmission/session.c

@@ -22 +22 @@
 #include <dirent.h> /* opendir */
 
+#include <event2/dns.h> /* evdns_base_free() */
 #include <event2/event.h>
 
@@ -1734 +1735 @@
 
     tr_utpClose( session );
-    tr_udpUninit( session );
+    tr_dhtUninit( session );
 
     event_free( session->saveTimer );
@@ -1759 +1760 @@
     tr_free( torrents );
 
+    /* Close the announcer *after* closing the torrents
+       so that all the &event=stopped messages will be
+       queued to be sent by tr_announcerClose() */
+    tr_announcerClose( session );
+
+    /* and this goes *after* announcer close so that
+       it won't be idle until the announce events are sent... */
+    tr_webClose( session, TR_WEB_CLOSE_WHEN_IDLE );
+
     tr_cacheFree( session->cache );
     session->cache = NULL;
-    tr_announcerClose( session );
+
+    /* gotta keep udp running long enough to send out all
+       the &event=stopped UDP tracker messages */
+    while( !tr_tracker_udp_is_empty( session ) ) {
+        tr_tracker_udp_upkeep( session );
+        tr_wait_msec( 100 );
+    }
+
+    /* we had to wait until UDP trackers were closed before closing these: */
+    evdns_base_free( session->evdns_base, 0 );
+    session->evdns_base = NULL;
+    tr_tracker_udp_close( session );
+    tr_udpUninit( session );
+
     tr_statsClose( session );
     tr_peerMgrFree( session->peerMgr );
-    tr_webClose( session, TR_WEB_CLOSE_WHEN_IDLE );
 
     closeBlocklists( session );
@@ -1802 +1824 @@
      * for a bit while they tell the router & tracker
      * that we're closing now */
-    while( ( session->shared || session->web || session->announcer )
+    while( ( session->shared || session->web || session->announcer || session->announcer_udp )
            && !deadlineReached( deadline ) )
     {

trunk/libtransmission/tr-udp.c

@@ -290 +290 @@
 tr_udpUninit(tr_session *ss)
 {
-    tr_dhtUninit(ss);
-
     if(ss->udp_socket >= 0) {
         tr_netCloseSocket( ss->udp_socket );

trunk/libtransmission/tr-utp.c

@@ -170 +170 @@
              tr_session *ss)
 {
-    if(utp_timer == NULL)
+    if( !ss->isClosed && !utp_timer )
     {
         utp_timer = evtimer_new( ss->event_base, timer_callback, ss );

trunk/libtransmission/trevent.c

@@ -225 +225 @@
 {
     struct event_base * base;
-    struct evdns_base * evdns_base;
     tr_event_handle * eh = veh;
 
@@ -235 +234 @@
     /* create the libevent bases */
     base = event_base_new( );
-    evdns_base = evdns_base_new( base, TRUE );
 
     /* set the struct's fields */
     eh->base = base;
     eh->session->event_base = base;
-    eh->session->evdns_base = evdns_base;
+    eh->session->evdns_base = evdns_base_new( base, TRUE );
     eh->session->events = eh;
 
@@ -254 +252 @@
     /* shut down the thread */
     tr_lockFree( eh->lock );
-    evdns_base_free( evdns_base, FALSE );
     event_base_free( base );
     eh->session->events = NULL;

trunk/libtransmission/web.c

@@ -331 +331 @@
         if( web->close_mode == TR_WEB_CLOSE_NOW )
             break;
-        if( ( web->close_mode == TR_WEB_CLOSE_WHEN_IDLE ) && !taskCount )
+        if( ( web->close_mode == TR_WEB_CLOSE_WHEN_IDLE ) && ( web->tasks == NULL ) )
             break;
 
@@ -350 +350 @@
         if( msec < 0 )
             msec = THREADFUNC_MAX_SLEEP_MSEC;
+        if( session->isClosed )
+            msec = 100; /* on shutdown, call perform() more frequently */
         if( msec > 0 )
         {
@@ -369 +371 @@
             t.tv_sec =  usec / 1000000;
             t.tv_usec = usec % 1000000;
-
             tr_select( max_fd+1, &r_fd_set, &w_fd_set, &c_fd_set, &t );
         }
@@ -400 +401 @@
             }
         }
+
+#if 0
+{
+tr_list * l;
+for( l=web->tasks; l!=NULL; l=l->next )
+    fprintf( stderr, "still pending: %s\n", ((struct tr_web_task*)l->data)->url );
+}
+fprintf( stderr, "loop is ending... web is closing\n" );
+#endif
     }