torrent manager

fake-tracker.py

 #! /usr/bin/env python
 
 import sys
+import time
 import torrentfile
 import torrenttracker
+import torrentmanager
 import config
 
 if len(sys.argv) >= 2:
 maxRatio = config.getMaxRatio()
 maxRate = config.getMaxRatio()
 
-
-
+trackers = []
 for file in ('torrent.torrent', 'torrent2.torrent'):
     torrent = torrentfile.TorrentFile()
     torrent.readFile(file)
-    tracker = torrenttracker.TorrentTracker(torrent)
-    r = tracker.start()
-    print r
-    print tracker.getInterval()
+    trackers.append(torrent)
+
+manager = torrentmanager.TorrentManager(trackers)
+manager.start()
+run = True
+while run:
+    t = manager.getNextTime()
+    torrent = t['torrent']
+    secs = t['time']
+    print(torrent.getName() + ": Next update in " + str(secs) + " seconds")
+    time.sleep(secs)
+    print("Updating...")
+    manager.updateNextTracker()
+

torrentfile.py

 import hashlib
 import bencode
 import torrententry
+import torrenttracker
 
 class TorrentFile:
     data = ()
     info = ()
+    tracker = None
     def readFile(self, path):
         with open(path, 'rb') as f:
             bencoded = f.read()
         self.readBencoded(bencoded)
+        self.tracker = torrenttracker.TorrentTracker(self)
 
     def readBencoded(self, data):
         self.data = bencode.bdecode(data)
         self.info = self.data['info']
 
     def getName(self):
-        return self.data['name']
+        return self.info['name']
 
     def getFiles(self):
         if 'files' in self.info:
         return size
 
     def getTracker(self):
+        return self.tracker
+
+    def getAnnounce(self):
         return self.data['announce']
 
     def getHash(self):

torrentmanager.py

+#! /usr/bin/env python
+
+import copy
+import time
+import torrenttracker
+
+class TorrentManager:
+    torrents = []
+    next_torrents = []
+    last_time = 0
+    def __init__(self, torrents):
+        self.torrents = torrents
+
+    def start(self):
+        for torrent in self.torrents:
+            torrent.getTracker().start()
+
+    def resetNextTorrents(self):
+        self.last_time = int(time.time())
+        self.next_torrents = copy.copy(self.torrents)
+
+    def getNextTorrent(self):
+        if not any(self.next_torrents):
+            self.resetNextTorrents()
+        minTorrent = self.next_torrents[0]
+        for torrent in self.next_torrents:
+            if (torrent.getTracker().getInterval()
+                    < minTorrent.getTracker().getInterval()):
+                minTorrent = torrent
+        return minTorrent
+
+    def getNextTime(self):
+        torrent = self.getNextTorrent()
+        t = max(torrent.getTracker().getInterval() - (int(time.time()) - self.last_time), 0)
+        return {'time': t, 'torrent': torrent}
+
+    def updateTorrent(self, torrent = None):
+        if torrent == None:
+            torrent = self.getNextTorrent()
+        torrent.getTracker().interval(0, 0, 0)
+        self.next_torrents.remove(torrent)
+

torrenttracker.py

                 "left": left,
                 "event": event}
         headers = {"User-Agent": self.user_agent}
-        r = self.session.get(self.torrent.getTracker(), headers=headers, params=params)
+        r = self.session.get(self.torrent.getAnnounce(), headers=headers, params=params)
         data = bencode.bdecode(r.content)
         if 'interval' in data:
             self.interval = int(data['interval'])
     def start(self):
         return self.request(0, 0, 0, "started")
 
-    def stop(self):
+    def stop(self, uploaded, downloaded, left):
         return self.request(0, 0, 0, "stopped")
 
-    def complete(self):
+    def complete(self, uploaded):
         return self.request(0, 0, 0, "completed")
 
     def interval(self, uploaded, downloaded, left):

trackermanager.py

-#! /usr/bin/env python
-
-import copy
-import torrenttracker
-
-class TrackerManager:
-    trackers = []
-    next_trackers = []
-    def __init__(self, trackers):
-        self.trackers = trackers
-
-    def start(self):
-        for tracker in self.trackers:
-            tracker.start()
-
-    def resetNextTrackers(self):
-        self.next_trackers = copy.copy(self.tracker)
-
-    def getNextTracker(self):
-        if not any(self.next_trackers):
-            self.resetNextTrackers()
-        minTracker = self.next_trackers[0]
-        for tracker in self.next_trackers:
-            if tracker.getInterval() < minTracker.getInterval():
-                minTracker = tracker
-        return minTracker
-
-    def updateNextTracker(self):
-        tracker = self.getNextTracker()
-        tracker.interval(0, 0, 0)
-        self.next_trackers.remove(tracker)