Changeset 8088


Ignore:
Timestamp:
Mar 25, 2009, 7:18:00 PM (13 years ago)
Author:
charles
Message:

(trunk) #1950: Add off-peak hour bandwidth limiting to libtransmission, rpc

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/remote.c

    r8077 r8088  
    417417            case 'p':
    418418                tr_bencDictAddStr( &top, "method", "session-set" );
    419                 tr_bencDictAddInt( args, "port", numarg( optarg ) );
     419                tr_bencDictAddInt( args, TR_PREFS_KEY_PEER_PORT, numarg( optarg ) );
    420420                break;
    421421
     
    470470                char * path = absolutify( optarg );
    471471                tr_bencDictAddStr( &top, "method", "session-set" );
    472                 tr_bencDictAddStr( args, "download-dir", path );
     472                tr_bencDictAddStr( args, TR_PREFS_KEY_DOWNLOAD_DIR, path );
    473473                tr_free( path );
    474474                break;
     
    477477            case 'x':
    478478                tr_bencDictAddStr( &top, "method", "session-set" );
    479                 tr_bencDictAddInt( args, "pex-allowed", 1 );
     479                tr_bencDictAddInt( args, TR_PREFS_KEY_PEX_ENABLED, 1 );
    480480                break;
    481481
    482482            case 'X':
    483483                tr_bencDictAddStr( &top, "method", "session-set" );
    484                 tr_bencDictAddInt( args, "pex-allowed", 0 );
     484                tr_bencDictAddInt( args, TR_PREFS_KEY_PEX_ENABLED, 0 );
    485485                break;
    486486
     
    505505            case 910:
    506506                tr_bencDictAddStr( &top, "method", "session-set" );
    507                 tr_bencDictAddStr( args, "encryption", "required" );
     507                tr_bencDictAddStr( args, TR_PREFS_KEY_ENCRYPTION, "required" );
    508508                break;
    509509
    510510            case 911:
    511511                tr_bencDictAddStr( &top, "method", "session-set" );
    512                 tr_bencDictAddStr( args, "encryption", "preferred" );
     512                tr_bencDictAddStr( args, TR_PREFS_KEY_ENCRYPTION, "preferred" );
    513513                break;
    514514
    515515            case 912:
    516516                tr_bencDictAddStr( &top, "method", "session-set" );
    517                 tr_bencDictAddStr( args, "encryption", "tolerated" );
     517                tr_bencDictAddStr( args, TR_PREFS_KEY_ENCRYPTION, "tolerated" );
    518518                break;
    519519
     
    531531            case 931:
    532532                tr_bencDictAddStr( &top, "method", "session-set" );
    533                 tr_bencDictAddInt( args, "peer-limit", atoi(optarg) );
     533                tr_bencDictAddInt( args, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi(optarg) );
    534534                break;
    535535
     
    812812
    813813        printf( "LIMITS\n" );
    814         if( tr_bencDictFindInt( args, "peer-limit", &i ) )
     814        if( tr_bencDictFindInt( args, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i ) )
    815815            printf( "  Peer limit: %" PRId64 "\n", i );
    816816        if( tr_bencDictFindInt( args, "speed-limit-down-enabled", &i ) )
  • trunk/doc/rpc-spec.txt

    r8079 r8088  
    337337   string                     | value type & description
    338338   ---------------------------+-------------------------------------------------
     339   "alt-speed-limit-enabled"  | 'boolean'  true means enabled
     340   "alt-speed-limit-up"       | number     max global upload speed (in K/s)
     341   "alt-speed-limit-down"     | number     max global download speed (in K/s)
     342   "alt-speed-limit-begin"    | number     minutes after midnight. (ex: 60 means starting at 1 am)
     343   "alt-speed-limit-end"      | number     minutes after midnight. (ex: 300 means ending at 5 am)
     344   "blocklist-enabled"        | 'boolean'  true means enabled
    339345   "encryption"               | string     "required", "preferred", "tolerated"
    340346   "download-dir"             | string     default path to download torrents
    341    "peer-limit"               | number     maximum global number of peers
    342    "pex-allowed"              | 'boolean'  true means allow pex in public torrents
    343    "port"                     | number     port number
     347   "peer-limit-global"        | number     maximum global number of peers
     348   "peer-limit-per-torrent"   | number     maximum global number of peers
     349   "pex-enabled"              | 'boolean'  true means allow pex in public torrents
     350   "peer-port"                | number     port number
    344351   "port-forwarding-enabled"  | 'boolean'  true means enabled
    345352   "speed-limit-down"         | number     max global download speed (in K/s)
     
    436443         |         | yes       | torrent-get    | new arg "speed-limit-up-global-enabled"
    437444         |         | yes       | torrent-get    | new ids option "recently-active"
     445         |         | yes       | session-get    | new arg "alt-speed-limit-enabled"
     446         |         | yes       | session-get    | new arg "alt-speed-limit-up"
     447         |         | yes       | session-get    | new arg "alt-speed-limit-down"
     448         |         | yes       | session-get    | new arg "alt-speed-limit-begin"
     449         |         | yes       | session-get    | new arg "alt-speed-limit-end"
     450         |         | yes       | session-get    | new arg "blocklist-enabled"
     451         |         | yes       | session-get    | new arg "peer-limit-per-torrent"
    438452         |         |        NO | torrent-get    | removed arg "downloadLimit"
    439453         |         |        NO | torrent-get    | removed arg "downloadLimitMode"
    440454         |         |        NO | torrent-get    | removed arg "uploadLimit"
    441455         |         |        NO | torrent-get    | removed arg "uploadLimitMode"
    442    ------+---------+-----------+----------------+-------------------------------
    443 
    444 
     456         |         |        NO | session-get    | renamed "pex-allowed" to "pex-enabled"
     457         |         |        NO | session-get    | renamed "port" to "peer-port"
     458         |         |        NO | session-get    | renamed "peer-limit" to "peer-limit-global"
     459   ------+---------+-----------+----------------+-------------------------------
     460
     461
  • trunk/gtk/conf.c

    r8047 r8088  
    179179    tr_bencDictAddStr( d, PREF_KEY_STATUSBAR_STATS, "total-ratio" );
    180180
    181     tr_bencDictAddInt( d, PREF_KEY_SCHED_LIMIT_ENABLED, FALSE );
    182     tr_bencDictAddInt( d, PREF_KEY_SCHED_BEGIN,    60 * 23 ); /* 11pm */
    183     tr_bencDictAddInt( d, PREF_KEY_SCHED_END,      60 * 7 );  /* 7am */
    184     tr_bencDictAddInt( d, PREF_KEY_SCHED_DL_LIMIT, 200 );   /* 2x the other limit */
    185     tr_bencDictAddInt( d, PREF_KEY_SCHED_UL_LIMIT, 100 );   /* 2x the other limit */
    186 
    187181    tr_bencDictAddInt( d, PREF_KEY_OPTIONS_PROMPT, TRUE );
    188182
  • trunk/gtk/main.c

    r8047 r8088  
    460460}
    461461
    462 static gboolean
    463 updateScheduledLimits( gpointer data )
    464 {
    465     tr_session *    tr = data;
    466     static gboolean last_state = FALSE;
    467     gboolean        in_sched_state = FALSE;
    468 
    469     if( !pref_flag_get( PREF_KEY_SCHED_LIMIT_ENABLED ) )
    470     {
    471         in_sched_state = FALSE;
    472     }
    473     else
    474     {
    475         const int  begin_time = pref_int_get( PREF_KEY_SCHED_BEGIN );
    476         const int  end_time = pref_int_get( PREF_KEY_SCHED_END );
    477         time_t     t;
    478         struct tm *tm;
    479         int        cur_time;
    480 
    481         time( &t );
    482         tm = localtime ( &t );
    483         cur_time = ( tm->tm_hour * 60 ) + tm->tm_min;
    484 
    485         if( end_time >= begin_time )
    486         {
    487             if( ( cur_time >= begin_time ) && ( cur_time <= end_time ) )
    488                 in_sched_state = TRUE;
    489         }
    490         else
    491         {
    492             if( ( cur_time >= begin_time ) || ( cur_time <= end_time ) )
    493                 in_sched_state = TRUE;
    494         }
    495     }
    496 
    497     if( last_state != in_sched_state )
    498     {
    499         if( in_sched_state )
    500         {
    501             int limit;
    502 
    503             tr_inf ( _( "Beginning to use scheduled bandwidth limits" ) );
    504 
    505             tr_sessionSetSpeedLimitEnabled( tr, TR_DOWN, TRUE );
    506             limit = pref_int_get( PREF_KEY_SCHED_DL_LIMIT );
    507             tr_sessionSetSpeedLimit( tr, TR_DOWN, limit );
    508             tr_sessionSetSpeedLimitEnabled( tr, TR_UP, TRUE );
    509             limit = pref_int_get( PREF_KEY_SCHED_UL_LIMIT );
    510             tr_sessionSetSpeedLimit( tr, TR_UP, limit );
    511         }
    512         else
    513         {
    514             gboolean b;
    515             int      limit;
    516 
    517             tr_inf ( _( "Ending use of scheduled bandwidth limits" ) );
    518 
    519             b = pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED );
    520             tr_sessionSetSpeedLimitEnabled( tr, TR_DOWN, b );
    521             limit = pref_int_get( TR_PREFS_KEY_DSPEED );
    522             tr_sessionSetSpeedLimit( tr, TR_DOWN, limit );
    523             b = pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED );
    524             tr_sessionSetSpeedLimitEnabled( tr, TR_UP, b );
    525             limit = pref_int_get( TR_PREFS_KEY_USPEED );
    526             tr_sessionSetSpeedLimit( tr, TR_UP, limit );
    527         }
    528 
    529         last_state = in_sched_state;
    530     }
    531     else if( in_sched_state )
    532     {
    533         static int old_dl_limit = 0, old_ul_limit = 0;
    534         int        dl_limit = pref_int_get( PREF_KEY_SCHED_DL_LIMIT );
    535         int        ul_limit = pref_int_get( PREF_KEY_SCHED_UL_LIMIT );
    536 
    537         if( ( dl_limit != old_dl_limit ) || ( ul_limit != old_ul_limit ) )
    538         {
    539             tr_sessionSetSpeedLimitEnabled( tr, TR_DOWN, TRUE );
    540             tr_sessionSetSpeedLimit( tr, TR_DOWN, dl_limit );
    541             tr_sessionSetSpeedLimitEnabled( tr, TR_UP, TRUE );
    542             tr_sessionSetSpeedLimit( tr, TR_UP, ul_limit );
    543 
    544             old_dl_limit = dl_limit;
    545             old_ul_limit = ul_limit;
    546         }
    547     }
    548 
    549     return TRUE;
    550 }
    551 
    552462static void
    553463appsetup( TrWindow *      wind,
     
    601511    cbdata->timer = gtr_timeout_add_seconds( REFRESH_INTERVAL_SECONDS, updatemodel, cbdata );
    602512    updatemodel( cbdata );
    603 
    604     /* start scheduled rate timer */
    605     updateScheduledLimits ( tr_core_session( cbdata->core ) );
    606     gtr_timeout_add_seconds( 60, updateScheduledLimits, tr_core_session( cbdata->core ) );
    607513
    608514    /* either show the window or iconify it */
     
    1088994        tr_sessionSetRatioLimit( tr, limit );
    1089995    }
    1090     else if( !strncmp( key, "sched-", 6 ) )
    1091     {
    1092         updateScheduledLimits( tr );
    1093     }
    1094996    else if( !strcmp( key, TR_PREFS_KEY_PORT_FORWARDING ) )
    1095997    {
     
    11701072        const char * s = pref_string_get( key );
    11711073        tr_sessionSetProxyPassword( tr, s );
     1074    }
     1075    else if( !strcmp( key, TR_PREFS_KEY_ALT_LIMIT_ENABLED ) )
     1076    {
     1077        const gboolean enabled = pref_flag_get( key );
     1078        tr_sessionSetAltSpeedLimitEnabled( tr, enabled );
     1079    }
     1080    else if( !strcmp( key, TR_PREFS_KEY_ALT_BEGIN ) )
     1081    {
     1082        const int minutes = pref_int_get( key );
     1083        tr_sessionSetAltSpeedLimitBegin( tr, minutes );
     1084    }
     1085    else if( !strcmp( key, TR_PREFS_KEY_ALT_DL_LIMIT ) )
     1086    {
     1087        const int speed = pref_int_get( key );
     1088        tr_sessionSetAltSpeedLimit( tr, TR_DOWN, speed );
     1089    }
     1090    else if( !strcmp( key, TR_PREFS_KEY_ALT_END ) )
     1091    {
     1092        const int minutes = pref_int_get( key );
     1093        tr_sessionSetAltSpeedLimitEnd( tr, minutes );
     1094    }
     1095    else if( !strcmp( key, TR_PREFS_KEY_ALT_UL_LIMIT ) )
     1096    {
     1097        const int speed = pref_int_get( key );
     1098        tr_sessionSetAltSpeedLimit( tr, TR_UP, speed );
    11721099    }
    11731100}
  • trunk/gtk/tr-prefs.c

    r8047 r8088  
    991991{
    992992    GSList *       l;
    993     const gboolean sched_enabled = pref_flag_get(
    994         PREF_KEY_SCHED_LIMIT_ENABLED );
     993    const gboolean sched_enabled = pref_flag_get( TR_PREFS_KEY_ALT_LIMIT_ENABLED );
    995994
    996995    for( l = p->sched_widgets; l != NULL; l = l->next )
     
    11121111
    11131112    h = gtk_hbox_new( FALSE, 0 );
    1114     w2 = new_time_combo( core, PREF_KEY_SCHED_BEGIN );
     1113    w2 = new_time_combo( core, TR_PREFS_KEY_ALT_BEGIN );
    11151114    page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
    11161115    gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
     
    11181117    page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
    11191118    gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
    1120     w2 = new_time_combo( core, PREF_KEY_SCHED_END );
     1119    w2 = new_time_combo( core, TR_PREFS_KEY_ALT_END );
    11211120    page->sched_widgets = g_slist_append( page->sched_widgets, w2 );
    11221121    gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
    11231122
    11241123    s = _( "_Limit bandwidth between" );
    1125     w = new_check_button( s, PREF_KEY_SCHED_LIMIT_ENABLED, core );
     1124    w = new_check_button( s, TR_PREFS_KEY_ALT_LIMIT_ENABLED, core );
    11261125    g_signal_connect( w, "toggled", G_CALLBACK( onSchedToggled ), page );
    11271126    hig_workarea_add_row_w( t, &row, w, h, NULL );
    11281127
    1129     w = new_spin_button( PREF_KEY_SCHED_DL_LIMIT, core, 0, INT_MAX, 5 );
     1128    w = new_spin_button( TR_PREFS_KEY_ALT_DL_LIMIT, core, 0, INT_MAX, 5 );
    11301129    page->sched_widgets = g_slist_append( page->sched_widgets, w );
    11311130    l = hig_workarea_add_row( t, &row, _( "Limit d_ownload speed (KB/s):" ), w, NULL );
    11321131    page->sched_widgets = g_slist_append( page->sched_widgets, l );
    11331132
    1134     w = new_spin_button( PREF_KEY_SCHED_UL_LIMIT, core, 0, INT_MAX, 5 );
     1133    w = new_spin_button( TR_PREFS_KEY_ALT_UL_LIMIT, core, 0, INT_MAX, 5 );
    11351134    page->sched_widgets = g_slist_append( page->sched_widgets, w );
    11361135    l = hig_workarea_add_row( t, &row, _( "Limit u_pload speed (KB/s):" ), w, NULL );
  • trunk/gtk/tr-prefs.h

    r8047 r8088  
    2222 * default in tr_prefs_init_defaults( void ) */
    2323
    24 #define PREF_KEY_SCHED_LIMIT_ENABLED        "sched-limit-enabled"
    25 #define PREF_KEY_SCHED_BEGIN                "sched-begin"
    26 #define PREF_KEY_SCHED_END                  "sched-end"
    27 #define PREF_KEY_SCHED_DL_LIMIT             "sched-download-limit"
    28 #define PREF_KEY_SCHED_UL_LIMIT             "sched-upload-limit"
    2924#define PREF_KEY_OPTIONS_PROMPT             "show-options-window"
    3025#define PREF_KEY_OPEN_DIALOG_FOLDER         "open-dialog-dir"
  • trunk/libtransmission/rpcimpl.c

    r8079 r8088  
    843843    assert( idle_data == NULL );
    844844
    845     if( tr_bencDictFindStr( args_in, "download-dir", &str ) )
     845    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_LIMIT_ENABLED, &i ) )
     846        tr_sessionSetAltSpeedLimitEnabled( session, i!=0 );
     847    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_BEGIN, &i ) )
     848        tr_sessionSetAltSpeedLimitBegin( session, i );
     849    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_END, &i ) )
     850        tr_sessionSetAltSpeedLimitEnd( session, i );
     851    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_DL_LIMIT, &i ) )
     852        tr_sessionSetAltSpeedLimit( session, TR_DOWN, i );
     853    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_UL_LIMIT, &i ) )
     854        tr_sessionSetAltSpeedLimit( session, TR_UP, i );
     855    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_BLOCKLIST_ENABLED, &i ) )
     856        tr_blocklistSetEnabled( session, i!=0 );
     857    if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) )
    846858        tr_sessionSetDownloadDir( session, str );
    847     if( tr_bencDictFindInt( args_in, "peer-limit", &i ) )
     859    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i ) )
    848860        tr_sessionSetPeerLimit( session, i );
    849     if( tr_bencDictFindInt( args_in, "pex-allowed", &i ) )
     861    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i ) )
     862        tr_sessionSetPeerLimitPerTorrent( session, i );
     863    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEX_ENABLED, &i ) )
    850864        tr_sessionSetPexEnabled( session, i );
    851     if( tr_bencDictFindInt( args_in, "port", &i ) )
     865    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_PORT, &i ) )
    852866        tr_sessionSetPeerPort( session, i );
    853     if( tr_bencDictFindInt( args_in, "port-forwarding-enabled", &i ) )
     867    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PORT_FORWARDING, &i ) )
    854868        tr_sessionSetPortForwardingEnabled( session, i );
    855869    if( tr_bencDictFindInt( args_in, "speed-limit-down", &i ) )
     
    928942
    929943static const char*
    930 sessionGet( tr_session               * session,
     944sessionGet( tr_session               * s,
    931945            tr_benc                  * args_in UNUSED,
    932946            tr_benc                  * args_out,
     
    937951
    938952    assert( idle_data == NULL );
    939 
    940     tr_bencDictAddStr( d, "download-dir", tr_sessionGetDownloadDir( session ) );
    941     tr_bencDictAddInt( d, "peer-limit", tr_sessionGetPeerLimit( session ) );
    942     tr_bencDictAddInt( d, "pex-allowed", tr_sessionIsPexEnabled( session ) );
    943     tr_bencDictAddInt( d, "port", tr_sessionGetPeerPort( session ) );
    944     tr_bencDictAddInt( d, "port-forwarding-enabled", tr_sessionIsPortForwardingEnabled( session ) );
     953    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_LIMIT_ENABLED, tr_sessionIsAltSpeedLimitEnabled( s ) );
     954    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_UL_LIMIT, tr_sessionGetAltSpeedLimit( s, TR_UP ) );
     955    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_DL_LIMIT, tr_sessionGetAltSpeedLimit( s, TR_DOWN ) );
     956    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_BEGIN, tr_sessionGetAltSpeedLimitBegin( s ) );
     957    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_END, tr_sessionGetAltSpeedLimitEnd( s ) );
     958    tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
     959    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
     960    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, tr_sessionGetPeerLimit( s ) );
     961    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, tr_sessionGetPeerLimitPerTorrent( s ) );
     962    tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
     963    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
     964    tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
    945965    tr_bencDictAddInt( d, "rpc-version", 4 );
    946966    tr_bencDictAddInt( d, "rpc-version-minimum", 1 );
    947     tr_bencDictAddInt( d, "speed-limit-up", tr_sessionGetSpeedLimit( session, TR_UP ) );
    948     tr_bencDictAddInt( d, "speed-limit-up-enabled", tr_sessionIsSpeedLimitEnabled( session, TR_UP ) );
    949     tr_bencDictAddInt( d, "speed-limit-down", tr_sessionGetSpeedLimit( session, TR_DOWN ) );
    950     tr_bencDictAddInt( d, "speed-limit-down-enabled", tr_sessionIsSpeedLimitEnabled( session, TR_DOWN ) );
    951     tr_bencDictAddDouble( d, "ratio-limit", tr_sessionGetRatioLimit( session ) );
    952     tr_bencDictAddInt( d, "ratio-limit-enabled", tr_sessionIsRatioLimited( session ) );
     967    tr_bencDictAddInt( d, "speed-limit-up", tr_sessionGetSpeedLimit( s, TR_UP ) );
     968    tr_bencDictAddInt( d, "speed-limit-up-enabled", tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
     969    tr_bencDictAddInt( d, "speed-limit-down", tr_sessionGetSpeedLimit( s, TR_DOWN ) );
     970    tr_bencDictAddInt( d, "speed-limit-down-enabled", tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
     971    tr_bencDictAddDouble( d, "ratio-limit", tr_sessionGetRatioLimit( s ) );
     972    tr_bencDictAddInt( d, "ratio-limit-enabled", tr_sessionIsRatioLimited( s ) );
    953973    tr_bencDictAddStr( d, "version", LONG_VERSION_STRING );
    954     switch( tr_sessionGetEncryption( session ) ) {
     974    switch( tr_sessionGetEncryption( s ) ) {
    955975        case TR_CLEAR_PREFERRED: str = "tolerated"; break;
    956976        case TR_ENCRYPTION_REQUIRED: str = "required"; break;
  • trunk/libtransmission/session.c

    r8085 r8088  
    220220    assert( tr_bencIsDict( d ) );
    221221
    222     tr_bencDictReserve( d, 30 );
     222    tr_bencDictReserve( d, 35 );
    223223    tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        FALSE );
    224224    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR,             tr_getDefaultDownloadDir( ) );
     
    255255    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    TRUE );
    256256    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT,                 atoi( TR_DEFAULT_RPC_PORT_STR ) );
     257    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_LIMIT_ENABLED,        FALSE );
     258    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_BEGIN,                1320 ); /* 10pm */
     259    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_END,                  300 ); /* 5am */
     260    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_DL_LIMIT,             200 ); /* double the regular default */
     261    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_UL_LIMIT,             200 ); /* double the regular default */
    257262    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED,                   100 );
    258263    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED,           0 );
     
    303308    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST,            freeme[n++] = tr_sessionGetRPCWhitelist( s ) );
    304309    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    tr_sessionGetRPCWhitelistEnabled( s ) );
     310    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_LIMIT_ENABLED,        tr_sessionIsAltSpeedLimitEnabled( s ) );
     311    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_BEGIN,                tr_sessionGetAltSpeedLimitBegin( s ) );
     312    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_END,                  tr_sessionGetAltSpeedLimitEnd( s ) );
     313    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_DL_LIMIT,             tr_sessionGetAltSpeedLimit( s, TR_DOWN ) );
     314    tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_UL_LIMIT,             tr_sessionGetAltSpeedLimit( s, TR_UP ) );
    305315    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED,                   tr_sessionGetSpeedLimit( s, TR_UP ) );
    306316    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED,           tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
     
    370380static void metainfoLookupRescan( tr_session * );
    371381static void tr_sessionInitImpl( void * );
     382static int onBandwidthTimer( void * );
    372383
    373384struct init_data
     
    574585    tr_sessionSetRatioLimited( session, j );
    575586
     587    /**
     588    ***  Alternate speed limits for off-peak hours
     589    **/
     590    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_LIMIT_ENABLED, &i );
     591    assert( found );
     592    session->isAltSpeedLimited = i != 0;
     593
     594    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_BEGIN, &i )
     595         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_END, &j );
     596    assert( found );
     597    session->altSpeedBeginTime = i;
     598    session->altSpeedEndTime = j;
     599
     600    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_DL_LIMIT, &i )
     601         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_UL_LIMIT, &j );
     602    assert( found );
     603    session->altSpeedLimit[TR_DOWN] = i;
     604    session->altSpeedLimit[TR_UP] = j;
     605
    576606    /* initialize the blocklist */
    577607    filename = tr_buildPath( session->configDir, "blocklists", NULL );
     
    589619    assert( tr_isSession( session ) );
    590620
     621    session->bandwidthTimer = tr_timerNew( session, onBandwidthTimer, session, 60000 );
     622
    591623    /* first %s is the application name
    592624       second %s is the version number */
     
    777809***/
    778810
     811static tr_bool
     812isAltTime( const tr_session * session )
     813{
     814    const time_t now = time( NULL );
     815    struct tm tm;
     816    int minutes;
     817
     818    tr_localtime_r( &now, &tm );
     819    minutes = tm.tm_hour*60 + tm.tm_min;
     820
     821    if( session->altSpeedBeginTime <= session->altSpeedEndTime )
     822    {
     823        return ( session->altSpeedBeginTime <= minutes )
     824            && ( minutes < session->altSpeedEndTime );
     825    }
     826    else /* goes past midnight */
     827    {
     828        return ( minutes >= session->altSpeedBeginTime )
     829            || ( minutes < session->altSpeedEndTime );
     830    }
     831}
     832
     833static int
     834getActiveSpeedLimit( const tr_session * session, tr_direction dir )
     835{
     836    int val;
     837
     838    if( tr_sessionIsAltSpeedLimitEnabled( session ) && session->isAltTime )
     839        val = tr_sessionGetAltSpeedLimit( session, dir );
     840    else if( tr_sessionIsSpeedLimitEnabled( session, dir ) )
     841        val = tr_sessionGetSpeedLimit( session, dir );
     842    else
     843        val = -1;
     844
     845    return val;
     846}
     847
    779848static void
    780849updateBandwidth( tr_session * session, tr_direction dir )
    781850{
    782     tr_bool zeroCase;
    783 
    784     assert( tr_isSession( session ) );
    785 
    786     zeroCase = session->speedLimit[dir] < 1 && session->isSpeedLimited[dir];
    787 
    788     tr_bandwidthSetLimited( session->bandwidth, dir, session->isSpeedLimited[dir] && !zeroCase );
    789 
    790     tr_bandwidthSetDesiredSpeed( session->bandwidth, dir, session->speedLimit[dir] );
     851    const int limit = getActiveSpeedLimit( session, dir );
     852    const tr_bool isLimited = limit >= 0;
     853    const tr_bool zeroCase = isLimited && !limit;
     854
     855    tr_bandwidthSetLimited( session->bandwidth, dir, isLimited && !zeroCase );
     856
     857    tr_bandwidthSetDesiredSpeed( session->bandwidth, dir, limit );
     858}
     859
     860/* this is called once a minute to:
     861 * (1) update session->isAltTime
     862 * (2) alter the speed limits when the alt limits go on and off */
     863static int
     864onBandwidthTimer( void * vsession )
     865{
     866    tr_session * session = vsession;
     867    tr_bool wasAltTime;
     868
     869    assert( tr_isSession( session ) );
     870
     871    wasAltTime = session->isAltTime;
     872    session->isAltTime = isAltTime( session );
     873
     874    if( tr_sessionIsAltSpeedLimitEnabled( session ) && ( wasAltTime != session->isAltTime ) )
     875    {
     876        updateBandwidth( session, TR_UP );
     877        updateBandwidth( session, TR_DOWN );
     878
     879        if( session->altCallback != NULL )
     880            (*session->altCallback)( session, session->isAltTime, session->altCallbackUserData );
     881    }
     882
     883    return TRUE; /* invoke again when another minute's passed */
    791884}
    792885
     
    832925    return session->speedLimit[dir];
    833926}
     927
     928tr_bool
     929tr_sessionIsAltSpeedLimitTime( const tr_session  * session )
     930{
     931    assert( tr_isSession( session ) );
     932
     933    return session->isAltTime;
     934}
     935
     936void
     937tr_sessionSetAltSpeedLimitEnabled( tr_session   * session,
     938                                   tr_bool        isEnabled )
     939{
     940    assert( tr_isSession( session ) );
     941    assert( tr_isBool( isEnabled ) );
     942
     943    session->isAltSpeedLimited = isEnabled;
     944
     945    onBandwidthTimer( session );
     946}
     947
     948tr_bool
     949tr_sessionIsAltSpeedLimitEnabled( const tr_session  * session )
     950{
     951    assert( tr_isSession( session ) );
     952
     953    return session->isAltSpeedLimited;
     954}
     955
     956void
     957tr_sessionSetAltSpeedLimit( tr_session        * session,
     958                            tr_direction        dir,
     959                            int                 desiredSpeed )
     960{
     961    assert( tr_isSession( session ) );
     962    assert( tr_isDirection( dir ) );
     963    assert( desiredSpeed >= 0 );
     964
     965    session->altSpeedLimit[dir] = desiredSpeed;
     966    updateBandwidth( session, dir );
     967}
     968
     969int
     970tr_sessionGetAltSpeedLimit( const tr_session  * session,
     971                            tr_direction        dir )
     972{
     973    assert( tr_isSession( session ) );
     974    assert( tr_isDirection( dir ) );
     975
     976    return session->altSpeedLimit[dir];
     977}
     978
     979void
     980tr_sessionSetAltSpeedLimitBegin( tr_session * session, int minutesSinceMidnight )
     981{
     982    assert( tr_isSession( session ) );
     983
     984    session->altSpeedBeginTime = minutesSinceMidnight;
     985}
     986
     987int
     988tr_sessionGetAltSpeedLimitBegin( const tr_session * session )
     989{
     990    assert( tr_isSession( session ) );
     991
     992    return session->altSpeedBeginTime;
     993}
     994
     995void
     996tr_sessionSetAltSpeedLimitEnd( tr_session * session, int minutesSinceMidnight )
     997{
     998    assert( tr_isSession( session ) );
     999
     1000    session->altSpeedEndTime = minutesSinceMidnight;
     1001}
     1002
     1003int
     1004tr_sessionGetAltSpeedLimitEnd( const tr_session * session )
     1005{
     1006    assert( tr_isSession( session ) );
     1007
     1008    return session->altSpeedEndTime;
     1009}
     1010
     1011void
     1012tr_sessionSetAltSpeedCallback( tr_session         * session,
     1013                               tr_alt_speed_func    func,
     1014                               void               * userData )
     1015{
     1016    assert( tr_isSession( session ) );
     1017
     1018    session->altCallback = func;
     1019    session->altCallbackUserData = userData;
     1020}
     1021
     1022void
     1023tr_sessionClearAltSpeedCallback( tr_session * session )
     1024{
     1025    tr_sessionSetAltSpeedCallback( session, NULL, NULL );
     1026}
     1027
    8341028
    8351029/***
     
    9151109    assert( tr_isSession( session ) );
    9161110
     1111    tr_timerFree( &session->bandwidthTimer );
    9171112    tr_statsClose( session );
    9181113    tr_sharedShuttingDown( session->shared );
  • trunk/libtransmission/session.h

    r7888 r8088  
    7171    tr_bool                      isSpeedLimited[2];
    7272    int                          speedLimit[2];
     73    tr_bool                      isAltSpeedLimited;
     74    int                          altSpeedBeginTime;
     75    int                          altSpeedEndTime;
     76    int                          altSpeedLimit[2];
     77    tr_bool                      isAltTime;
     78    tr_alt_speed_func          * altCallback;
     79    void                       * altCallbackUserData;
     80
     81
    7382    int                          magicNumber;
    7483
     
    123132    int                          metainfoLookupCount;
    124133
     134    struct tr_timer            * bandwidthTimer;
     135
    125136    /* the size of the output buffer for peer connections */
    126137    int so_sndbuf;
  • trunk/libtransmission/transmission.h

    r8085 r8088  
    152152#define TR_DEFAULT_PEER_LIMIT_TORRENT_STR "60"
    153153
     154#define TR_PREFS_KEY_ALT_LIMIT_ENABLED          "alt-speed-limit-enabled"
     155#define TR_PREFS_KEY_ALT_BEGIN                  "alt-speed-limit-begin"
     156#define TR_PREFS_KEY_ALT_DL_LIMIT               "alt-speed-limit-down"
     157#define TR_PREFS_KEY_ALT_END                    "alt-speed-limit-end"
     158#define TR_PREFS_KEY_ALT_UL_LIMIT               "alt-speed-limit-up"
    154159#define TR_PREFS_KEY_BLOCKLIST_ENABLED          "blocklist-enabled"
    155160#define TR_PREFS_KEY_DOWNLOAD_DIR               "download-dir"
     
    231236 * FIXME: this belongs in libtransmissionapp
    232237 *
     238 * @param dictionary pointer to an uninitialized tr_benc
    233239 * @param configDir the configuration directory to find settings.json
    234  * @param initme pointer to an uninitialized tr_benc
    235  * @param appName examples: Transmission, transmission-daemon
     240 * @param appName if configDir is empty, appName is used to get the default config dir.
    236241 * @see tr_sessionGetDefaultSettings()
    237242 * @see tr_sessionInit()
     
    549554tr_direction;
    550555
     556/***
     557****
     558***/
     559
    551560void       tr_sessionSetSpeedLimitEnabled ( tr_session        * session,
    552561                                            tr_direction        direction,
     
    562571int        tr_sessionGetSpeedLimit        ( const tr_session  * session,
    563572                                            tr_direction        direction );
     573
     574/***
     575****
     576***/
     577
     578typedef void ( tr_alt_speed_func )( tr_session * session,
     579                                    tr_bool      isAltActive,
     580                                    void       * userData );
     581
     582/**
     583 * Register to be notified whenever the alternate speed limits go on and off.
     584 *
     585 * func is invoked FROM LIBTRANSMISSION'S THREAD!
     586 * This means func must be fast (to avoid blocking peers),
     587 * shouldn't call libtransmission functions (to avoid deadlock),
     588 * and shouldn't modify client-level memory without using a mutex!
     589 */
     590void tr_sessionSetAltSpeedCallback( tr_session         * session,
     591                                    tr_alt_speed_func    func,
     592                                    void               * userData );
     593
     594void tr_sessionClearAltSpeedCallback( tr_session * session );
     595
     596
     597void       tr_sessionSetAltSpeedLimitEnabled( tr_session   * session,
     598                                              tr_bool        isEnabled );
     599
     600tr_bool    tr_sessionIsAltSpeedLimitEnabled( const tr_session  * session );
     601
     602/** @return true if the current time is between the alt begin and end times */
     603tr_bool    tr_sessionIsAltSpeedLimitTime( const tr_session  * session );
     604
     605void       tr_sessionSetAltSpeedLimitBegin( tr_session * session,
     606                                            int          minutesSinceMidnight );
     607
     608int        tr_sessionGetAltSpeedLimitBegin( const tr_session * session );
     609
     610void       tr_sessionSetAltSpeedLimitEnd( tr_session * session,
     611                                          int          minutesSinceMidnight );
     612
     613int        tr_sessionGetAltSpeedLimitEnd( const tr_session * session );
     614
     615void       tr_sessionSetAltSpeedLimit( tr_session        * session,
     616                                       tr_direction        direction,
     617                                       int                 KiB_sec );
     618
     619int        tr_sessionGetAltSpeedLimit( const tr_session  * session,
     620                                       tr_direction        direction );
     621
     622/***
     623****
     624***/
    564625
    565626void       tr_sessionSetRatioLimited      ( tr_session        * session,
  • trunk/web/javascript/transmission.js

    r8062 r8088  
    724724                var up_limited    = prefs[RPC._UpSpeedLimited];
    725725               
    726                 $('div.download_location input')[0].value = prefs['download-dir'];
    727                 $('div.port input')[0].value              = prefs['port'];
     726                $('div.download_location input')[0].value = prefs[RPC._DownloadDir];
     727                $('div.port input')[0].value              = prefs[RPC._PeerPort];
    728728                $('div.auto_start input')[0].checked      = prefs[Prefs._AutoStart];
    729729                $('input#limit_download')[0].checked      = down_limited == 1;
  • trunk/web/javascript/transmission.remote.js

    r8074 r8088  
    1818RPC._DownSpeedLimit         = 'speed-limit-down';
    1919RPC._DownloadDir            = 'download-dir';
    20 RPC._PeerPort               = 'port';
     20RPC._PeerPort               = 'peer-port';
    2121RPC._UpSpeedLimited         = 'speed-limit-up-enabled';
    2222RPC._DownSpeedLimited       = 'speed-limit-down-enabled';
Note: See TracChangeset for help on using the changeset viewer.