src/base/search/searchpluginmanager.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2015, 2018  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2006  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 "searchpluginmanager.h"
  31
  32 #include <memory>
  33
  34 #include <QDir>
  35 #include <QDirIterator>
  36 #include <QDomDocument>
  37 #include <QDomElement>
  38 #include <QDomNode>
  39 #include <QFile>
  40 #include <QPointer>
  41 #include <QProcess>
  42 #include <QUrl>
  43
  44 #include "base/global.h"
  45 #include "base/logger.h"
  46 #include "base/net/downloadmanager.h"
  47 #include "base/net/proxyconfigurationmanager.h"
  48 #include "base/preferences.h"
  49 #include "base/profile.h"
  50 #include "base/utils/bytearray.h"
  51 #include "base/utils/foreignapps.h"
  52 #include "base/utils/fs.h"
  53 #include "searchdownloadhandler.h"
  54 #include "searchhandler.h"
  55
  56 namespace
  57 {
  58     void clearPythonCache(const Path &path)
  59     {
  60         // remove python cache artifacts in `path` and subdirs
  61
  62         PathList dirs = {path};
  63         QDirIterator iter {path.data(), (QDir::AllDirs | QDir::NoDotAndDotDot), QDirIterator::Subdirectories};
  64         while (iter.hasNext())
  65             dirs += Path(iter.next());
  66
  67         for (const Path &dir : asConst(dirs))
  68         {
  69             // python 3: remove "__pycache__" folders
  70             if (dir.filename() == u"__pycache__")
  71             {
  72                 Utils::Fs::removeDirRecursively(dir);
  73                 continue;
  74             }
  75
  76             // python 2: remove "*.pyc" files
  77             const QStringList files = QDir(dir.data()).entryList(QDir::Files);
  78             for (const QString &file : files)
  79             {
  80                 const Path path {file};
  81                 if (path.hasExtension(u".pyc"_s))
  82                     Utils::Fs::removeFile(path);
  83             }
  84         }
  85     }
  86 }
  87
  88 QPointer<SearchPluginManager> SearchPluginManager::m_instance = nullptr;
  89
  90 SearchPluginManager::SearchPluginManager()
  91     : m_updateUrl(u"https://searchplugins.qbittorrent.org/nova3/engines/"_s)
  92 {
  93     Q_ASSERT(!m_instance); // only one instance is allowed
  94     m_instance = this;
  95
  96     connect(Net::ProxyConfigurationManager::instance(), &Net::ProxyConfigurationManager::proxyConfigurationChanged
  97             , this, &SearchPluginManager::applyProxySettings);
  98     connect(Preferences::instance(), &Preferences::changed
  99             , this, &SearchPluginManager::applyProxySettings);
 100     applyProxySettings();
 101
 102     updateNova();
 103     update();
 104 }
 105
 106 SearchPluginManager::~SearchPluginManager()
 107 {
 108     qDeleteAll(m_plugins);
 109 }
 110
 111 SearchPluginManager *SearchPluginManager::instance()
 112 {
 113     if (!m_instance)
 114         m_instance = new SearchPluginManager;
 115     return m_instance;
 116 }
 117
 118 void SearchPluginManager::freeInstance()
 119 {
 120     delete m_instance;
 121 }
 122
 123 QStringList SearchPluginManager::allPlugins() const
 124 {
 125     return m_plugins.keys();
 126 }
 127
 128 QStringList SearchPluginManager::enabledPlugins() const
 129 {
 130     QStringList plugins;
 131     for (const PluginInfo *plugin : asConst(m_plugins))
 132     {
 133         if (plugin->enabled)
 134             plugins << plugin->name;
 135     }
 136
 137     return plugins;
 138 }
 139
 140 QStringList SearchPluginManager::supportedCategories() const
 141 {
 142     QStringList result;
 143     for (const PluginInfo *plugin : asConst(m_plugins))
 144     {
 145         if (plugin->enabled)
 146         {
 147             for (const QString &cat : plugin->supportedCategories)
 148             {
 149                 if (!result.contains(cat))
 150                     result << cat;
 151             }
 152         }
 153     }
 154
 155     return result;
 156 }
 157
 158 QStringList SearchPluginManager::getPluginCategories(const QString &pluginName) const
 159 {
 160     QStringList plugins;
 161     if (pluginName == u"all")
 162         plugins = allPlugins();
 163     else if ((pluginName == u"enabled") || (pluginName == u"multi"))
 164         plugins = enabledPlugins();
 165     else
 166         plugins << pluginName.trimmed();
 167
 168     QSet<QString> categories;
 169     for (const QString &name : asConst(plugins))
 170     {
 171         const PluginInfo *plugin = pluginInfo(name);
 172         if (!plugin) continue; // plugin wasn't found
 173         for (const QString &category : plugin->supportedCategories)
 174             categories << category;
 175     }
 176
 177     return categories.values();
 178 }
 179
 180 PluginInfo *SearchPluginManager::pluginInfo(const QString &name) const
 181 {
 182     return m_plugins.value(name);
 183 }
 184
 185 void SearchPluginManager::enablePlugin(const QString &name, const bool enabled)
 186 {
 187     PluginInfo *plugin = m_plugins.value(name, nullptr);
 188     if (plugin)
 189     {
 190         plugin->enabled = enabled;
 191         // Save to Hard disk
 192         Preferences *const pref = Preferences::instance();
 193         QStringList disabledPlugins = pref->getSearchEngDisabled();
 194         if (enabled)
 195             disabledPlugins.removeAll(name);
 196         else if (!disabledPlugins.contains(name))
 197             disabledPlugins.append(name);
 198         pref->setSearchEngDisabled(disabledPlugins);
 199
 200         emit pluginEnabled(name, enabled);
 201     }
 202 }
 203
 204 // Updates shipped plugin
 205 void SearchPluginManager::updatePlugin(const QString &name)
 206 {
 207     installPlugin(u"%1%2.py"_s.arg(m_updateUrl, name));
 208 }
 209
 210 // Install or update plugin from file or url
 211 void SearchPluginManager::installPlugin(const QString &source)
 212 {
 213     clearPythonCache(engineLocation());
 214
 215     if (Net::DownloadManager::hasSupportedScheme(source))
 216     {
 217         using namespace Net;
 218         DownloadManager::instance()->download(DownloadRequest(source).saveToFile(true)
 219                 , Preferences::instance()->useProxyForGeneralPurposes()
 220                 , this, &SearchPluginManager::pluginDownloadFinished);
 221     }
 222     else
 223     {
 224         const Path path {source.startsWith(u"file:", Qt::CaseInsensitive) ? QUrl(source).toLocalFile() : source};
 225
 226         QString pluginName = path.filename();
 227         if (pluginName.endsWith(u".py", Qt::CaseInsensitive))
 228         {
 229             pluginName.chop(pluginName.size() - pluginName.lastIndexOf(u'.'));
 230             installPlugin_impl(pluginName, path);
 231         }
 232         else
 233         {
 234             emit pluginInstallationFailed(pluginName, tr("Unknown search engine plugin file format."));
 235         }
 236     }
 237 }
 238
 239 void SearchPluginManager::installPlugin_impl(const QString &name, const Path &path)
 240 {
 241     const PluginVersion newVersion = getPluginVersion(path);
 242     const PluginInfo *plugin = pluginInfo(name);
 243     if (plugin && !(plugin->version < newVersion))
 244     {
 245         LogMsg(tr("Plugin already at version %1, which is greater than %2").arg(plugin->version.toString(), newVersion.toString()), Log::INFO);
 246         emit pluginUpdateFailed(name, tr("A more recent version of this plugin is already installed."));
 247         return;
 248     }
 249
 250     // Process with install
 251     const Path destPath = pluginPath(name);
 252     const Path backupPath = destPath + u".bak";
 253     bool updated = false;
 254     if (destPath.exists())
 255     {
 256         // Backup in case install fails
 257         Utils::Fs::copyFile(destPath, backupPath);
 258         Utils::Fs::removeFile(destPath);
 259         updated = true;
 260     }
 261     // Copy the plugin
 262     Utils::Fs::copyFile(path, destPath);
 263     // Update supported plugins
 264     update();
 265     // Check if this was correctly installed
 266     if (!m_plugins.contains(name))
 267     {
 268         // Remove broken file
 269         Utils::Fs::removeFile(destPath);
 270         LogMsg(tr("Plugin %1 is not supported.").arg(name), Log::INFO);
 271         if (updated)
 272         {
 273             // restore backup
 274             Utils::Fs::copyFile(backupPath, destPath);
 275             Utils::Fs::removeFile(backupPath);
 276             // Update supported plugins
 277             update();
 278             emit pluginUpdateFailed(name, tr("Plugin is not supported."));
 279         }
 280         else
 281         {
 282             emit pluginInstallationFailed(name, tr("Plugin is not supported."));
 283         }
 284     }
 285     else
 286     {
 287         // Install was successful, remove backup
 288         if (updated)
 289         {
 290             LogMsg(tr("Plugin %1 has been successfully updated.").arg(name), Log::INFO);
 291             Utils::Fs::removeFile(backupPath);
 292         }
 293     }
 294 }
 295
 296 bool SearchPluginManager::uninstallPlugin(const QString &name)
 297 {
 298     clearPythonCache(engineLocation());
 299
 300     // remove it from hard drive
 301     const Path pluginsPath = pluginsLocation();
 302     const QStringList filters {name + u".*"};
 303     const QStringList files = QDir(pluginsPath.data()).entryList(filters, QDir::Files, QDir::Unsorted);
 304     for (const QString &file : files)
 305         Utils::Fs::removeFile(pluginsPath / Path(file));
 306     // Remove it from supported engines
 307     delete m_plugins.take(name);
 308
 309     emit pluginUninstalled(name);
 310     return true;
 311 }
 312
 313 void SearchPluginManager::updateIconPath(PluginInfo *const plugin)
 314 {
 315     if (!plugin) return;
 316
 317     const Path pluginsPath = pluginsLocation();
 318     Path iconPath = pluginsPath / Path(plugin->name + u".png");
 319     if (iconPath.exists())
 320     {
 321         plugin->iconPath = iconPath;
 322     }
 323     else
 324     {
 325         iconPath = pluginsPath / Path(plugin->name + u".ico");
 326         if (iconPath.exists())
 327             plugin->iconPath = iconPath;
 328     }
 329 }
 330
 331 void SearchPluginManager::checkForUpdates()
 332 {
 333     // Download version file from update server
 334     using namespace Net;
 335     DownloadManager::instance()->download({m_updateUrl + u"versions.txt"}
 336             , Preferences::instance()->useProxyForGeneralPurposes()
 337             , this, &SearchPluginManager::versionInfoDownloadFinished);
 338 }
 339
 340 SearchDownloadHandler *SearchPluginManager::downloadTorrent(const QString &siteUrl, const QString &url)
 341 {
 342     return new SearchDownloadHandler {siteUrl, url, this};
 343 }
 344
 345 SearchHandler *SearchPluginManager::startSearch(const QString &pattern, const QString &category, const QStringList &usedPlugins)
 346 {
 347     // No search pattern entered
 348     Q_ASSERT(!pattern.isEmpty());
 349
 350     return new SearchHandler {pattern, category, usedPlugins, this};
 351 }
 352
 353 QString SearchPluginManager::categoryFullName(const QString &categoryName)
 354 {
 355     const QHash<QString, QString> categoryTable
 356     {
 357         {u"all"_s, tr("All categories")},
 358         {u"movies"_s, tr("Movies")},
 359         {u"tv"_s, tr("TV shows")},
 360         {u"music"_s, tr("Music")},
 361         {u"games"_s, tr("Games")},
 362         {u"anime"_s, tr("Anime")},
 363         {u"software"_s, tr("Software")},
 364         {u"pictures"_s, tr("Pictures")},
 365         {u"books"_s, tr("Books")}
 366     };
 367     return categoryTable.value(categoryName);
 368 }
 369
 370 QString SearchPluginManager::pluginFullName(const QString &pluginName) const
 371 {
 372     return pluginInfo(pluginName) ? pluginInfo(pluginName)->fullName : QString();
 373 }
 374
 375 Path SearchPluginManager::pluginsLocation()
 376 {
 377     return (engineLocation() / Path(u"engines"_s));
 378 }
 379
 380 Path SearchPluginManager::engineLocation()
 381 {
 382     static Path location;
 383     if (location.isEmpty())
 384     {
 385         location = specialFolderLocation(SpecialFolder::Data) / Path(u"nova3"_s);
 386         Utils::Fs::mkpath(location);
 387     }
 388
 389     return location;
 390 }
 391
 392 void SearchPluginManager::applyProxySettings()
 393 {
 394     const auto *proxyManager = Net::ProxyConfigurationManager::instance();
 395     const Net::ProxyConfiguration proxyConfig = proxyManager->proxyConfiguration();
 396
 397     // Define environment variables for urllib in search engine plugins
 398     QString proxyStrHTTP, proxyStrSOCK;
 399     if ((proxyConfig.type != Net::ProxyType::None) && Preferences::instance()->useProxyForGeneralPurposes())
 400     {
 401         switch (proxyConfig.type)
 402         {
 403         case Net::ProxyType::HTTP:
 404             if (proxyConfig.authEnabled)
 405             {
 406                 proxyStrHTTP = u"http://%1:%2@%3:%4"_s.arg(proxyConfig.username
 407                         , proxyConfig.password, proxyConfig.ip, QString::number(proxyConfig.port));
 408             }
 409             else
 410             {
 411                 proxyStrHTTP = u"http://%1:%2"_s.arg(proxyConfig.ip, QString::number(proxyConfig.port));
 412             }
 413             break;
 414
 415         case Net::ProxyType::SOCKS5:
 416             if (proxyConfig.authEnabled)
 417             {
 418                 proxyStrSOCK = u"%1:%2@%3:%4"_s.arg(proxyConfig.username
 419                     , proxyConfig.password, proxyConfig.ip, QString::number(proxyConfig.port));
 420             }
 421             else
 422             {
 423                 proxyStrSOCK = u"%1:%2"_s.arg(proxyConfig.ip, QString::number(proxyConfig.port));
 424             }
 425             break;
 426
 427         default:
 428             qDebug("Disabling HTTP communications proxy");
 429         }
 430
 431         qDebug("HTTP communications proxy string: %s"
 432                , qUtf8Printable((proxyConfig.type == Net::ProxyType::SOCKS5) ? proxyStrSOCK : proxyStrHTTP));
 433     }
 434
 435     qputenv("http_proxy", proxyStrHTTP.toLocal8Bit());
 436     qputenv("https_proxy", proxyStrHTTP.toLocal8Bit());
 437     qputenv("sock_proxy", proxyStrSOCK.toLocal8Bit());
 438 }
 439
 440 void SearchPluginManager::versionInfoDownloadFinished(const Net::DownloadResult &result)
 441 {
 442     if (result.status == Net::DownloadStatus::Success)
 443         parseVersionInfo(result.data);
 444     else
 445         emit checkForUpdatesFailed(tr("Update server is temporarily unavailable. %1").arg(result.errorString));
 446 }
 447
 448 void SearchPluginManager::pluginDownloadFinished(const Net::DownloadResult &result)
 449 {
 450     if (result.status == Net::DownloadStatus::Success)
 451     {
 452         const Path filePath = result.filePath;
 453
 454         const auto pluginPath = Path(QUrl(result.url).path()).removedExtension();
 455         installPlugin_impl(pluginPath.filename(), filePath);
 456         Utils::Fs::removeFile(filePath);
 457     }
 458     else
 459     {
 460         const QString url = result.url;
 461         QString pluginName = url.mid(url.lastIndexOf(u'/') + 1);
 462         pluginName.replace(u".py"_s, u""_s, Qt::CaseInsensitive);
 463
 464         if (pluginInfo(pluginName))
 465             emit pluginUpdateFailed(pluginName, tr("Failed to download the plugin file. %1").arg(result.errorString));
 466         else
 467             emit pluginInstallationFailed(pluginName, tr("Failed to download the plugin file. %1").arg(result.errorString));
 468     }
 469 }
 470
 471 // Update nova.py search plugin if necessary
 472 void SearchPluginManager::updateNova()
 473 {
 474     // create nova directory if necessary
 475     const Path enginePath = engineLocation();
 476
 477     QFile packageFile {(enginePath / Path(u"__init__.py"_s)).data()};
 478     packageFile.open(QIODevice::WriteOnly);
 479     packageFile.close();
 480
 481     Utils::Fs::mkdir(enginePath / Path(u"engines"_s));
 482
 483     QFile packageFile2 {(enginePath / Path(u"engines/__init__.py"_s)).data()};
 484     packageFile2.open(QIODevice::WriteOnly);
 485     packageFile2.close();
 486
 487     // Copy search plugin files (if necessary)
 488     const auto updateFile = [&enginePath](const Path &filename, const bool compareVersion)
 489     {
 490         const Path filePathBundled = Path(u":/searchengine/nova3"_s) / filename;
 491         const Path filePathDisk = enginePath / filename;
 492
 493         if (compareVersion && (getPluginVersion(filePathBundled) <= getPluginVersion(filePathDisk)))
 494             return;
 495
 496         Utils::Fs::removeFile(filePathDisk);
 497         Utils::Fs::copyFile(filePathBundled, filePathDisk);
 498     };
 499
 500     updateFile(Path(u"helpers.py"_s), true);
 501     updateFile(Path(u"nova2.py"_s), true);
 502     updateFile(Path(u"nova2dl.py"_s), true);
 503     updateFile(Path(u"novaprinter.py"_s), true);
 504     updateFile(Path(u"socks.py"_s), false);
 505 }
 506
 507 void SearchPluginManager::update()
 508 {
 509     QProcess nova;
 510     nova.setProcessEnvironment(QProcessEnvironment::systemEnvironment());
 511
 512     const QStringList params
 513     {
 514         Utils::ForeignApps::PYTHON_ISOLATE_MODE_FLAG,
 515         (engineLocation() / Path(u"/nova2.py"_s)).toString(),
 516         u"--capabilities"_s
 517     };
 518     nova.start(Utils::ForeignApps::pythonInfo().executableName, params, QIODevice::ReadOnly);
 519     nova.waitForFinished();
 520
 521     const auto capabilities = QString::fromUtf8(nova.readAllStandardOutput());
 522     QDomDocument xmlDoc;
 523     if (!xmlDoc.setContent(capabilities))
 524     {
 525         qWarning() << "Could not parse Nova search engine capabilities, msg: " << capabilities.toLocal8Bit().data();
 526         qWarning() << "Error: " << nova.readAllStandardError().constData();
 527         return;
 528     }
 529
 530     const QDomElement root = xmlDoc.documentElement();
 531     if (root.tagName() != u"capabilities")
 532     {
 533         qWarning() << "Invalid XML file for Nova search engine capabilities, msg: " << capabilities.toLocal8Bit().data();
 534         return;
 535     }
 536
 537     for (QDomNode engineNode = root.firstChild(); !engineNode.isNull(); engineNode = engineNode.nextSibling())
 538     {
 539         const QDomElement engineElem = engineNode.toElement();
 540         if (!engineElem.isNull())
 541         {
 542             const QString pluginName = engineElem.tagName();
 543
 544             auto plugin = std::make_unique<PluginInfo>();
 545             plugin->name = pluginName;
 546             plugin->version = getPluginVersion(pluginPath(pluginName));
 547             plugin->fullName = engineElem.elementsByTagName(u"name"_s).at(0).toElement().text();
 548             plugin->url = engineElem.elementsByTagName(u"url"_s).at(0).toElement().text();
 549
 550             const QStringList categories = engineElem.elementsByTagName(u"categories"_s).at(0).toElement().text().split(u' ');
 551             for (QString cat : categories)
 552             {
 553                 cat = cat.trimmed();
 554                 if (!cat.isEmpty())
 555                     plugin->supportedCategories << cat;
 556             }
 557
 558             const QStringList disabledEngines = Preferences::instance()->getSearchEngDisabled();
 559             plugin->enabled = !disabledEngines.contains(pluginName);
 560
 561             updateIconPath(plugin.get());
 562
 563             if (!m_plugins.contains(pluginName))
 564             {
 565                 m_plugins[pluginName] = plugin.release();
 566                 emit pluginInstalled(pluginName);
 567             }
 568             else if (m_plugins[pluginName]->version != plugin->version)
 569             {
 570                 delete m_plugins.take(pluginName);
 571                 m_plugins[pluginName] = plugin.release();
 572                 emit pluginUpdated(pluginName);
 573             }
 574         }
 575     }
 576 }
 577
 578 void SearchPluginManager::parseVersionInfo(const QByteArray &info)
 579 {
 580     QHash<QString, PluginVersion> updateInfo;
 581     int numCorrectData = 0;
 582
 583     const QVector<QByteArray> lines = Utils::ByteArray::splitToViews(info, "\n", Qt::SkipEmptyParts);
 584     for (QByteArray line : lines)
 585     {
 586         line = line.trimmed();
 587         if (line.isEmpty()) continue;
 588         if (line.startsWith('#')) continue;
 589
 590         const QVector<QByteArray> list = Utils::ByteArray::splitToViews(line, ":", Qt::SkipEmptyParts);
 591         if (list.size() != 2) continue;
 592
 593         const auto pluginName = QString::fromUtf8(list.first().trimmed());
 594         const auto version = PluginVersion::fromString(QString::fromLatin1(list.last().trimmed()));
 595
 596         if (!version.isValid()) continue;
 597
 598         ++numCorrectData;
 599         if (isUpdateNeeded(pluginName, version))
 600         {
 601             LogMsg(tr("Plugin \"%1\" is outdated, updating to version %2").arg(pluginName, version.toString()), Log::INFO);
 602             updateInfo[pluginName] = version;
 603         }
 604     }
 605
 606     if (numCorrectData < lines.size())
 607     {
 608         emit checkForUpdatesFailed(tr("Incorrect update info received for %1 out of %2 plugins.")
 609             .arg(QString::number(lines.size() - numCorrectData), QString::number(lines.size())));
 610     }
 611     else
 612     {
 613         emit checkForUpdatesFinished(updateInfo);
 614     }
 615 }
 616
 617 bool SearchPluginManager::isUpdateNeeded(const QString &pluginName, const PluginVersion &newVersion) const
 618 {
 619     const PluginInfo *plugin = pluginInfo(pluginName);
 620     if (!plugin) return true;
 621
 622     PluginVersion oldVersion = plugin->version;
 623     return (newVersion > oldVersion);
 624 }
 625
 626 Path SearchPluginManager::pluginPath(const QString &name)
 627 {
 628     return (pluginsLocation() / Path(name + u".py"));
 629 }
 630
 631 PluginVersion SearchPluginManager::getPluginVersion(const Path &filePath)
 632 {
 633     const int lineMaxLength = 16;
 634
 635     QFile pluginFile {filePath.data()};
 636     if (!pluginFile.open(QIODevice::ReadOnly | QIODevice::Text))
 637         return {};
 638
 639     while (!pluginFile.atEnd())
 640     {
 641         const auto line = QString::fromUtf8(pluginFile.readLine(lineMaxLength)).remove(u' ');
 642         if (!line.startsWith(u"#VERSION:", Qt::CaseInsensitive)) continue;
 643
 644         const QString versionStr = line.mid(9);
 645         const auto version = PluginVersion::fromString(versionStr);
 646         if (version.isValid())
 647             return version;
 648
 649         LogMsg(tr("Search plugin '%1' contains invalid version string ('%2')")
 650             .arg(filePath.filename(), versionStr), Log::MsgType::WARNING);
 651         break;
 652     }
 653
 654     return {};
 655 }