kget/core/transfergroupscheduler.cpp

   1 /* This file is part of the KDE project
   2
   3    Copyright (C) 2008 Lukas Appelhans <l.appelhans@gmx.de>
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public
   7    License as published by the Free Software Foundation; either
   8    version 2 of the License, or (at your option) any later version.
   9 */
  10 #include "transfergroupscheduler.h"
  11
  12 #include "kget.h"
  13 #include "transfergrouphandler.h"
  14 #include "settings.h"
  15
  16 TransferGroupScheduler::TransferGroupScheduler()
  17   : Scheduler(),
  18     m_downloadLimit(0),
  19     m_uploadLimit(0)
  20 {
  21 }
  22
  23 TransferGroupScheduler::~TransferGroupScheduler()
  24 {
  25 }
  26
  27 void TransferGroupScheduler::jobQueueChangedEvent(JobQueue * queue, JobQueue::Status status)
  28 {
  29     Scheduler::jobQueueChangedEvent(queue, status);
  30 }
  31
  32 void TransferGroupScheduler::jobQueueMovedJobEvent(JobQueue * queue, Job * job)
  33 {
  34     Scheduler::jobQueueMovedJobEvent(queue, job);
  35 }
  36
  37 void TransferGroupScheduler::jobQueueAddedJobEvent(JobQueue * queue, Job * job)
  38 {
  39     Scheduler::jobQueueAddedJobEvent(queue, job);
  40 }
  41
  42 void TransferGroupScheduler::jobQueueRemovedJobEvent(JobQueue * queue, Job * job)
  43 {
  44     Scheduler::jobQueueRemovedJobEvent(queue, job);
  45 }
  46
  47 void TransferGroupScheduler::jobChangedEvent(Job * job, Job::Status status)
  48 {
  49     Scheduler::jobChangedEvent(job, status);
  50 }
  51
  52 void TransferGroupScheduler::jobChangedEvent(Job * job, Job::Policy status)
  53 {
  54     Scheduler::jobChangedEvent(job, status);
  55 }
  56
  57 void TransferGroupScheduler::calculateSpeedLimits()
  58 {
  59     calculateDownloadLimit();
  60     calculateUploadLimit();
  61 }
  62
  63 void TransferGroupScheduler::calculateDownloadLimit()
  64 {
  65     int n = KGet::allTransferGroups().count();
  66     int pool = 0;//We create a pool where we have some KiB/s to go to other groups...
  67     QList<TransferGroupHandler*> transfergroupsNeedSpeed;
  68     foreach (TransferGroupHandler *handler, KGet::allTransferGroups())
  69     {
  70         if (!Settings::speedLimit())
  71             handler->setDownloadLimit(0, Transfer::InvisibleSpeedLimit);
  72         else if (handler->transfers().count() < 1)
  73         {
  74             pool = pool + downloadLimit() / n;
  75         }
  76         else if (downloadLimit() == 0 && handler->downloadLimit(Transfer::VisibleSpeedLimit) != 0)
  77             continue;
  78         else if (downloadLimit() == 0 && handler->downloadLimit(Transfer::VisibleSpeedLimit) == 0)
  79             handler->setDownloadLimit(0, Transfer::InvisibleSpeedLimit);
  80         else if (handler->downloadLimit(Transfer::VisibleSpeedLimit) < downloadLimit() / n
  81                                                && handler->downloadLimit(Transfer::VisibleSpeedLimit) != 0)
  82             /*If the handler's visible download limit is under the new one,
  83                            we move the KiB/s which are different to the pool*/
  84             pool = pool + (downloadLimit() / n - handler->downloadLimit(Transfer::VisibleSpeedLimit));
  85         else if (handler->downloadSpeed() + 10 < downloadLimit() / n)
  86         {
  87             /*When the downloadSpeed of the handler is under the new downloadLimit + 10 then we
  88                     set the downloadLimit to the downloadSpeed + 10*/
  89             pool = pool + downloadLimit() / n - handler->downloadSpeed() + 10;
  90             handler->setDownloadLimit(handler->downloadSpeed() + 10, Transfer::InvisibleSpeedLimit);
  91         }
  92         else
  93         {
  94             handler->setDownloadLimit(downloadLimit() / n, Transfer::InvisibleSpeedLimit);
  95             transfergroupsNeedSpeed.append(handler);
  96         }
  97     }
  98     foreach (TransferGroupHandler *handler, transfergroupsNeedSpeed)
  99     {
 100         handler->setDownloadLimit(downloadLimit() / n + pool / transfergroupsNeedSpeed.count(), Transfer::InvisibleSpeedLimit);
 101     }
 102 }
 103
 104 void TransferGroupScheduler::calculateUploadLimit()
 105 {
 106     int n = KGet::allTransferGroups().count();
 107     kDebug(5001) << n;
 108     int pool = 0;//We create a pool where we have some KiB/s to go to other groups...
 109     QList<TransferGroupHandler*> transfergroupsNeedSpeed;
 110     foreach (TransferGroupHandler *handler, KGet::allTransferGroups())
 111     {
 112         if (!Settings::speedLimit())
 113             handler->setUploadLimit(0, Transfer::InvisibleSpeedLimit);
 114         else if (handler->transfers().count() < 1)
 115             pool = pool + uploadLimit() / n;
 116         else if (uploadLimit() == 0 && handler->uploadLimit(Transfer::VisibleSpeedLimit) != 0)
 117             continue;
 118         else if (uploadLimit() == 0 && handler->uploadLimit(Transfer::VisibleSpeedLimit) == 0)
 119             handler->setUploadLimit(0, Transfer::InvisibleSpeedLimit);
 120         else if (handler->uploadLimit(Transfer::VisibleSpeedLimit) < uploadLimit() / n && handler->uploadLimit(Transfer::VisibleSpeedLimit) != 0)
 121             /*If the handler's visible download limit is under the new one,
 122                            we move the KiB/s which are different to the pool*/
 123             pool = pool + (uploadLimit() / n - handler->uploadLimit(Transfer::VisibleSpeedLimit));
 124         else if (handler->uploadSpeed() + 10 < uploadLimit() / n)
 125         {
 126             /*When the downloadSpeed of the handler is under the new downloadLimit + 10 then we
 127                     set the downloadLimit to the downloadSpeed + 10*/
 128             pool = pool + uploadLimit() / n - handler->uploadSpeed() + 10;
 129             handler->setUploadLimit(handler->uploadSpeed() + 10, Transfer::InvisibleSpeedLimit);
 130         }
 131         else
 132         {
 133             handler->setUploadLimit(uploadLimit() / n, Transfer::InvisibleSpeedLimit);
 134             transfergroupsNeedSpeed.append(handler);
 135         }
 136     }
 137     foreach (TransferGroupHandler *handler, transfergroupsNeedSpeed)
 138     {
 139         handler->setUploadLimit(uploadLimit() / n + pool / transfergroupsNeedSpeed.count(), Transfer::InvisibleSpeedLimit);
 140     }
 141 }
 142
 143 void TransferGroupScheduler::setDownloadLimit(int limit)
 144 {
 145     m_downloadLimit = limit;
 146     calculateDownloadLimit();
 147 }
 148
 149 void TransferGroupScheduler::setUploadLimit(int limit)
 150 {
 151     m_uploadLimit = limit;
 152     calculateUploadLimit();
 153 }
 154
 155 #include "transfergroupscheduler.moc"