src/base/torrentfileswatcher.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2021-2023  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2010  Christian Kandeler, Christophe Dumez <chris@qbittorrent.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * In addition, as a special exception, the copyright holders give permission to
  21  * link this program with the OpenSSL project's "OpenSSL" library (or with
  22  * modified versions of it that use the same license as the "OpenSSL" library),
  23  * and distribute the linked executables. You must obey the GNU General Public
  24  * License in all respects for all of the code used other than "OpenSSL".  If you
  25  * modify file(s), you may extend this exception to your version of the file(s),
  26  * but you are not obligated to do so. If you do not wish to do so, delete this
  27  * exception statement from your version.
  28  */
  29
  30 #include "torrentfileswatcher.h"
  31
  32 #include <chrono>
  33
  34 #include <QtAssert>
  35 #include <QDir>
  36 #include <QDirIterator>
  37 #include <QFile>
  38 #include <QFileSystemWatcher>
  39 #include <QJsonDocument>
  40 #include <QJsonObject>
  41 #include <QSet>
  42 #include <QThread>
  43 #include <QTimer>
  44 #include <QVariant>
  45
  46 #include "base/algorithm.h"
  47 #include "base/bittorrent/torrentcontentlayout.h"
  48 #include "base/bittorrent/session.h"
  49 #include "base/bittorrent/torrent.h"
  50 #include "base/exceptions.h"
  51 #include "base/global.h"
  52 #include "base/logger.h"
  53 #include "base/profile.h"
  54 #include "base/settingsstorage.h"
  55 #include "base/tagset.h"
  56 #include "base/utils/fs.h"
  57 #include "base/utils/io.h"
  58 #include "base/utils/string.h"
  59
  60 using namespace std::chrono_literals;
  61
  62 const std::chrono::seconds WATCH_INTERVAL {10};
  63 const int MAX_FAILED_RETRIES = 5;
  64 const QString CONF_FILE_NAME = u"watched_folders.json"_s;
  65
  66 const QString OPTION_ADDTORRENTPARAMS = u"add_torrent_params"_s;
  67 const QString OPTION_RECURSIVE = u"recursive"_s;
  68
  69 namespace
  70 {
  71     TorrentFilesWatcher::WatchedFolderOptions parseWatchedFolderOptions(const QJsonObject &jsonObj)
  72     {
  73         TorrentFilesWatcher::WatchedFolderOptions options;
  74         options.addTorrentParams = BitTorrent::parseAddTorrentParams(jsonObj.value(OPTION_ADDTORRENTPARAMS).toObject());
  75         options.recursive = jsonObj.value(OPTION_RECURSIVE).toBool();
  76
  77         return options;
  78     }
  79
  80     QJsonObject serializeWatchedFolderOptions(const TorrentFilesWatcher::WatchedFolderOptions &options)
  81     {
  82         return {{OPTION_ADDTORRENTPARAMS, BitTorrent::serializeAddTorrentParams(options.addTorrentParams)},
  83                 {OPTION_RECURSIVE, options.recursive}};
  84     }
  85 }
  86
  87 class TorrentFilesWatcher::Worker final : public QObject
  88 {
  89     Q_OBJECT
  90     Q_DISABLE_COPY_MOVE(Worker)
  91
  92 public:
  93     Worker(QFileSystemWatcher *watcher);
  94
  95 public slots:
  96     void setWatchedFolder(const Path &path, const TorrentFilesWatcher::WatchedFolderOptions &options);
  97     void removeWatchedFolder(const Path &path);
  98
  99 signals:
 100     void torrentFound(const BitTorrent::TorrentDescriptor &torrentDescr, const BitTorrent::AddTorrentParams &addTorrentParams);
 101
 102 private:
 103     void onTimeout();
 104     void scheduleWatchedFolderProcessing(const Path &path);
 105     void processWatchedFolder(const Path &path);
 106     void processFolder(const Path &path, const Path &watchedFolderPath, const TorrentFilesWatcher::WatchedFolderOptions &options);
 107     void processFailedTorrents();
 108     void addWatchedFolder(const Path &path, const TorrentFilesWatcher::WatchedFolderOptions &options);
 109     void updateWatchedFolder(const Path &path, const TorrentFilesWatcher::WatchedFolderOptions &options);
 110
 111     QFileSystemWatcher *m_watcher = nullptr;
 112     QTimer *m_watchTimer = nullptr;
 113     QHash<Path, TorrentFilesWatcher::WatchedFolderOptions> m_watchedFolders;
 114     QSet<Path> m_watchedByTimeoutFolders;
 115
 116     // Failed torrents
 117     QTimer *m_retryTorrentTimer = nullptr;
 118     QHash<Path, QHash<Path, int>> m_failedTorrents;
 119 };
 120
 121 TorrentFilesWatcher *TorrentFilesWatcher::m_instance = nullptr;
 122
 123 void TorrentFilesWatcher::initInstance()
 124 {
 125     if (!m_instance)
 126         m_instance = new TorrentFilesWatcher;
 127 }
 128
 129 void TorrentFilesWatcher::freeInstance()
 130 {
 131     delete m_instance;
 132     m_instance = nullptr;
 133 }
 134
 135 TorrentFilesWatcher *TorrentFilesWatcher::instance()
 136 {
 137     return m_instance;
 138 }
 139
 140 TorrentFilesWatcher::TorrentFilesWatcher(QObject *parent)
 141     : QObject(parent)
 142     , m_ioThread {new QThread}
 143     , m_asyncWorker {new TorrentFilesWatcher::Worker(new QFileSystemWatcher(this))}
 144 {
 145     connect(m_asyncWorker, &TorrentFilesWatcher::Worker::torrentFound, this, &TorrentFilesWatcher::onTorrentFound);
 146
 147     m_asyncWorker->moveToThread(m_ioThread.get());
 148     connect(m_ioThread.get(), &QThread::finished, m_asyncWorker, &QObject::deleteLater);
 149     m_ioThread->setObjectName("TorrentFilesWatcher m_ioThread");
 150     m_ioThread->start();
 151
 152     load();
 153 }
 154
 155 void TorrentFilesWatcher::load()
 156 {
 157     const int fileMaxSize = 10 * 1024 * 1024;
 158     const Path path = specialFolderLocation(SpecialFolder::Config) / Path(CONF_FILE_NAME);
 159
 160     const auto readResult = Utils::IO::readFile(path, fileMaxSize);
 161     if (!readResult)
 162     {
 163         if (readResult.error().status == Utils::IO::ReadError::NotExist)
 164         {
 165             loadLegacy();
 166             return;
 167         }
 168
 169         LogMsg(tr("Failed to load Watched Folders configuration. %1").arg(readResult.error().message), Log::WARNING);
 170         return;
 171     }
 172
 173     QJsonParseError jsonError;
 174     const QJsonDocument jsonDoc = QJsonDocument::fromJson(readResult.value(), &jsonError);
 175     if (jsonError.error != QJsonParseError::NoError)
 176     {
 177         LogMsg(tr("Failed to parse Watched Folders configuration from %1. Error: \"%2\"")
 178             .arg(path.toString(), jsonError.errorString()), Log::WARNING);
 179         return;
 180     }
 181
 182     if (!jsonDoc.isObject())
 183     {
 184         LogMsg(tr("Failed to load Watched Folders configuration from %1. Error: \"Invalid data format.\"")
 185             .arg(path.toString()), Log::WARNING);
 186         return;
 187     }
 188
 189     const QJsonObject jsonObj = jsonDoc.object();
 190     for (auto it = jsonObj.constBegin(); it != jsonObj.constEnd(); ++it)
 191     {
 192         const Path watchedFolder {it.key()};
 193         const WatchedFolderOptions options = parseWatchedFolderOptions(it.value().toObject());
 194         try
 195         {
 196             doSetWatchedFolder(watchedFolder, options);
 197         }
 198         catch (const InvalidArgument &err)
 199         {
 200             LogMsg(err.message(), Log::WARNING);
 201         }
 202     }
 203 }
 204
 205 void TorrentFilesWatcher::loadLegacy()
 206 {
 207     const auto dirs = SettingsStorage::instance()->loadValue<QVariantHash>(u"Preferences/Downloads/ScanDirsV2"_s);
 208
 209     for (auto it = dirs.cbegin(); it != dirs.cend(); ++it)
 210     {
 211         const Path watchedFolder {it.key()};
 212         BitTorrent::AddTorrentParams params;
 213         if (it.value().userType() == QMetaType::Int)
 214         {
 215             if (it.value().toInt() == 0)
 216             {
 217                 params.savePath = watchedFolder;
 218                 params.useAutoTMM = false;
 219             }
 220         }
 221         else
 222         {
 223             const Path customSavePath {it.value().toString()};
 224             params.savePath = customSavePath;
 225             params.useAutoTMM = false;
 226         }
 227
 228         try
 229         {
 230             doSetWatchedFolder(watchedFolder, {params, false});
 231         }
 232         catch (const InvalidArgument &err)
 233         {
 234             LogMsg(err.message(), Log::WARNING);
 235         }
 236     }
 237
 238     store();
 239     SettingsStorage::instance()->removeValue(u"Preferences/Downloads/ScanDirsV2"_s);
 240 }
 241
 242 void TorrentFilesWatcher::store() const
 243 {
 244     QJsonObject jsonObj;
 245     for (auto it = m_watchedFolders.cbegin(); it != m_watchedFolders.cend(); ++it)
 246     {
 247         const Path &watchedFolder = it.key();
 248         const WatchedFolderOptions &options = it.value();
 249         jsonObj[watchedFolder.data()] = serializeWatchedFolderOptions(options);
 250     }
 251
 252     const Path path = specialFolderLocation(SpecialFolder::Config) / Path(CONF_FILE_NAME);
 253     const QByteArray data = QJsonDocument(jsonObj).toJson();
 254     const nonstd::expected<void, QString> result = Utils::IO::saveToFile(path, data);
 255     if (!result)
 256     {
 257         LogMsg(tr("Couldn't store Watched Folders configuration to %1. Error: %2")
 258             .arg(path.toString(), result.error()), Log::WARNING);
 259     }
 260 }
 261
 262 QHash<Path, TorrentFilesWatcher::WatchedFolderOptions> TorrentFilesWatcher::folders() const
 263 {
 264     return m_watchedFolders;
 265 }
 266
 267 void TorrentFilesWatcher::setWatchedFolder(const Path &path, const WatchedFolderOptions &options)
 268 {
 269     doSetWatchedFolder(path, options);
 270     store();
 271 }
 272
 273 void TorrentFilesWatcher::doSetWatchedFolder(const Path &path, const WatchedFolderOptions &options)
 274 {
 275     if (path.isEmpty())
 276         throw InvalidArgument(tr("Watched folder Path cannot be empty."));
 277
 278     if (path.isRelative())
 279         throw InvalidArgument(tr("Watched folder Path cannot be relative."));
 280
 281     m_watchedFolders[path] = options;
 282
 283     QMetaObject::invokeMethod(m_asyncWorker, [this, path, options]
 284     {
 285         m_asyncWorker->setWatchedFolder(path, options);
 286     });
 287
 288     emit watchedFolderSet(path, options);
 289 }
 290
 291 void TorrentFilesWatcher::removeWatchedFolder(const Path &path)
 292 {
 293     if (m_watchedFolders.remove(path))
 294     {
 295         if (m_asyncWorker)
 296         {
 297             QMetaObject::invokeMethod(m_asyncWorker, [this, path]()
 298             {
 299                 m_asyncWorker->removeWatchedFolder(path);
 300             });
 301         }
 302
 303         emit watchedFolderRemoved(path);
 304
 305         store();
 306     }
 307 }
 308
 309 void TorrentFilesWatcher::onTorrentFound(const BitTorrent::TorrentDescriptor &torrentDescr
 310         , const BitTorrent::AddTorrentParams &addTorrentParams)
 311 {
 312     BitTorrent::Session::instance()->addTorrent(torrentDescr, addTorrentParams);
 313 }
 314
 315 TorrentFilesWatcher::Worker::Worker(QFileSystemWatcher *watcher)
 316     : m_watcher {watcher}
 317     , m_watchTimer {new QTimer(this)}
 318     , m_retryTorrentTimer {new QTimer(this)}
 319 {
 320     connect(m_watcher, &QFileSystemWatcher::directoryChanged, this, [this](const QString &path)
 321     {
 322         scheduleWatchedFolderProcessing(Path(path));
 323     });
 324     connect(m_watchTimer, &QTimer::timeout, this, &Worker::onTimeout);
 325
 326     connect(m_retryTorrentTimer, &QTimer::timeout, this, &Worker::processFailedTorrents);
 327 }
 328
 329 void TorrentFilesWatcher::Worker::onTimeout()
 330 {
 331     for (const Path &path : asConst(m_watchedByTimeoutFolders))
 332         processWatchedFolder(path);
 333 }
 334
 335 void TorrentFilesWatcher::Worker::setWatchedFolder(const Path &path, const TorrentFilesWatcher::WatchedFolderOptions &options)
 336 {
 337     if (m_watchedFolders.contains(path))
 338         updateWatchedFolder(path, options);
 339     else
 340         addWatchedFolder(path, options);
 341 }
 342
 343 void TorrentFilesWatcher::Worker::removeWatchedFolder(const Path &path)
 344 {
 345     m_watchedFolders.remove(path);
 346
 347     m_watcher->removePath(path.data());
 348     m_watchedByTimeoutFolders.remove(path);
 349     if (m_watchedByTimeoutFolders.isEmpty())
 350         m_watchTimer->stop();
 351
 352     m_failedTorrents.remove(path);
 353     if (m_failedTorrents.isEmpty())
 354         m_retryTorrentTimer->stop();
 355 }
 356
 357 void TorrentFilesWatcher::Worker::scheduleWatchedFolderProcessing(const Path &path)
 358 {
 359     QTimer::singleShot(2s, Qt::CoarseTimer, this, [this, path]
 360     {
 361         processWatchedFolder(path);
 362     });
 363 }
 364
 365 void TorrentFilesWatcher::Worker::processWatchedFolder(const Path &path)
 366 {
 367     const TorrentFilesWatcher::WatchedFolderOptions options = m_watchedFolders.value(path);
 368     processFolder(path, path, options);
 369
 370     if (!m_failedTorrents.empty() && !m_retryTorrentTimer->isActive())
 371         m_retryTorrentTimer->start(WATCH_INTERVAL);
 372 }
 373
 374 void TorrentFilesWatcher::Worker::processFolder(const Path &path, const Path &watchedFolderPath
 375                                               , const TorrentFilesWatcher::WatchedFolderOptions &options)
 376 {
 377     QDirIterator dirIter {path.data(), {u"*.torrent"_s, u"*.magnet"_s}, QDir::Files};
 378     while (dirIter.hasNext())
 379     {
 380         const Path filePath {dirIter.next()};
 381         BitTorrent::AddTorrentParams addTorrentParams = options.addTorrentParams;
 382         if (path != watchedFolderPath)
 383         {
 384             const Path subdirPath = watchedFolderPath.relativePathOf(path);
 385             const bool useAutoTMM = addTorrentParams.useAutoTMM.value_or(!BitTorrent::Session::instance()->isAutoTMMDisabledByDefault());
 386             if (useAutoTMM)
 387             {
 388                 addTorrentParams.category = addTorrentParams.category.isEmpty()
 389                         ? subdirPath.data() : (addTorrentParams.category + u'/' + subdirPath.data());
 390             }
 391             else
 392             {
 393                 addTorrentParams.savePath = addTorrentParams.savePath / subdirPath;
 394             }
 395         }
 396
 397         if (filePath.hasExtension(u".magnet"_s))
 398         {
 399             const int fileMaxSize = 100 * 1024 * 1024;
 400
 401             QFile file {filePath.data()};
 402             if (file.open(QIODevice::ReadOnly | QIODevice::Text))
 403             {
 404                 if (file.size() <= fileMaxSize)
 405                 {
 406                     while (!file.atEnd())
 407                     {
 408                         const auto line = QString::fromLatin1(file.readLine()).trimmed();
 409                         if (const auto parseResult = BitTorrent::TorrentDescriptor::parse(line))
 410                             emit torrentFound(parseResult.value(), addTorrentParams);
 411                         else
 412                             LogMsg(tr("Invalid Magnet URI. URI: %1. Reason: %2").arg(line, parseResult.error()), Log::WARNING);
 413                     }
 414
 415                     file.close();
 416                     Utils::Fs::removeFile(filePath);
 417                 }
 418                 else
 419                 {
 420                     LogMsg(tr("Magnet file too big. File: %1").arg(file.errorString()), Log::WARNING);
 421                 }
 422             }
 423             else
 424             {
 425                 LogMsg(tr("Failed to open magnet file: %1").arg(file.errorString()));
 426             }
 427         }
 428         else
 429         {
 430             if (const auto loadResult = BitTorrent::TorrentDescriptor::loadFromFile(filePath))
 431             {
 432                 emit torrentFound(loadResult.value(), addTorrentParams);
 433                 Utils::Fs::removeFile(filePath);
 434             }
 435             else
 436             {
 437                 if (!m_failedTorrents.value(path).contains(filePath))
 438                 {
 439                     m_failedTorrents[path][filePath] = 0;
 440                 }
 441             }
 442         }
 443     }
 444
 445     if (options.recursive)
 446     {
 447         QDirIterator iter {path.data(), (QDir::Dirs | QDir::NoDotAndDotDot)};
 448         while (iter.hasNext())
 449         {
 450             const Path folderPath {iter.next()};
 451             // Skip processing of subdirectory that is explicitly set as watched folder
 452             if (!m_watchedFolders.contains(folderPath))
 453                 processFolder(folderPath, watchedFolderPath, options);
 454         }
 455     }
 456 }
 457
 458 void TorrentFilesWatcher::Worker::processFailedTorrents()
 459 {
 460     // Check which torrents are still partial
 461     Algorithm::removeIf(m_failedTorrents, [this](const Path &watchedFolderPath, QHash<Path, int> &partialTorrents)
 462     {
 463         const TorrentFilesWatcher::WatchedFolderOptions options = m_watchedFolders.value(watchedFolderPath);
 464         Algorithm::removeIf(partialTorrents, [this, &watchedFolderPath, &options](const Path &torrentPath, int &value)
 465         {
 466             if (!torrentPath.exists())
 467                 return true;
 468
 469             if (const auto loadResult = BitTorrent::TorrentDescriptor::loadFromFile(torrentPath))
 470             {
 471                 BitTorrent::AddTorrentParams addTorrentParams = options.addTorrentParams;
 472                 if (torrentPath != watchedFolderPath)
 473                 {
 474                     const Path subdirPath = watchedFolderPath.relativePathOf(torrentPath);
 475                     const bool useAutoTMM = addTorrentParams.useAutoTMM.value_or(!BitTorrent::Session::instance()->isAutoTMMDisabledByDefault());
 476                     if (useAutoTMM)
 477                     {
 478                         addTorrentParams.category = addTorrentParams.category.isEmpty()
 479                                 ? subdirPath.data() : (addTorrentParams.category + u'/' + subdirPath.data());
 480                     }
 481                     else
 482                     {
 483                         addTorrentParams.savePath = addTorrentParams.savePath / subdirPath;
 484                     }
 485                 }
 486
 487                 emit torrentFound(loadResult.value(), addTorrentParams);
 488                 Utils::Fs::removeFile(torrentPath);
 489
 490                 return true;
 491             }
 492
 493             if (value >= MAX_FAILED_RETRIES)
 494             {
 495                 LogMsg(tr("Rejecting failed torrent file: %1").arg(torrentPath.toString()));
 496                 Utils::Fs::renameFile(torrentPath, (torrentPath + u".qbt_rejected"));
 497                 return true;
 498             }
 499
 500             ++value;
 501             return false;
 502         });
 503
 504         if (partialTorrents.isEmpty())
 505             return true;
 506
 507         return false;
 508     });
 509
 510     // Stop the partial timer if necessary
 511     if (m_failedTorrents.empty())
 512         m_retryTorrentTimer->stop();
 513     else
 514         m_retryTorrentTimer->start(WATCH_INTERVAL);
 515 }
 516
 517 void TorrentFilesWatcher::Worker::addWatchedFolder(const Path &path, const TorrentFilesWatcher::WatchedFolderOptions &options)
 518 {
 519     // Check if the `path` points to a network file system or not
 520     if (Utils::Fs::isNetworkFileSystem(path) || options.recursive)
 521     {
 522         m_watchedByTimeoutFolders.insert(path);
 523         if (!m_watchTimer->isActive())
 524             m_watchTimer->start(WATCH_INTERVAL);
 525     }
 526     else
 527     {
 528         m_watcher->addPath(path.data());
 529         scheduleWatchedFolderProcessing(path);
 530     }
 531
 532     m_watchedFolders[path] = options;
 533
 534     LogMsg(tr("Watching folder: \"%1\"").arg(path.toString()));
 535 }
 536
 537 void TorrentFilesWatcher::Worker::updateWatchedFolder(const Path &path, const TorrentFilesWatcher::WatchedFolderOptions &options)
 538 {
 539     const bool recursiveModeChanged = (m_watchedFolders[path].recursive != options.recursive);
 540     if (recursiveModeChanged && !Utils::Fs::isNetworkFileSystem(path))
 541     {
 542         if (options.recursive)
 543         {
 544             m_watcher->removePath(path.data());
 545
 546             m_watchedByTimeoutFolders.insert(path);
 547             if (!m_watchTimer->isActive())
 548                 m_watchTimer->start(WATCH_INTERVAL);
 549         }
 550         else
 551         {
 552             m_watchedByTimeoutFolders.remove(path);
 553             if (m_watchedByTimeoutFolders.isEmpty())
 554                 m_watchTimer->stop();
 555
 556             m_watcher->addPath(path.data());
 557             scheduleWatchedFolderProcessing(path);
 558         }
 559     }
 560
 561     m_watchedFolders[path] = options;
 562 }
 563
 564 #include "torrentfileswatcher.moc"