- Multithreaded deletionThread (harmonized with deleteThread)

src/bittorrent.cpp

@@ -66,6 +66,8 @@ bittorrent::bittorrent(){
   downloader = new downloadThread(this);
   connect(downloader, SIGNAL(downloadFinished(QString, QString)), this, SLOT(processDownloadedFile(QString, QString)));
   connect(downloader, SIGNAL(downloadFailure(QString, QString)), this, SLOT(HandleDownloadFailure(QString, QString)));
+  // File deleter (thread)
+  deleter = new deleteThread(this);
 }
 
 // Main destructor
@@ -76,6 +78,7 @@ bittorrent::~bittorrent(){
   saveDHTEntry();
   saveFastResumeAndRatioData();
   // Delete our objects
+  delete deleter;
   delete timerAlerts;
   delete ETARefresher;
   delete downloader;
@@ -184,17 +187,10 @@ void bittorrent::deleteTorrent(QString hash, bool permanent){
     // Remove from Hard drive
     qDebug("Removing this on hard drive: %s", qPrintable(savePath+QDir::separator()+fileName));
     // Deleting in a thread to avoid GUI freeze
-    deleteThread *deleter = new deleteThread(savePath+QDir::separator()+fileName);
+    deleter->deletePath(savePath+QDir::separator()+fileName);
-    connect(deleter, SIGNAL(deletionFinished(deleteThread*)), this, SLOT(cleanDeleter(deleteThread*)));
   }
 }
 
-// slot to destroy a deleteThread once it finished deletion
-void bittorrent::cleanDeleter(deleteThread* deleter){
-  qDebug("Deleting deleteThread because it finished deletion");
-  delete deleter;
-}
-
 // Pause a running torrent
 bool bittorrent::pauseTorrent(QString hash){
   bool change = false;

src/bittorrent.h

@@ -55,6 +55,7 @@ class bittorrent : public QObject{
     QTimer *ETARefresher;
     QList<QString> fullAllocationModeList;
     QHash<QString, QList<QPair<QString, QString> > > trackersErrors;
+    deleteThread *deleter;
 
   protected:
     QString getSavePath(QString hash);
@@ -125,7 +126,6 @@ class bittorrent : public QObject{
     void setUploadLimit(QString hash, int val);
 
   protected slots:
-    void cleanDeleter(deleteThread* deleter);
     void scanDirectory();
     void readAlerts();
     void processDownloadedFile(QString, QString);

src/deleteThread.h

@@ -23,31 +23,121 @@
 #define DELETETHREAD_H
 
 #include <QThread>
+#include <QMutex>
+#include <QWaitCondition>
+#include <QMutexLocker>
 
 #include "misc.h"
 
-class deleteThread : public QThread {
+class subDeleteThread : public QThread {
   Q_OBJECT
-
   private:
     QString path;
+    bool abort;
 
-  public :
+  public:
-    deleteThread(QString _path): path(_path){
+    subDeleteThread(QObject *parent, QString path) : QThread(parent), path(path){
-      start();
+      abort = false;
     }
 
-    ~deleteThread(){
+    ~subDeleteThread(){
+      abort = true;
       wait();
     }
 
   signals:
-    void deletionFinished(deleteThread*) const;
+    // For subthreads
+    void deletionSuccessST(subDeleteThread* st, QString path);
+    void deletionFailureST(subDeleteThread* st, QString path);
+
+  protected:
+    void run(){
+      if(misc::removePath(path))
+        emit deletionSuccessST(this, path);
+      else
+        emit deletionFailureST(this, path);
+      qDebug("deletion completed for %s", (const char*)path.toUtf8());
+    }
+};
+
+class deleteThread : public QThread {
+  Q_OBJECT
 
   private:
+    QStringList path_list;
+    QMutex mutex;
+    QWaitCondition condition;
+    bool abort;
+    QList<subDeleteThread*> subThreads;
+
+  signals:
+    void deletionSuccess(QString path);
+    void deletionFailure(QString path);
+
+  public:
+    deleteThread(QObject* parent) : QThread(parent){
+      abort = false;
+    }
+
+    ~deleteThread(){
+      mutex.lock();
+      abort = true;
+      condition.wakeOne();
+      mutex.unlock();
+      subDeleteThread *st;
+      foreach(st, subThreads){
+        delete st;
+      }
+      wait();
+    }
+
+    void deletePath(QString path){
+      QMutexLocker locker(&mutex);
+      path_list << path;
+      if(!isRunning()){
+        start();
+      }else{
+        condition.wakeOne();
+      }
+    }
+
+  protected:
     void run(){
-      misc::removePath(path);
+      forever{
-      emit deletionFinished(this);
+        if(abort)
+          return;
+        mutex.lock();
+        if(path_list.size() != 0){
+          QString path = path_list.takeFirst();
+          mutex.unlock();
+          subDeleteThread *st = new subDeleteThread(0, path);
+          subThreads << st;
+          connect(st, SIGNAL(deletionSuccessST(subDownloadThread*, QString, QString)), this, SLOT(propagateDeletionSuccess(subDeleteThread*, QString)));
+          connect(st, SIGNAL(deletionFailureST(subDownloadThread*, QString, QString)), this, SLOT(propagateDeletionFailure(subDeleteThread*, QString)));
+          st->start();
+        }else{
+          condition.wait(&mutex);
+          mutex.unlock();
+        }
+      }
+    }
+  protected slots:
+    void propagateDeletionSuccess(subDeleteThread* st, QString path){
+      int index = subThreads.indexOf(st);
+      Q_ASSERT(index != -1);
+      subThreads.removeAt(index);
+      delete st;
+      emit deletionSuccess(path);
+      qDebug("%s was successfully deleted", (const char*)path.toUtf8());
+    }
+
+    void propagateDeletionFailure(subDeleteThread* st, QString path){
+      int index = subThreads.indexOf(st);
+      Q_ASSERT(index != -1);
+      subThreads.removeAt(index);
+      delete st;
+      emit deletionFailure(path);
+      std::cerr << "Could not delete path: " << (const char*)path.toUtf8() << ". Check if qBittorrent has the required rights.\n";
     }
 };
 

src/downloadThread.h

@@ -194,20 +194,16 @@ class downloadThread : public QThread {
   protected slots:
     void propagateDownloadedFile(subDownloadThread* st, QString url, QString path){
       int index = subThreads.indexOf(st);
-      if(index == -1)
+      Q_ASSERT(index != -1);
-        std::cerr << "ERROR: Couldn't delete download subThread!\n";
+      subThreads.removeAt(index);
-      else
-        subThreads.takeAt(index);
       delete st;
       emit downloadFinished(url, path);
     }
 
     void propagateDownloadFailure(subDownloadThread* st, QString url, QString reason){
       int index = subThreads.indexOf(st);
-      if(index == -1)
+      Q_ASSERT(index != -1);
-        std::cerr << "ERROR: Couldn't delete download subThread!\n";
+      subThreads.removeAt(index);
-      else
-        subThreads.takeAt(index);
       delete st;
       emit downloadFailure(url, reason);
     }