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->start();
 150
 151     load();
 152 }
 153
 154 void TorrentFilesWatcher::load()
 155 {
 156     const int fileMaxSize = 10 * 1024 * 1024;
 157     const Path path = specialFolderLocation(SpecialFolder::Config) / Path(CONF_FILE_NAME);
 158
 159     const auto readResult = Utils::IO::readFile(path, fileMaxSize);
 160     if (!readResult)
 161     {
 162         if (readResult.error().status == Utils::IO::ReadError::NotExist)
 163         {
 164             loadLegacy();
 165             return;
 166         }
 167
 168         LogMsg(tr("Failed to load Watched Folders configuration. %1").arg(readResult.error().message), Log::WARNING);
 169         return;
 170     }
 171
 172     QJsonParseError jsonError;
 173     const QJsonDocument jsonDoc = QJsonDocument::fromJson(readResult.value(), &jsonError);
 174     if (jsonError.error != QJsonParseError::NoError)
 175     {
 176         LogMsg(tr("Failed to parse Watched Folders configuration from %1. Error: \"%2\"")
 177             .arg(path.toString(), jsonError.errorString()), Log::WARNING);
 178         return;
 179     }
 180
 181     if (!jsonDoc.isObject())
 182     {
 183         LogMsg(tr("Failed to load Watched Folders configuration from %1. Error: \"Invalid data format.\"")
 184             .arg(path.toString()), Log::WARNING);
 185         return;
 186     }
 187
 188     const QJsonObject jsonObj = jsonDoc.object();
 189     for (auto it = jsonObj.constBegin(); it != jsonObj.constEnd(); ++it)
 190     {
 191         const Path watchedFolder {it.key()};
 192         const WatchedFolderOptions options = parseWatchedFolderOptions(it.value().toObject());
 193         try
 194         {
 195             doSetWatchedFolder(watchedFolder, options);
 196         }
 197         catch (const InvalidArgument &err)
 198         {
 199             LogMsg(err.message(), Log::WARNING);
 200         }
 201     }
 202 }
 203
 204 void TorrentFilesWatcher::loadLegacy()
 205 {
 206     const auto dirs = SettingsStorage::instance()->loadValue<QVariantHash>(u"Preferences/Downloads/ScanDirsV2"_s);
 207
 208     for (auto it = dirs.cbegin(); it != dirs.cend(); ++it)
 209     {
 210         const Path watchedFolder {it.key()};
 211         BitTorrent::AddTorrentParams params;
 212         if (it.value().userType() == QMetaType::Int)
 213         {
 214             if (it.value().toInt() == 0)
 215             {
 216                 params.savePath = watchedFolder;
 217                 params.useAutoTMM = false;
 218             }
 219         }
 220         else
 221         {
 222             const Path customSavePath {it.value().toString()};
 223             params.savePath = customSavePath;
 224             params.useAutoTMM = false;
 225         }
 226
 227         try
 228         {
 229             doSetWatchedFolder(watchedFolder, {params, false});
 230         }
 231         catch (const InvalidArgument &err)
 232         {
 233             LogMsg(err.message(), Log::WARNING);
 234         }
 235     }
 236
 237     store();
 238     SettingsStorage::instance()->removeValue(u"Preferences/Downloads/ScanDirsV2"_s);
 239 }
 240
 241 void TorrentFilesWatcher::store() const
 242 {
 243     QJsonObject jsonObj;
 244     for (auto it = m_watchedFolders.cbegin(); it != m_watchedFolders.cend(); ++it)
 245     {
 246         const Path &watchedFolder = it.key();
 247         const WatchedFolderOptions &options = it.value();
 248         jsonObj[watchedFolder.data()] = serializeWatchedFolderOptions(options);
 249     }
 250
 251     const Path path = specialFolderLocation(SpecialFolder::Config) / Path(CONF_FILE_NAME);
 252     const QByteArray data = QJsonDocument(jsonObj).toJson();
 253     const nonstd::expected<void, QString> result = Utils::IO::saveToFile(path, data);
 254     if (!result)
 255     {
 256         LogMsg(tr("Couldn't store Watched Folders configuration to %1. Error: %2")
 257             .arg(path.toString(), result.error()), Log::WARNING);
 258     }
 259 }
 260
 261 QHash<Path, TorrentFilesWatcher::WatchedFolderOptions> TorrentFilesWatcher::folders() const
 262 {
 263     return m_watchedFolders;
 264 }
 265
 266 void TorrentFilesWatcher::setWatchedFolder(const Path &path, const WatchedFolderOptions &options)
 267 {
 268     doSetWatchedFolder(path, options);
 269     store();
 270 }
 271
 272 void TorrentFilesWatcher::doSetWatchedFolder(const Path &path, const WatchedFolderOptions &options)
 273 {
 274     if (path.isEmpty())
 275         throw InvalidArgument(tr("Watched folder Path cannot be empty."));
 276
 277     if (path.isRelative())
 278         throw InvalidArgument(tr("Watched folder Path cannot be relative."));
 279
 280     m_watchedFolders[path] = options;
 281
 282     QMetaObject::invokeMethod(m_asyncWorker, [this, path, options]
 283     {
 284         m_asyncWorker->setWatchedFolder(path, options);
 285     });
 286
 287     emit watchedFolderSet(path, options);
 288 }
 289
 290 void TorrentFilesWatcher::removeWatchedFolder(const Path &path)
 291 {
 292     if (m_watchedFolders.remove(path))
 293     {
 294         if (m_asyncWorker)
 295         {
 296             QMetaObject::invokeMethod(m_asyncWorker, [this, path]()
 297             {
 298                 m_asyncWorker->removeWatchedFolder(path);
 299             });
 300         }
 301
 302         emit watchedFolderRemoved(path);
 303
 304         store();
 305     }
 306 }
 307
 308 void TorrentFilesWatcher::onTorrentFound(const BitTorrent::TorrentDescriptor &torrentDescr
 309         , const BitTorrent::AddTorrentParams &addTorrentParams)
 310 {
 311     BitTorrent::Session::instance()->addTorrent(torrentDescr, addTorrentParams);
 312 }
 313
 314 TorrentFilesWatcher::Worker::Worker(QFileSystemWatcher *watcher)
 315     : m_watcher {watcher}
 316     , m_watchTimer {new QTimer(this)}
 317     , m_retryTorrentTimer {new QTimer(this)}
 318 {
 319     connect(m_watcher, &QFileSystemWatcher::directoryChanged, this, [this](const QString &path)
 320     {
 321         scheduleWatchedFolderProcessing(Path(path));
 322     });
 323     connect(m_watchTimer, &QTimer::timeout, this, &Worker::onTimeout);
 324
 325     connect(m_retryTorrentTimer, &QTimer::timeout, this, &Worker::processFailedTorrents);
 326 }
 327
 328 void TorrentFilesWatcher::Worker::onTimeout()
 329 {
 330     for (const Path &path : asConst(m_watchedByTimeoutFolders))
 331         processWatchedFolder(path);
 332 }
 333
 334 void TorrentFilesWatcher::Worker::setWatchedFolder(const Path &path, const TorrentFilesWatcher::WatchedFolderOptions &options)
 335 {
 336     if (m_watchedFolders.contains(path))
 337         updateWatchedFolder(path, options);
 338     else
 339         addWatchedFolder(path, options);
 340 }
 341
 342 void TorrentFilesWatcher::Worker::removeWatchedFolder(const Path &path)
 343 {
 344     m_watchedFolders.remove(path);
 345
 346     m_watcher->removePath(path.data());
 347     m_watchedByTimeoutFolders.remove(path);
 348     if (m_watchedByTimeoutFolders.isEmpty())
 349         m_watchTimer->stop();
 350
 351     m_failedTorrents.remove(path);
 352     if (m_failedTorrents.isEmpty())
 353         m_retryTorrentTimer->stop();
 354 }
 355
 356 void TorrentFilesWatcher::Worker::scheduleWatchedFolderProcessing(const Path &path)
 357 {
 358     QTimer::singleShot(2s, Qt::CoarseTimer, this, [this, path]
 359     {
 360         processWatchedFolder(path);
 361     });
 362 }
 363
 364 void TorrentFilesWatcher::Worker::processWatchedFolder(const Path &path)
 365 {
 366     const TorrentFilesWatcher::WatchedFolderOptions options = m_watchedFolders.value(path);
 367     processFolder(path, path, options);
 368
 369     if (!m_failedTorrents.empty() && !m_retryTorrentTimer->isActive())
 370         m_retryTorrentTimer->start(WATCH_INTERVAL);
 371 }
 372
 373 void TorrentFilesWatcher::Worker::processFolder(const Path &path, const Path &watchedFolderPath
 374                                               , const TorrentFilesWatcher::WatchedFolderOptions &options)
 375 {
 376     QDirIterator dirIter {path.data(), {u"*.torrent"_s, u"*.magnet"_s}, QDir::Files};
 377     while (dirIter.hasNext())
 378     {
 379         const Path filePath {dirIter.next()};
 380         BitTorrent::AddTorrentParams addTorrentParams = options.addTorrentParams;
 381         if (path != watchedFolderPath)
 382         {
 383             const Path subdirPath = watchedFolderPath.relativePathOf(path);
 384             const bool useAutoTMM = addTorrentParams.useAutoTMM.value_or(!BitTorrent::Session::instance()->isAutoTMMDisabledByDefault());
 385             if (useAutoTMM)
 386             {
 387                 addTorrentParams.category = addTorrentParams.category.isEmpty()
 388                         ? subdirPath.data() : (addTorrentParams.category + u'/' + subdirPath.data());
 389             }
 390             else
 391             {
 392                 addTorrentParams.savePath = addTorrentParams.savePath / subdirPath;
 393             }
 394         }
 395
 396         if (filePath.hasExtension(u".magnet"_s))
 397         {
 398             const int fileMaxSize = 100 * 1024 * 1024;
 399
 400             QFile file {filePath.data()};
 401             if (file.open(QIODevice::ReadOnly | QIODevice::Text))
 402             {
 403                 if (file.size() <= fileMaxSize)
 404                 {
 405                     while (!file.atEnd())
 406                     {
 407                         const auto line = QString::fromLatin1(file.readLine()).trimmed();
 408                         if (const auto parseResult = BitTorrent::TorrentDescriptor::parse(line))
 409                             emit torrentFound(parseResult.value(), addTorrentParams);
 410                         else
 411                             LogMsg(tr("Invalid Magnet URI. URI: %1. Reason: %2").arg(line, parseResult.error()), Log::WARNING);
 412                     }
 413
 414                     file.close();
 415                     Utils::Fs::removeFile(filePath);
 416                 }
 417                 else
 418                 {
 419                     LogMsg(tr("Magnet file too big. File: %1").arg(file.errorString()), Log::WARNING);
 420                 }
 421             }
 422             else
 423             {
 424                 LogMsg(tr("Failed to open magnet file: %1").arg(file.errorString()));
 425             }
 426         }
 427         else
 428         {
 429             if (const auto loadResult = BitTorrent::TorrentDescriptor::loadFromFile(filePath))
 430             {
 431                 emit torrentFound(loadResult.value(), addTorrentParams);
 432                 Utils::Fs::removeFile(filePath);
 433             }
 434             else
 435             {
 436                 if (!m_failedTorrents.value(path).contains(filePath))
 437                 {
 438                     m_failedTorrents[path][filePath] = 0;
 439                 }
 440             }
 441         }
 442     }
 443
 444     if (options.recursive)
 445     {
 446         QDirIterator iter {path.data(), (QDir::Dirs | QDir::NoDotAndDotDot)};
 447         while (iter.hasNext())
 448         {
 449             const Path folderPath {iter.next()};
 450             // Skip processing of subdirectory that is explicitly set as watched folder
 451             if (!m_watchedFolders.contains(folderPath))
 452                 processFolder(folderPath, watchedFolderPath, options);
 453         }
 454     }
 455 }
 456
 457 void TorrentFilesWatcher::Worker::processFailedTorrents()
 458 {
 459     // Check which torrents are still partial
 460     Algorithm::removeIf(m_failedTorrents, [this](const Path &watchedFolderPath, QHash<Path, int> &partialTorrents)
 461     {
 462         const TorrentFilesWatcher::WatchedFolderOptions options = m_watchedFolders.value(watchedFolderPath);
 463         Algorithm::removeIf(partialTorrents, [this, &watchedFolderPath, &options](const Path &torrentPath, int &value)
 464         {
 465             if (!torrentPath.exists())
 466                 return true;
 467
 468             if (const auto loadResult = BitTorrent::TorrentDescriptor::loadFromFile(torrentPath))
 469             {
 470                 BitTorrent::AddTorrentParams addTorrentParams = options.addTorrentParams;
 471                 if (torrentPath != watchedFolderPath)
 472                 {
 473                     const Path subdirPath = watchedFolderPath.relativePathOf(torrentPath);
 474                     const bool useAutoTMM = addTorrentParams.useAutoTMM.value_or(!BitTorrent::Session::instance()->isAutoTMMDisabledByDefault());
 475                     if (useAutoTMM)
 476                     {
 477                         addTorrentParams.category = addTorrentParams.category.isEmpty()
 478                                 ? subdirPath.data() : (addTorrentParams.category + u'/' + subdirPath.data());
 479                     }
 480                     else
 481                     {
 482                         addTorrentParams.savePath = addTorrentParams.savePath / subdirPath;
 483                     }
 484                 }
 485
 486                 emit torrentFound(loadResult.value(), addTorrentParams);
 487                 Utils::Fs::removeFile(torrentPath);
 488
 489                 return true;
 490             }
 491
 492             if (value >= MAX_FAILED_RETRIES)
 493             {
 494                 LogMsg(tr("Rejecting failed torrent file: %1").arg(torrentPath.toString()));
 495                 Utils::Fs::renameFile(torrentPath, (torrentPath + u".qbt_rejected"));
 496                 return true;
 497             }
 498
 499             ++value;
 500             return false;
 501         });
 502
 503         if (partialTorrents.isEmpty())
 504             return true;
 505
 506         return false;
 507     });
 508
 509     // Stop the partial timer if necessary
 510     if (m_failedTorrents.empty())
 511         m_retryTorrentTimer->stop();
 512     else
 513         m_retryTorrentTimer->start(WATCH_INTERVAL);
 514 }
 515
 516 void TorrentFilesWatcher::Worker::addWatchedFolder(const Path &path, const TorrentFilesWatcher::WatchedFolderOptions &options)
 517 {
 518     // Check if the `path` points to a network file system or not
 519     if (Utils::Fs::isNetworkFileSystem(path) || options.recursive)
 520     {
 521         m_watchedByTimeoutFolders.insert(path);
 522         if (!m_watchTimer->isActive())
 523             m_watchTimer->start(WATCH_INTERVAL);
 524     }
 525     else
 526     {
 527         m_watcher->addPath(path.data());
 528         scheduleWatchedFolderProcessing(path);
 529     }
 530
 531     m_watchedFolders[path] = options;
 532
 533     LogMsg(tr("Watching folder: \"%1\"").arg(path.toString()));
 534 }
 535
 536 void TorrentFilesWatcher::Worker::updateWatchedFolder(const Path &path, const TorrentFilesWatcher::WatchedFolderOptions &options)
 537 {
 538     const bool recursiveModeChanged = (m_watchedFolders[path].recursive != options.recursive);
 539     if (recursiveModeChanged && !Utils::Fs::isNetworkFileSystem(path))
 540     {
 541         if (options.recursive)
 542         {
 543             m_watcher->removePath(path.data());
 544
 545             m_watchedByTimeoutFolders.insert(path);
 546             if (!m_watchTimer->isActive())
 547                 m_watchTimer->start(WATCH_INTERVAL);
 548         }
 549         else
 550         {
 551             m_watchedByTimeoutFolders.remove(path);
 552             if (m_watchedByTimeoutFolders.isEmpty())
 553                 m_watchTimer->stop();
 554
 555             m_watcher->addPath(path.data());
 556             scheduleWatchedFolderProcessing(path);
 557         }
 558     }
 559
 560     m_watchedFolders[path] = options;
 561 }
 562
 563 #include "torrentfileswatcher.moc"