Ticket #671: r7107_ratioLimit.patch

File r7107_ratioLimit.patch, 12.9 KB (added by journey4712, 13 years ago)

ratio limit and related RPC/remote patches updated for r7107

  • libtransmission/torrent.h

     
    154154time_t*          tr_torrentGetMTimes( const tr_torrent  * tor,
    155155                                      size_t            * setmeCount );
    156156
     157void tr_queuePulseInit( struct tr_handle * handle );
     158
    157159typedef enum
    158160{
    159161    TR_VERIFY_NONE,
     
    174176
    175177    struct tr_ratecontrol *  swarmSpeed;
    176178
     179    double                   ratioLimit;
     180    int                      ratioLimitActive;
     181
    177182    int                      error;
    178183    char                     errorString[128];
    179184
  • libtransmission/rpcimpl.c

     
    364364        tr_bencDictAddInt( d, key, (int)( st->pieceDownloadSpeed * 1024 ) );
    365365    else if( !strcmp( key, "rateUpload" ) )
    366366        tr_bencDictAddInt( d, key, (int)( st->pieceUploadSpeed * 1024 ) );
     367    else if( !strcmp( key, "ratioLimit" ) )
     368        tr_bencDictAddDouble( d, key, tr_torrentGetRatioLimit( tor ) );
     369    else if( !strcmp( key, "ratioLimitMode" ) )
     370        tr_bencDictAddInt( d, key, tr_torrentGetRatioLimitActive( tor ) );
    367371    else if( !strcmp( key, "recheckProgress" ) )
    368372        tr_bencDictAddDouble( d, key, st->recheckProgress );
    369373    else if( !strcmp( key, "scrapeResponse" ) )
     
    523527    for( i = 0; i < torrentCount; ++i )
    524528    {
    525529        int64_t      tmp;
     530        double       ratio;
    526531        tr_benc *    files;
    527532        tr_torrent * tor = torrents[i];
    528533
     
    538543            setFilePriorities( tor, TR_PRI_LOW, files );
    539544        if( tr_bencDictFindList( args_in, "priority-normal", &files ) )
    540545            setFilePriorities( tor, TR_PRI_NORMAL, files );
     546        if( tr_bencDictFindInt( args_in, "ratio-limit-enabled", &tmp) )
     547            tr_torrentSetRatioLimitActive( tor, tmp );
     548        if( tr_bencDictFindDouble( args_in, "ratio-limit", &ratio ) )
     549            tr_torrentSetRatioLimit( tor, ratio );
    541550        if( tr_bencDictFindInt( args_in, "speed-limit-down", &tmp ) )
    542551            tr_torrentSetSpeedLimit( tor, TR_DOWN, tmp );
    543552        if( tr_bencDictFindInt( args_in, "speed-limit-down-enabled", &tmp ) )
     
    607616
    608617        if( tor )
    609618        {
     619            double d;
     620            if( tr_bencDictFindDouble( args_in, "ratio-limit", &d ) )
     621            {
     622                tr_torrentSetRatioLimitActive( tor, TRUE );
     623                tr_torrentSetRatioLimit( tor, d );
     624            }
     625
    610626            tr_benc fields;
    611627            tr_bencInitList( &fields, 3 );
    612628            tr_bencListAddStr( &fields, "id" );
  • libtransmission/transmission.h

     
    875875                                       tr_direction        direction );
    876876
    877877/****
     878*****  Ratio Limits
     879****/
     880
     881void tr_torrentSetRatioLimitActive( tr_torrent * tor,
     882                                    int          active );
     883
     884int tr_torrentGetRatioLimitActive( const tr_torrent * tor );
     885
     886void tr_torrentSetRatioLimit( tr_torrent * tor,
     887                              double       ratio );
     888
     889double tr_torrentGetRatioLimit( const tr_torrent * tor );
     890
     891int tr_torrentRatioLimitExceeded( tr_torrent * tor );
     892
     893/****
    878894*****  Peer Limits
    879895****/
    880896
  • libtransmission/resume.c

     
    3838#define KEY_PROGRESS        "progress"
    3939#define KEY_SPEEDLIMIT      "speed-limit"
    4040#define KEY_UPLOADED        "uploaded"
     41#define KEY_RATIO_LIMIT     "ratio-limit"
    4142
    4243#define KEY_SPEEDLIMIT_DOWN_SPEED "down-speed"
    4344#define KEY_SPEEDLIMIT_DOWN_MODE  "down-mode"
     
    408409                       tor->maxConnectedPeers );
    409410    tr_bencDictAddInt( &top, KEY_PAUSED,
    410411                       tor->isRunning ? 0 : 1 );
     412    tr_bencDictAddDouble( &top, KEY_RATIO_LIMIT,
     413                          tor->ratioLimitActive ? tor->ratioLimit : -tor->ratioLimit );
    411414    savePeers( &top, tor );
    412415    savePriorities( &top, tor );
    413416    saveDND( &top, tor );
     
    426429              uint64_t     fieldsToLoad )
    427430{
    428431    int64_t      i;
     432    double       d;
    429433    const char * str;
    430434    uint64_t     fieldsLoaded = 0;
    431435    char *       filename;
     
    516520        fieldsLoaded |= TR_FR_ACTIVITY_DATE;
    517521    }
    518522
     523    if( ( fieldsToLoad & TR_FR_RATIO_LIMIT )
     524        && tr_bencDictFindDouble( &top, KEY_RATIO_LIMIT, &d ) ) {
     525        if( d >= 0.0 ) {
     526            tor->ratioLimitActive = TRUE;
     527            tor->ratioLimit = d;
     528        } else {
     529            tor->ratioLimitActive = FALSE;
     530            tor->ratioLimit = -d;
     531        }
     532        fieldsLoaded |= TR_FR_RATIO_LIMIT;
     533    }
     534
    519535    if( fieldsToLoad & TR_FR_PEERS )
    520536        fieldsLoaded |= loadPeers( &top, tor );
    521537
  • libtransmission/resume.h

     
    2828    TR_FR_MAX_PEERS      = ( 1 << 10 ),
    2929    TR_FR_ADDED_DATE     = ( 1 << 11 ),
    3030    TR_FR_DONE_DATE      = ( 1 << 12 ),
    31     TR_FR_ACTIVITY_DATE  = ( 1 << 13 )
     31    TR_FR_ACTIVITY_DATE  = ( 1 << 13 ),
     32    TR_FR_RATIO_LIMIT    = ( 1 << 14 )
    3233};
    3334
    3435/**
  • libtransmission/session.c

     
    269269    while( !h->events )
    270270        tr_wait( 50 );
    271271
     272    tr_queuePulseInit( h );
     273
    272274    h->tag = tr_strdup( tag );
    273275    h->peerMgr = tr_peerMgrNew( h );
    274276
  • libtransmission/torrent.c

     
    4747#include "verify.h"
    4848
    4949#define MAX_BLOCK_SIZE ( 1024 * 16 )
     50#define QUEUE_PULSE_DELAY 1000
    5051
    5152/***
    5253****
     
    224225}
    225226
    226227/***
     228**** Ratio Limiting
     229***/
     230
     231void tr_torrentSetRatioLimitActive( tr_torrent * tor,
     232                                    int          active )
     233{
     234    tor->ratioLimitActive = !!active;
     235}
     236
     237int tr_torrentGetRatioLimitActive( const tr_torrent * tor )
     238{
     239    return tor->ratioLimitActive;
     240}
     241
     242void tr_torrentSetRatioLimit( tr_torrent * tor,
     243                              double       ratio )
     244{
     245    if( ratio >= 0.0 ) {
     246        tor->ratioLimit = ratio;
     247    }
     248}
     249
     250double tr_torrentGetRatioLimit( const tr_torrent * tor )
     251{
     252    return tor->ratioLimit;
     253}
     254
     255int tr_torrentRatioLimitExceeded( tr_torrent * tor )
     256{
     257    return tor->ratioLimitActive &&
     258        tr_torrentStat( tor )->ratio >= tor->ratioLimit;
     259}
     260
     261/***
    227262****
    228263***/
    229264
     
    562597    tor->checkedPieces = tr_bitfieldNew( tor->info.pieceCount );
    563598    tr_torrentUncheck( tor );
    564599
    565     tor->addedDate = time( NULL ); /* this is a default value to be
    566                                       overwritten by the resume file */
     600    /* these are default values to be overwritten by the resume file */
     601    tor->addedDate = time( NULL );
     602    tor->ratioLimitActive = FALSE;
     603    tor->ratioLimit = 1.0;
     604
    567605    loaded = tr_torrentLoadResume( tor, ~0, ctor );
    568606
    569607    doStart = tor->isRunning;
     
    18221860
    18231861    return bytesLeft;
    18241862}
     1863
     1864static int
     1865queuePulseFunc( void * vhandle )
     1866{
     1867    tr_handle * handle = (tr_handle *)vhandle;
     1868    tr_torrent * tor;
     1869
     1870    for( tor = handle->torrentList; tor; tor = tor->next ) {
     1871        if( tr_torrentGetActivity( tor ) == TR_STATUS_SEED &&
     1872            tr_torrentRatioLimitExceeded( tor ) ) {
     1873            tr_torrentSetRatioLimitActive( tor, FALSE );
     1874            tr_torrentStop( tor );
     1875        }
     1876    }
     1877    return 1;
     1878}
     1879
     1880void
     1881tr_queuePulseInit( tr_handle * handle )
     1882{
     1883    tr_timerNew( handle, queuePulseFunc, handle, QUEUE_PULSE_DELAY );
     1884}
  • daemon/remote.c

     
    7474      "G",  1, "<files>"             },
    7575    { 'i', "info",                 "Show details of the current torrent(s)",
    7676      "i",  0, NULL                  },
     77    { 'k', "ratio-limit",          "Set the seeding ratio of the current torrent(s)",
     78      "k",  1, "<ratio>"             },
     79    { 'K', "no-ratio-limit",       "Disable the seeding ratio of the current torrent(s)",
     80      "K",  0, NULL                  },
    7781    { 'l', "list",                 "List all torrents",
    7882      "l",  0, NULL                  },
    7983    { 'm', "portmap",              "Enable portmapping via NAT-PMP or UPnP",
     
    138142    return num;
    139143}
    140144
     145static double
     146dblarg( const char * arg )
     147{
     148    char *       end = NULL;
     149    const double num = strtod( arg, &end );
     150    if( *end )
     151    {
     152        fprintf( stderr, "Not a double: \"%s\"\n", arg );
     153        showUsage( );
     154    }
     155    return num;
     156}
     157
    141158static char * reqs[256]; /* arbitrary max */
    142159static int    reqCount = 0;
    143160static int    debug = 0;
     
    242259    "nextAnnounceTime", "nextScrapeTime",
    243260    "peersConnected", "peersGettingFromUs", "peersSendingToUs",
    244261    "pieceCount",     "pieceSize",          "rateDownload",
    245     "rateUpload",      "recheckProgress",
    246     "scrapeResponse", "seeders",
     262    "rateUpload",       "ratioLimit",         "ratioLimitMode",
     263    "recheckProgress",  "scrapeResponse",    "seeders",
    247264    "sizeWhenDone",    "startDate",
    248265    "status",         "timesCompleted",     "totalSize",
    249266    "uploadedEver",
     
    356373                    tr_bencListAddStr( fields, details_keys[i] );
    357374                break;
    358375
     376            case 'k':
     377                tr_bencDictAddStr( &top, "method", "torrent-set" );
     378                addIdArg( args, id );
     379                tr_bencDictAddDouble( args, "ratio-limit", dblarg( optarg ) );
     380                tr_bencDictAddInt( args, "ratio-limit-enabled", 1 );
     381                break;
     382
     383            case 'K':
     384                tr_bencDictAddStr( &top, "method", "torrent-set" );
     385                addIdArg( args, id );
     386                tr_bencDictAddInt( args, "ratio-limit-enabled", 0 );
     387                break;
     388
    359389            case 'l':
    360390                tr_bencDictAddStr( &top, "method", "torrent-get" );
    361391                tr_bencDictAddInt( &top, "tag", TAG_LIST );
     
    689719            char         buf[512];
    690720            char         buf2[512];
    691721            int64_t      i, j, k;
     722            double       d;
    692723
    693724            printf( "NAME\n" );
    694725            if( tr_bencDictFindInt( t, "id", &i ) )
     
    744775                strlratio( buf, j, i, sizeof( buf ) );
    745776                printf( "  Ratio: %s\n", buf );
    746777            }
     778            if( tr_bencDictFindDouble( t, "ratioLimit", &d ) &&
     779                tr_bencDictFindInt( t, "ratioLimitMode", &i ) )
     780                printf( "  Ratio Limit: %f\n  Ratio Active: %s\n",
     781                        d, i ? "Yes" : "No" );
    747782            if( tr_bencDictFindInt( t, "corruptEver", &i ) )
    748783            {
    749784                strlsize( buf, i, sizeof( buf ) );
  • doc/rpc-spec.txt

     
    9595   "priority-high"            | array      indices of high-priority file(s)
    9696   "priority-low"             | array      indices of low-priority file(s)
    9797   "priority-normal"          | array      indices of normal-priority file(s)
     98   "ratio-limit"              | double     maximum seed ratio
     99   "ratio-limit-enabled"      | 'boolean'  true if seeding is ratio limited
    98100   "speed-limit-down"         | number     maximum download speed (in K/s)
    99101   "speed-limit-down-enabled" | 'boolean'  true if the download speed is limited
    100102   "speed-limit-up"           | number     maximum upload speed (in K/s)
     
    164166   priorities             | array (see below)                    | n/a
    165167   rateDownload (B/s)     | number                               | tr_stat
    166168   rateUpload (B/s)       | number                               | tr_stat
     169   ratioLimit             | 'double'                             | tr_torrent
     170   ratioLimitMode         | 'boolean'                            | tr_torrent
    167171   recheckProgress        | 'double'                             | tr_stat
    168172   scrapeResponse         | string                               | tr_stat
    169173   scrapeURL              | string                               | tr_stat
     
    283287   "metainfo"         | string      base64-encoded .torrent content
    284288   "paused"           | 'boolean'   if true, don't start the torrent
    285289   "peer-limit"       | number      maximum number of peers
     290   "ratio-limit"      | double      maximum seed ratio
    286291
    287292   Either "filename" OR "metainfo" MUST be included.
    288293   All other arguments are optional.