download speed limit

1 files changed, 89 insertions, 4 deletions

diff --git a/module/thread_list.py b/module/thread_list.py
index d78a9b95c..9cdb5fc8f 100644
--- a/module/thread_list.py
+++ b/module/thread_list.py
@@ -21,7 +21,7 @@ from __future__ import with_statement
 from os.path import exists
 import re
 import subprocess
-from threading import RLock
+from threading import RLock, Thread
 import time
 import urllib2
 
@@ -40,6 +40,7 @@ class Thread_List(object):
         self.reconnecting = False
 
         self.select_thread()
+        self.speedManager = self.SpeedManager(self)
 
     def create_thread(self):
         """ creates thread for Py_Load_File and append thread to self.threads
@@ -207,10 +208,94 @@ class Thread_List(object):
             out.wait()
 
     def scripts_download_finished(self, pluginname, url, filename, location):
-    	map(lambda script: subprocess.Popen([script, pluginname, url, filename, location], stdout=subprocess.PIPE), self.parent.scripts['download_finished'])
+        map(lambda script: subprocess.Popen([script, pluginname, url, filename, location], stdout=subprocess.PIPE), self.parent.scripts['download_finished'])
 
     def scripts_package_finished(self, name, location): #@TODO Implement!
-    	map(lambda script: subprocess.Popen([script, name, location], stdout=subprocess.PIPE), self.parent.scripts['download_finished'])
+        map(lambda script: subprocess.Popen([script, name, location], stdout=subprocess.PIPE), self.parent.scripts['download_finished'])
 
     def scripts_reconnected(self, ip):
-    	map(lambda script: subprocess.Popen([script, ip], stdout=subprocess.PIPE), self.parent.scripts['download_finished'])
+        map(lambda script: subprocess.Popen([script, ip], stdout=subprocess.PIPE), self.parent.scripts['download_finished'])
+    
+    class SpeedManager(Thread):
+        def __init__(self, parent):
+            Thread.__init__(self)
+            self.parent = parent
+            self.running = True
+            self.lastSlowCheck = 0.0
+            
+            stat = {}
+            stat["slow_downloads"] = None
+            stat["each_speed"] = None
+            stat["each_speed_optimized"] = None
+            self.stat = stat
+            
+            self.slowCheckInterval = 60
+            self.slowCheckTestTime = 25
+            
+            self.logger = self.parent.parent.logger
+            self.start()
+        
+        def run(self):
+            while self.running:
+                time.sleep(1)
+                self.manageSpeed()
+        
+        def getMaxSpeed(self):
+            return self.parent.parent.getMaxSpeed()
+        
+        def manageSpeed(self):
+            maxSpeed = self.getMaxSpeed()
+            if maxSpeed <= 0:
+                for thread in self.parent.py_downloading:
+                    thread.plugin.req.speedLimitActive = False
+                return
+            threads = self.parent.py_downloading
+            threadCount = len(threads)
+            if threadCount <= 0:
+                return
+            eachSpeed = maxSpeed/threadCount
+            
+            currentOverallSpeed = 0
+            restSpeed = maxSpeed - currentOverallSpeed
+            speeds = []
+            for thread in threads:
+                currentOverallSpeed += thread.plugin.req.dl_speed
+                speeds.append((thread.plugin.req.dl_speed, thread.plugin.req.averageSpeed, thread))
+                thread.plugin.req.speedLimitActive = True
+            
+            if currentOverallSpeed+50 < maxSpeed:
+                for thread in self.parent.py_downloading:
+                    thread.plugin.req.speedLimitActive = False
+                return
+                
+            print "-----"
+            
+            slowCount = 0
+            slowSpeed = 0
+            if self.lastSlowCheck + self.slowCheckInterval + self.slowCheckTestTime < time.time():
+                self.lastSlowCheck = time.time()
+            if self.lastSlowCheck + self.slowCheckInterval < time.time() < self.lastSlowCheck + self.slowCheckInterval + self.slowCheckTestTime:
+                for speed in speeds:
+                    speed[2].plugin.req.isSlow = False
+            else:
+                for speed in speeds:
+                    if speed[0] <= eachSpeed-7:
+                        if speed[1] < eachSpeed-15:
+                            if speed[2].plugin.req.dl_time > 0 and speed[2].plugin.req.dl_time+30 < time.time():
+                                speed[2].plugin.req.isSlow = True
+                                if not speed[1]-5 < speed[2].plugin.req.maxSpeed/1024 < speed[1]+5:
+                                    speed[2].plugin.req.maxSpeed = (speed[1]+10)*1024
+                    if speed[2].plugin.req.isSlow:
+                        slowCount += 1
+                        slowSpeed += speed[2].plugin.req.maxSpeed/1024
+            
+            stat["slow_downloads"] = slowCount
+            stat["each_speed"] = eachSpeed
+            eachSpeed = (maxSpeed - slowSpeed) / (threadCount - slowCount)
+            stat["each_speed_optimized"] = eachSpeed
+            for speed in speeds:
+                if speed[2].plugin.req.isSlow:
+                    continue
+                speed[2].plugin.req.maxSpeed = eachSpeed*1024
+                print "max", speed[2].plugin.req.maxSpeed, "current", speed[2].plugin.req.dl_speed
+