mirror of
https://github.com/transmission/transmission
synced 2024-12-26 09:37:56 +00:00
405 lines
12 KiB
JavaScript
405 lines
12 KiB
JavaScript
/*
|
|
* Copyright © Jordan Lee, Dave Perrett and Malcolm Jarvis
|
|
* This code is licensed under the GPL version 2.
|
|
* For details, see http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
*
|
|
* Class Torrent
|
|
*/
|
|
|
|
|
|
function Torrent(controller, data)
|
|
{
|
|
this.initialize(controller, data)
|
|
}
|
|
|
|
/***
|
|
****
|
|
**** Constants
|
|
****
|
|
***/
|
|
|
|
// Torrent.fields.status
|
|
Torrent._StatusStopped = 0
|
|
Torrent._StatusCheckWait = 1
|
|
Torrent._StatusCheck = 2
|
|
Torrent._StatusDownloadWait = 3
|
|
Torrent._StatusDownload = 4
|
|
Torrent._StatusSeedWait = 5
|
|
Torrent._StatusSeed = 6
|
|
|
|
// Torrent.fields.seedRatioMode
|
|
Torrent._RatioUseGlobal = 0
|
|
Torrent._RatioUseLocal = 1
|
|
Torrent._RatioUnlimited = 2
|
|
|
|
// Torrent.fields.error
|
|
Torrent._ErrNone = 0
|
|
Torrent._ErrTrackerWarning = 1
|
|
Torrent._ErrTrackerError = 2
|
|
Torrent._ErrLocalError = 3
|
|
|
|
// TrackerStats' announceState
|
|
Torrent._TrackerInactive = 0
|
|
Torrent._TrackerWaiting = 1
|
|
Torrent._TrackerQueued = 2
|
|
Torrent._TrackerActive = 3
|
|
|
|
|
|
// fields whose values never change and are always known
|
|
Torrent._StaticFields = [
|
|
'hashString', 'id' ]
|
|
|
|
// fields whose values never change and are known upon constructon OR
|
|
// when a magnet torrent finishes downloading its metadata
|
|
Torrent._MetaDataFields = [
|
|
'addedDate', 'comment', 'creator', 'dateCreated',
|
|
'isPrivate', 'name', 'totalSize', 'pieceCount', 'pieceSize' ]
|
|
|
|
// torrent fields whose values change all the time
|
|
Torrent._DynamicFields = [
|
|
'desiredAvailable', 'downloadDir', 'downloadedEver', 'error',
|
|
'errorString', 'eta', 'haveUnchecked', 'haveValid', 'isFinished',
|
|
'leftUntilDone', 'metadataPercentComplete', 'peers', 'peersConnected',
|
|
'peersGettingFromUs', 'peersSendingToUs', 'queuePosition',
|
|
'rateDownload', 'rateUpload', 'recheckProgress', 'seedRatioLimit',
|
|
'seedRatioMode', 'sizeWhenDone', 'status', 'trackerStats',
|
|
'uploadedEver', 'uploadRatio', 'webseedsSendingToUs' ]
|
|
|
|
/***
|
|
****
|
|
**** Methods
|
|
****
|
|
***/
|
|
|
|
Torrent.prototype =
|
|
{
|
|
initialize: function(controller, data)
|
|
{
|
|
this.fields = {}
|
|
this._files = []
|
|
|
|
// these fields are set in the ctor and never change
|
|
for(var i=0, key; key=Torrent._StaticFields[i]; ++i)
|
|
if(key in data)
|
|
this.fields[key] = data[key]
|
|
|
|
this.initMetaData(data)
|
|
this._trackerStats = this.buildTrackerStats(data.trackerStats)
|
|
this.refresh(data)
|
|
},
|
|
|
|
buildTrackerStats: function(trackerStats) {
|
|
result = []
|
|
for(var i=0, tracker; tracker=trackerStats[i]; ++i) {
|
|
tier = result[tracker.tier] || []
|
|
tier.push(tracker)
|
|
result[tracker.tier] = tier
|
|
}
|
|
return result
|
|
},
|
|
|
|
initMetaData: function(data) {
|
|
|
|
var f = this.fields
|
|
|
|
// populate the metadata fields
|
|
for(var i=0, key; key=Torrent._MetaDataFields[i]; ++i) {
|
|
if(key in data) {
|
|
f[key] = data[key]
|
|
if(key === 'name')
|
|
f.collatedName = data.name.toLowerCase()
|
|
}
|
|
}
|
|
|
|
// populate the files array
|
|
if(data.files) {
|
|
for(var i=0, row; row=data.files[i]; ++i) {
|
|
this._files[i] = {
|
|
'index': i,
|
|
'torrent': this,
|
|
'length': row.length,
|
|
'name': row.name
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
refreshMetaData: function(data)
|
|
{
|
|
this.initMetaData(data)
|
|
this.fireDataChanged()
|
|
},
|
|
|
|
refresh: function(data)
|
|
{
|
|
// FIXME: unnecessary coupling... this should be handled by transmission.js
|
|
if(this.needsMetaData() && (data.metadataPercentComplete >= 1))
|
|
transmission.refreshMetaData([ this.getId() ])
|
|
|
|
var f = this.fields
|
|
|
|
// refresh the dynamic fields
|
|
for(var i=0, key; key=Torrent._DynamicFields[i]; ++i)
|
|
if(key in data)
|
|
f[key] = data[key]
|
|
|
|
this._trackerStats = this.buildTrackerStats(data.trackerStats)
|
|
|
|
if (data.fileStats)
|
|
this.refreshFiles(data)
|
|
|
|
this.fireDataChanged()
|
|
},
|
|
|
|
refreshFiles: function(data) {
|
|
for(var i=0; i<data.fileStats.length; ++i) {
|
|
var src = data.fileStats[i]
|
|
var tgt = this._files[i]
|
|
if(!tgt)
|
|
tgt = this._files[i] = { }
|
|
tgt.wanted = src.wanted
|
|
tgt.priority = src.priority
|
|
tgt.bytesCompleted = src.bytesCompleted
|
|
}
|
|
},
|
|
|
|
fireDataChanged: function()
|
|
{
|
|
$(this).trigger('dataChanged',[])
|
|
},
|
|
|
|
/****
|
|
*****
|
|
****/
|
|
|
|
// simple accessors
|
|
getCollatedName: function() { return this.fields.collatedName },
|
|
getComment: function() { return this.fields.comment },
|
|
getCreator: function() { return this.fields.creator },
|
|
getDateAdded: function() { return this.fields.addedDate },
|
|
getDateCreated: function() { return this.fields.dateCreated },
|
|
getDesiredAvailable: function() { return this.fields.desiredAvailable },
|
|
getDownloadDir: function() { return this.fields.downloadDir },
|
|
getDownloadSpeed: function() { return this.fields.rateDownload },
|
|
getDownloadedEver: function() { return this.fields.downloadedEver },
|
|
getError: function() { return this.fields.error },
|
|
getErrorString: function() { return this.fields.errorString },
|
|
getETA: function() { return this.fields.eta },
|
|
getHashString: function() { return this.fields.hashString },
|
|
getHaveValid: function() { return this.fields.haveValid },
|
|
getHave: function() { return this.getHaveValid() + this.fields.haveUnchecked },
|
|
getId: function() { return this.fields.id },
|
|
getLeftUntilDone: function() { return this.fields.leftUntilDone },
|
|
getMetadataPercentComplete: function() { return this.fields.metadataPercentComplete },
|
|
getName: function() { return this.fields.name },
|
|
getPeers: function() { return this.fields.peers },
|
|
getPeersConnected: function() { return this.fields.peersConnected },
|
|
getPeersGettingFromUs: function() { return this.fields.peersGettingFromUs },
|
|
getPeersSendingToUs: function() { return this.fields.peersSendingToUs },
|
|
getPieceCount: function() { return this.fields.pieceCount },
|
|
getPieceCount: function() { return this.fields.pieceCount },
|
|
getPieceSize: function() { return this.fields.pieceSize },
|
|
getPrivateFlag: function() { return this.fields.isPrivate },
|
|
getQueuePosition: function() { return this.fields.queuePosition },
|
|
getRecheckProgress: function() { return this.fields.recheckProgress },
|
|
getSeedRatioLimit: function() { return this.fields.seedRatioLimit },
|
|
getSeedRatioMode: function() { return this.fields.seedRatioMode },
|
|
getSizeWhenDone: function() { return this.fields.sizeWhenDone },
|
|
getStatus: function() { return this.fields.status },
|
|
getTotalSize: function() { return this.fields.totalSize },
|
|
getUploadSpeed: function() { return this.fields.rateUpload },
|
|
getUploadRatio: function() { return this.fields.uploadRatio },
|
|
getUploadedEver: function() { return this.fields.uploadedEver },
|
|
getWebseedsSendingToUs: function() { return this.fields.webseedsSendingToUs },
|
|
isFinished: function() { return this.fields.isFinished },
|
|
|
|
// derived accessors
|
|
isSeeding: function() { return this.getStatus() === Torrent._StatusSeed },
|
|
isStopped: function() { return this.getStatus() === Torrent._StatusStopped },
|
|
isChecking: function() { return this.getStatus() === Torrent._StatusCheck },
|
|
isDownloading: function() { return this.getStatus() === Torrent._StatusDownload },
|
|
isDone: function() { return this.getLeftUntilDone() < 1 },
|
|
needsMetaData: function(){ return this.getMetadataPercentComplete() < 1 },
|
|
getActivity: function() { return this.getDownloadSpeed() + this.getUploadSpeed() },
|
|
getPercentDoneStr: function() { return Transmission.fmt.percentString(100*this.getPercentDone()) },
|
|
getPercentDone: function() {
|
|
var finalSize = this.getSizeWhenDone()
|
|
if(!finalSize) return 1.0
|
|
var left = this.getLeftUntilDone()
|
|
if(!left) return 1.0
|
|
return (finalSize - left) / finalSize
|
|
},
|
|
getStateString: function() {
|
|
switch(this.getStatus()) {
|
|
case Torrent._StatusStopped: return this.isFinished() ? 'Seeding complete' : 'Paused'
|
|
case Torrent._StatusCheckWait: return 'Queued for verification'
|
|
case Torrent._StatusCheck: return 'Verifying local data'
|
|
case Torrent._StatusDownloadWait: return 'Queued for download'
|
|
case Torrent._StatusDownload: return 'Downloading'
|
|
case Torrent._StatusSeedWait: return 'Queued for seeding'
|
|
case Torrent._StatusSeed: return 'Seeding'
|
|
default: return 'error'
|
|
}
|
|
},
|
|
trackerStats: function() { return this._trackerStats },
|
|
seedRatioLimit: function(controller){
|
|
switch(this.getSeedRatioMode()) {
|
|
case Torrent._RatioUseGlobal: return controller.seedRatioLimit()
|
|
case Torrent._RatioUseLocal: return this.getSeedRatioLimit()
|
|
default: return -1
|
|
}
|
|
},
|
|
getErrorMessage: function() {
|
|
var str = this.getErrorString()
|
|
switch(this.getError()) {
|
|
case Torrent._ErrTrackerWarning:
|
|
return 'Tracker returned a warning: ' + str
|
|
case Torrent._ErrTrackerError:
|
|
return 'Tracker returned an error: ' + str
|
|
case Torrent._ErrLocalError:
|
|
return 'Error: ' + str
|
|
default:
|
|
return null
|
|
}
|
|
},
|
|
|
|
/****
|
|
*****
|
|
****/
|
|
|
|
/**
|
|
* @param filter one of Prefs._Filter*
|
|
* @param search substring to look for, or null
|
|
* @return true if it passes the test, false if it fails
|
|
*/
|
|
test: function(filter, search)
|
|
{
|
|
var pass = false
|
|
var s = this.getStatus()
|
|
|
|
switch(filter)
|
|
{
|
|
case Prefs._FilterActive:
|
|
pass = this.getPeersGettingFromUs() > 0
|
|
|| this.getPeersSendingToUs() > 0
|
|
|| this.getWebseedsSendingToUs() > 0
|
|
|| this.isChecking()
|
|
break
|
|
case Prefs._FilterSeeding:
|
|
pass = (s === Torrent._StatusSeed) || (s === Torrent._StatusSeedWait)
|
|
break
|
|
case Prefs._FilterDownloading:
|
|
pass = (s === Torrent._StatusDownload) || (s === Torrent._StatusDownloadWait)
|
|
break
|
|
case Prefs._FilterPaused:
|
|
pass = this.isStopped()
|
|
break
|
|
case Prefs._FilterFinished:
|
|
pass = this.isFinished()
|
|
break
|
|
default:
|
|
pass = true
|
|
break
|
|
}
|
|
|
|
if(!pass)
|
|
return false
|
|
|
|
if(!search || !search.length)
|
|
return pass
|
|
|
|
return this.getCollatedName().indexOf(search.toLowerCase()) !== -1
|
|
}
|
|
}
|
|
|
|
|
|
/***
|
|
****
|
|
**** SORTING
|
|
****
|
|
***/
|
|
|
|
Torrent.compareById = function(ta, tb)
|
|
{
|
|
return ta.getId() - tb.getId()
|
|
}
|
|
Torrent.compareByName = function(ta, tb)
|
|
{
|
|
return ta.getCollatedName().compareTo(tb.getCollatedName())
|
|
|| Torrent.compareById(ta, tb)
|
|
}
|
|
Torrent.compareByQueue = function(ta, tb)
|
|
{
|
|
return ta.getQueuePosition() - tb.getQueuePosition()
|
|
}
|
|
Torrent.compareByAge = function(ta, tb)
|
|
{
|
|
var a = ta.getDateAdded()
|
|
var b = tb.getDateAdded()
|
|
return (b - a) || Torrent.compareByQueue(ta, tb)
|
|
}
|
|
Torrent.compareByState = function(ta, tb)
|
|
{
|
|
var a = ta.getStatus()
|
|
var b = tb.getStatus()
|
|
return (b - a) || Torrent.compareByQueue(ta, tb)
|
|
}
|
|
Torrent.compareByActivity = function(ta, tb)
|
|
{
|
|
var a = ta.getActivity()
|
|
var b = tb.getActivity()
|
|
return (a - b) || Torrent.compareByState(ta, tb)
|
|
}
|
|
Torrent.compareByRatio = function(a, b)
|
|
{
|
|
var a = Math.ratio(ta.getUploadedEver(), ta.getDownloadedEver())
|
|
var b = Math.ratio(tb.getUploadedEver(), tb.getDownloadedEver())
|
|
return (a - b) || Torrent.compareByState(ta, tb)
|
|
}
|
|
Torrent.compareByProgress = function(ta, tb)
|
|
{
|
|
var a = ta.getPercentDone()
|
|
var b = tb.getPercentDone()
|
|
return (a - b) || Torrent.compareByRatio(ta, tb)
|
|
}
|
|
|
|
/**
|
|
* @param torrents an array of Torrent objects
|
|
* @param sortMethod one of Prefs._SortBy*
|
|
* @param sortDirection Prefs._SortAscending or Prefs._SortDescending
|
|
*/
|
|
Torrent.sortTorrents = function(torrents, sortMethod, sortDirection)
|
|
{
|
|
switch(sortMethod)
|
|
{
|
|
case Prefs._SortByActivity:
|
|
torrents.sort(this.compareByActivity)
|
|
break
|
|
case Prefs._SortByAge:
|
|
torrents.sort(this.compareByAge)
|
|
break
|
|
case Prefs._SortByQueue:
|
|
torrents.sort(this.compareByQueue)
|
|
break
|
|
case Prefs._SortByProgress:
|
|
torrents.sort(this.compareByProgress)
|
|
break
|
|
case Prefs._SortByState:
|
|
torrents.sort(this.compareByState)
|
|
break
|
|
case Prefs._SortByName:
|
|
torrents.sort(this.compareByName)
|
|
break
|
|
case Prefs._SortByRatio:
|
|
torrents.sort(this.compareByRatio)
|
|
break
|
|
default:
|
|
console.warn("unknown sort method: " + sortMethod)
|
|
break
|
|
}
|
|
|
|
if(sortDirection === Prefs._SortDescending)
|
|
torrents.reverse()
|
|
|
|
return torrents
|
|
}
|