source: trunk/qt/torrent.cc @ 8401

Last change on this file since 8401 was 8401, checked in by charles, 7 years ago

(trunk qt) #2077: doesn't show/modify the "Stop seeding torrents at ratio"

File size: 17.2 KB
Line 
1/*
2 * This file Copyright (C) 2009 Charles Kerr <charles@transmissionbt.com>
3 *
4 * This file is licensed by the GPL version 2.  Works owned by the
5 * Transmission project are granted a special exemption to clause 2(b)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id:$
11 */
12
13#include <cassert>
14#include <iostream>
15
16#include <QApplication>
17#include <QStyle>
18#include <QSet>
19#include <QString>
20#include <QFileInfo>
21#include <QVariant>
22
23#include <libtransmission/transmission.h>
24#include <libtransmission/bencode.h>
25#include <libtransmission/utils.h> /* tr_new0, tr_strdup */
26
27#include "app.h"
28#include "prefs.h"
29#include "qticonloader.h"
30#include "torrent.h"
31#include "utils.h"
32
33
34Torrent :: Torrent( Prefs& prefs, int id ):
35    myPrefs( prefs )
36{
37    for( int i=0; i<PROPERTY_COUNT; ++i )
38        assert( myProperties[i].id == i );
39
40    setInt( ID, id );
41    setIcon( MIME_ICON, QApplication::style()->standardIcon( QStyle::SP_FileIcon ) );
42}
43
44Torrent :: ~Torrent( )
45{
46}
47
48/***
49****
50***/
51
52Torrent :: Property
53Torrent :: myProperties[] =
54{
55    { ID, "id", QVariant::Int, INFO, },
56    { UPLOAD_SPEED, "rateUpload", QVariant::Int, STAT } /* B/s */,
57    { DOWNLOAD_SPEED, "rateDownload", QVariant::Int, STAT }, /* B/s */
58    { SWARM_SPEED, "swarmSpeed", QVariant::Int, STAT_EXTRA },/* KB/s */
59    { DOWNLOAD_DIR, "downloadDir", QVariant::String, STAT },
60    { ACTIVITY, "status", QVariant::Int, STAT },
61    { NAME, "name", QVariant::String, INFO },
62    { ERROR, "errorString", QVariant::String, STAT },
63    { SIZE_WHEN_DONE, "sizeWhenDone", QVariant::ULongLong, STAT },
64    { LEFT_UNTIL_DONE, "leftUntilDone", QVariant::ULongLong, STAT },
65    { HAVE_UNCHECKED, "haveUnchecked", QVariant::ULongLong, STAT },
66    { HAVE_VERIFIED, "haveValid", QVariant::ULongLong, STAT },
67    { TOTAL_SIZE, "totalSize", QVariant::ULongLong, INFO },
68    { PIECE_SIZE, "pieceSize", QVariant::ULongLong, INFO },
69    { PIECE_COUNT, "pieceCount", QVariant::Int, INFO },
70    { PEERS_GETTING_FROM_US, "peersGettingFromUs", QVariant::Int, STAT },
71    { PEERS_SENDING_TO_US, "peersSendingToUs", QVariant::Int, STAT },
72    { WEBSEEDS_SENDING_TO_US, "webseedsSendingToUs", QVariant::Int, STAT_EXTRA },
73    { PERCENT_DONE, "percentDone", QVariant::Double, STAT },
74    { PERCENT_VERIFIED, "recheckProgress", QVariant::Double, STAT },
75    { DATE_ACTIVITY, "activityDate", QVariant::DateTime, STAT_EXTRA },
76    { DATE_ADDED, "addedDate", QVariant::DateTime, INFO },
77    { DATE_STARTED, "startDate", QVariant::DateTime, STAT_EXTRA },
78    { DATE_CREATED, "dateCreated", QVariant::DateTime, INFO },
79    { PEERS_CONNECTED, "peersConnected", QVariant::Int, STAT },
80    { ETA, "eta", QVariant::Int, STAT },
81    { RATIO, "uploadRatio", QVariant::Double, STAT },
82    { DOWNLOADED_EVER, "downloadedEver", QVariant::ULongLong, STAT },
83    { UPLOADED_EVER, "uploadedEver", QVariant::ULongLong, STAT },
84    { FAILED_EVER, "corruptEver", QVariant::ULongLong, STAT_EXTRA },
85    { TRACKERS, "trackers", QVariant::StringList, INFO },
86    { MIME_ICON, "ccc", QVariant::Icon, DERIVED },
87    { SEED_RATIO_LIMIT, "seedRatioLimit", QVariant::Double, STAT_EXTRA },
88    { SEED_RATIO_MODE, "seedRatioMode", QVariant::Int, STAT_EXTRA },
89    { DOWN_LIMIT, "downloadLimit", QVariant::Int, STAT_EXTRA }, /* KB/s */
90    { DOWN_LIMITED, "downloadLimited", QVariant::Bool, STAT_EXTRA },
91    { UP_LIMIT, "uploadLimit", QVariant::Int, STAT_EXTRA }, /* KB/s */
92    { UP_LIMITED, "uploadLimited", QVariant::Bool, STAT_EXTRA },
93    { HONORS_SESSION_LIMITS, "honorsSessionLimits", QVariant::Bool, STAT_EXTRA },
94    { PEER_LIMIT, "peer-limit", QVariant::Int, STAT_EXTRA },
95    { HASH_STRING, "hashString", QVariant::String, INFO },
96    { IS_PRIVATE, "isPrivate", QVariant::Bool, INFO },
97    { COMMENT, "comment", QVariant::String, INFO },
98    { CREATOR, "creator", QVariant::String, INFO },
99    { LAST_ANNOUNCE_TIME, "lastAnnounceTime", QVariant::DateTime, STAT_EXTRA },
100    { LAST_SCRAPE_TIME, "lastScrapeTime", QVariant::DateTime, STAT_EXTRA },
101    { MANUAL_ANNOUNCE_TIME, "manualAnnounceTime", QVariant::DateTime, STAT_EXTRA },
102    { NEXT_ANNOUNCE_TIME, "nextAnnounceTime", QVariant::DateTime, STAT_EXTRA },
103    { NEXT_SCRAPE_TIME, "nextScrapeTime", QVariant::DateTime, STAT_EXTRA },
104    { SCRAPE_RESPONSE, "scrapeResponse", QVariant::String, STAT_EXTRA },
105    { ANNOUNCE_RESPONSE, "announceResponse", QVariant::String, STAT_EXTRA },
106    { ANNOUNCE_URL, "announceURL", QVariant::String, STAT_EXTRA },
107    { SEEDERS, "seeders", QVariant::Int, STAT_EXTRA },
108    { LEECHERS, "leechers", QVariant::Int, STAT_EXTRA },
109    { TIMES_COMPLETED, "timesCompleted", QVariant::Int, STAT_EXTRA },
110    { PEERS, "peers", TrTypes::PeerList, STAT_EXTRA },
111    { TORRENT_FILE, "torrentFile", QVariant::String, STAT_EXTRA },
112    { BANDWIDTH_PRIORITY, "bandwidthPriority", QVariant::Int, STAT_EXTRA }
113};
114
115Torrent :: KeyList
116Torrent :: buildKeyList( Group group )
117{
118    KeyList keys;
119
120    if( keys.empty( ) )
121        for( int i=0; i<PROPERTY_COUNT; ++i )
122            if( myProperties[i].id==ID || myProperties[i].group==group )
123                keys << myProperties[i].key;
124
125    return keys;
126}
127
128const Torrent :: KeyList&
129Torrent :: getInfoKeys( )
130{
131    static KeyList keys;
132    if( keys.isEmpty( ) )
133        keys << buildKeyList( INFO ) << "files";
134    return keys;
135}
136
137const Torrent :: KeyList&
138Torrent :: getStatKeys( )
139{
140    static KeyList keys( buildKeyList( STAT ) );
141    return keys;
142}
143
144const Torrent :: KeyList&
145Torrent :: getExtraStatKeys( )
146{
147    static KeyList keys;
148    if( keys.isEmpty( ) )
149        keys << buildKeyList( STAT_EXTRA ) << "fileStats";
150    return keys;
151}
152
153
154bool
155Torrent :: setInt( int i, int value )
156{
157    bool changed = false;
158
159    assert( 0<=i && i<PROPERTY_COUNT );
160    assert( myProperties[i].type == QVariant::Int );
161
162    if( myValues[i].isNull() || myValues[i].toInt()!=value )
163    {
164        myValues[i].setValue( value );
165        changed = true;
166    }
167
168    return changed;
169}
170
171bool
172Torrent :: setBool( int i, bool value )
173{
174    bool changed = false;
175
176    assert( 0<=i && i<PROPERTY_COUNT );
177    assert( myProperties[i].type == QVariant::Bool );
178
179    if( myValues[i].isNull() || myValues[i].toBool()!=value )
180    {
181        myValues[i].setValue( value );
182        changed = true;
183    }
184
185    return changed;
186}
187
188bool
189Torrent :: setDouble( int i, double value )
190{
191    bool changed = false;
192
193    assert( 0<=i && i<PROPERTY_COUNT );
194    assert( myProperties[i].type == QVariant::Double );
195
196    if( myValues[i].isNull() || myValues[i].toDouble()!=value )
197    {
198        myValues[i].setValue( value );
199        changed = true;
200    }
201
202    return changed;
203}
204
205bool
206Torrent :: setDateTime( int i, const QDateTime& value )
207{
208    bool changed = false;
209
210    assert( 0<=i && i<PROPERTY_COUNT );
211    assert( myProperties[i].type == QVariant::DateTime );
212
213    if( myValues[i].isNull() || myValues[i].toDateTime()!=value )
214    {
215        myValues[i].setValue( value );
216        changed = true;
217    }
218
219    return changed;
220}
221 
222bool
223Torrent :: setSize( int i, qulonglong value )
224{
225    bool changed = false;
226
227    assert( 0<=i && i<PROPERTY_COUNT );
228    assert( myProperties[i].type == QVariant::ULongLong );
229
230    if( myValues[i].isNull() || myValues[i].toULongLong()!=value )
231    {
232        myValues[i].setValue( value );
233        changed = true;
234    }
235
236    return changed;
237}
238
239bool
240Torrent :: setString( int i, const char * value )
241{
242    bool changed = false;
243
244    assert( 0<=i && i<PROPERTY_COUNT );
245    assert( myProperties[i].type == QVariant::String );
246
247    if( myValues[i].isNull() || myValues[i].toString()!=value )
248    {
249        myValues[i].setValue( QString::fromUtf8( value ) );
250        changed = true;
251    }
252
253    return changed;
254}
255
256bool
257Torrent :: setIcon( int i, const QIcon& value )
258{
259    assert( 0<=i && i<PROPERTY_COUNT );
260    assert( myProperties[i].type == QVariant::Icon );
261
262    myValues[i].setValue( value );
263    return true;
264}
265
266int
267Torrent :: getInt( int i ) const
268{
269    assert( 0<=i && i<PROPERTY_COUNT );
270    assert( myProperties[i].type == QVariant::Int );
271
272    return myValues[i].toInt( );
273}
274
275QDateTime
276Torrent :: getDateTime( int i ) const
277{
278    assert( 0<=i && i<PROPERTY_COUNT );
279    assert( myProperties[i].type == QVariant::DateTime );
280
281    return myValues[i].toDateTime( );
282}
283
284bool
285Torrent :: getBool( int i ) const
286{
287    assert( 0<=i && i<PROPERTY_COUNT );
288    assert( myProperties[i].type == QVariant::Bool );
289
290    return myValues[i].toBool( );
291}
292
293qulonglong
294Torrent :: getSize( int i ) const
295{
296    assert( 0<=i && i<PROPERTY_COUNT );
297    assert( myProperties[i].type == QVariant::ULongLong );
298
299    return myValues[i].toULongLong( );
300}
301double
302Torrent :: getDouble( int i ) const
303{
304    assert( 0<=i && i<PROPERTY_COUNT );
305    assert( myProperties[i].type == QVariant::Double );
306
307    return myValues[i].toDouble( );
308}
309QString
310Torrent :: getString( int i ) const
311{
312    assert( 0<=i && i<PROPERTY_COUNT );
313    assert( myProperties[i].type == QVariant::String );
314
315    return myValues[i].toString( );
316}
317QIcon
318Torrent :: getIcon( int i ) const
319{
320    assert( 0<=i && i<PROPERTY_COUNT );
321    assert( myProperties[i].type == QVariant::Icon );
322
323    return myValues[i].value<QIcon>();
324}
325
326/***
327****
328***/
329
330bool
331Torrent :: getSeedRatio( double& ratio ) const
332{
333    bool isLimited;
334
335    switch( seedRatioMode( ) )
336    {
337        case TR_RATIOLIMIT_SINGLE:
338            isLimited = true;
339            ratio = seedRatioLimit( );
340            break;
341
342        case TR_RATIOLIMIT_GLOBAL:
343            if(( isLimited = myPrefs.getBool( Prefs :: RATIO_ENABLED )))
344                ratio = myPrefs.getDouble( Prefs :: RATIO );
345            break;
346
347        case TR_RATIOLIMIT_UNLIMITED:
348            isLimited = false;
349            break;
350    }
351
352    return isLimited;
353}
354
355bool
356Torrent :: hasFileSubstring( const QString& substr ) const
357{
358    foreach( const TrFile file, myFiles )
359        if( file.filename.contains( substr, Qt::CaseInsensitive ) )
360            return true;
361    return false;
362}
363
364bool
365Torrent :: hasTrackerSubstring( const QString& substr ) const
366{
367    foreach( QString s, myValues[TRACKERS].toStringList() )
368        if( s.contains( substr, Qt::CaseInsensitive ) )
369            return true;
370    return false;
371}
372
373int
374Torrent :: compareRatio( const Torrent& that ) const
375{
376    const double a = ratio( );
377    const double b = that.ratio( );
378    if( (int)a == TR_RATIO_INF && (int)b == TR_RATIO_INF ) return 0;
379    if( (int)a == TR_RATIO_INF ) return 1;
380    if( (int)b == TR_RATIO_INF ) return -1;
381    if( a < b ) return -1;
382    if( a > b ) return 1;
383    return 0;
384}
385
386int
387Torrent :: compareETA( const Torrent& that ) const
388{
389    const bool haveA( hasETA( ) );
390    const bool haveB( that.hasETA( ) );
391    if( haveA && haveB ) return getETA() - that.getETA();
392    if( haveA ) return -1;
393    if( haveB ) return 1;
394    return 0;
395}
396
397int
398Torrent :: compareTracker( const Torrent& that ) const
399{
400    Q_UNUSED( that );
401
402    // FIXME
403    return 0;
404}
405
406/***
407****
408***/
409
410void
411Torrent :: updateMimeIcon( )
412{
413    const FileList& files( myFiles );
414
415    QIcon icon;
416
417    if( files.size( ) > 1 )
418        icon = QtIconLoader :: icon( "folder", QApplication::style()->standardIcon( QStyle::SP_DirIcon ) );
419    else
420        icon = Utils :: guessMimeIcon( files.at(0).filename );
421
422    setIcon( MIME_ICON, icon );
423}
424
425/***
426****
427***/
428
429void
430Torrent :: notifyComplete( ) const
431{
432    // if someone wants to implement notification, here's the hook.
433}
434
435/***
436****
437***/
438
439void
440Torrent :: update( tr_benc * d )
441{
442    bool changed = false;
443
444    for( int  i=0; i<PROPERTY_COUNT; ++i )
445    {
446        tr_benc * child = tr_bencDictFind( d, myProperties[i].key );
447        if( !child )
448            continue;
449
450        switch( myProperties[i].type )
451        {
452            case QVariant :: Int: {
453                int64_t val;
454                if( tr_bencGetInt( child, &val ) )
455                    changed |= setInt( i, val );
456                break;
457            }
458
459            case QVariant :: Bool: {
460                tr_bool val;
461                if( tr_bencGetBool( child, &val ) )
462                    changed |= setBool( i, val );
463                break;
464            }
465
466            case QVariant :: String: {
467                const char * val;
468                if( tr_bencGetStr( child, &val ) )
469                    changed |= setString( i, val );
470                break;
471            }
472
473            case QVariant :: ULongLong: {
474                int64_t val;
475                if( tr_bencGetInt( child, &val ) )
476                    changed |= setSize( i, val );
477                break;
478            }
479
480            case QVariant :: Double: {
481                double val;
482                if( tr_bencGetReal( child, &val ) )
483                    changed |= setDouble( i, val );
484                break;
485            }
486
487            case QVariant :: DateTime: {
488                int64_t val;
489                if( tr_bencGetInt( child, &val ) && val )
490                    changed |= setDateTime( i, QDateTime :: fromTime_t( val ) );
491                break;
492            }
493
494            case QVariant :: StringList:
495            case TrTypes :: PeerList:
496                break;
497
498            default:
499                assert( 0 && "unhandled type" );
500        }
501       
502    }
503
504    tr_benc * files;
505
506    if( tr_bencDictFindList( d, "files", &files ) ) {
507        const char * str;
508        int64_t intVal;
509        int i = 0;
510        myFiles.clear( );
511        tr_benc * child;
512        while(( child = tr_bencListChild( files, i ))) {
513            TrFile file;
514            file.index = i++;
515            if( tr_bencDictFindStr( child, "name", &str ) )
516                file.filename = QString::fromUtf8( str );
517            if( tr_bencDictFindInt( child, "length", &intVal ) )
518                file.size = intVal;
519            myFiles.append( file );
520        }
521        updateMimeIcon( );
522        changed = true;
523    }
524
525    if( tr_bencDictFindList( d, "fileStats", &files ) ) {
526        const int n = tr_bencListSize( files );
527        assert( n == myFiles.size( ) );
528        for( int i=0; i<n; ++i ) {
529            int64_t intVal;
530            tr_bool boolVal;
531            tr_benc * child = tr_bencListChild( files, i );
532            TrFile& file( myFiles[i] );
533            if( tr_bencDictFindInt( child, "bytesCompleted", &intVal ) )
534                file.have = intVal;
535            if( tr_bencDictFindBool( child, "wanted", &boolVal ) )
536                file.wanted = boolVal;
537            if( tr_bencDictFindInt( child, "priority", &intVal ) )
538                file.priority = intVal;
539        }
540        changed = true;
541    }
542
543    tr_benc * trackers;
544    if( tr_bencDictFindList( d, "trackers", &trackers ) ) {
545        const char * str;
546        int i = 0;
547        QStringList list;
548        tr_benc * child;
549        while(( child = tr_bencListChild( trackers, i++ )))
550            if( tr_bencDictFindStr( child, "announce", &str ))
551                list.append( QString::fromUtf8( str ) );
552        if( myValues[TRACKERS] != list ) {
553            myValues[TRACKERS].setValue( list );
554            changed = true;
555        }
556    }
557
558    tr_benc * peers;
559    if( tr_bencDictFindList( d, "peers", &peers ) ) {
560        tr_benc * child;
561        PeerList peerList;
562        int childNum = 0;
563        while(( child = tr_bencListChild( peers, childNum++ ))) {
564            double d;
565            tr_bool b;
566            int64_t i;
567            const char * str;
568            Peer peer;
569            if( tr_bencDictFindStr( child, "address", &str ) )
570                peer.address = QString::fromUtf8( str );
571            if( tr_bencDictFindStr( child, "clientName", &str ) )
572                peer.clientName = QString::fromUtf8( str );
573            if( tr_bencDictFindBool( child, "clientIsChoked", &b ) )
574                peer.clientIsChoked = b;
575            if( tr_bencDictFindBool( child, "clientIsInterested", &b ) )
576                peer.clientIsInterested = b;
577            if( tr_bencDictFindBool( child, "isDownloadingFrom", &b ) )
578                peer.isDownloadingFrom = b;
579            if( tr_bencDictFindBool( child, "isEncrypted", &b ) )
580                peer.isEncrypted = b;
581            if( tr_bencDictFindBool( child, "isIncoming", &b ) )
582                peer.isIncoming = b;
583            if( tr_bencDictFindBool( child, "isUploadingTo", &b ) )
584                peer.isUploadingTo = b;
585            if( tr_bencDictFindBool( child, "peerIsChoked", &b ) )
586                peer.peerIsChoked = b;
587            if( tr_bencDictFindBool( child, "peerIsInterested", &b ) )
588                peer.peerIsInterested = b;
589            if( tr_bencDictFindInt( child, "port", &i ) )
590                peer.port = i;
591            if( tr_bencDictFindReal( child, "progress", &d ) )
592                peer.progress = d;
593            if( tr_bencDictFindInt( child, "rateToClient", &i ) )
594                peer.rateToClient = Speed::fromBps( i );
595            if( tr_bencDictFindInt( child, "rateToPeer", &i ) )
596                peer.rateToPeer = Speed::fromBps( i );
597            peerList << peer;
598        }
599        myValues[PEERS].setValue( peerList );
600        changed = true;
601    }
602
603    if( changed )
604        emit torrentChanged( id( ) );
605}
606
607QString
608Torrent :: activityString( ) const
609{
610    QString str;
611
612    switch( getActivity( ) )
613    {
614        case TR_STATUS_CHECK_WAIT: str = tr( "Waiting to verify local data" ); break;
615        case TR_STATUS_CHECK:      str = tr( "Verifying local data" ); break;
616        case TR_STATUS_DOWNLOAD:   str = tr( "Downloading" ); break;
617        case TR_STATUS_SEED:       str = tr( "Seeding" ); break;
618        case TR_STATUS_STOPPED:    str = tr( "Paused" ); break;
619    }
620
621    return str;
622}
Note: See TracBrowser for help on using the repository browser.