File indexing completed on 2024-04-14 03:54:06

 /*
     SPDX-FileCopyrightText: 2009 Frederik Gladhorn <gladhorn@kde.org>
     SPDX-FileCopyrightText: 2010 Matthias Fuchs <mat69@gmx.net>
 
     SPDX-License-Identifier: LGPL-2.1-or-later
 */
 
 #include "cache.h"
 
 #include <QDir>
 #include <QDomElement>
 #include <QFile>
 #include <QFileInfo>
 #include <QFileSystemWatcher>
 #include <QPointer>
 #include <QTimer>
 #include <QXmlStreamReader>
 #include <knewstuffcore_debug.h>
 #include <qstandardpaths.h>
 
 class KNSCore::CachePrivate
 {
 public:
     CachePrivate(Cache *qq)
         : q(qq)
     {
     }
     ~CachePrivate()
     {
     }
 
     Cache *q;
     QHash<QString, Entry::List> requestCache;
 
     QPointer<QTimer> throttleTimer;
 
     // The file that is used to keep track of downloaded entries
     QString registryFile;
 
     QSet<Entry> cache;
 
     bool dirty = false;
     bool writingRegistry = false;
     bool reloadingRegistry = false;
 
     void throttleWrite()
     {
         if (!throttleTimer) {
             throttleTimer = new QTimer(q);
             QObject::connect(throttleTimer, &QTimer::timeout, q, [this]() {
                 q->writeRegistry();
             });
             throttleTimer->setSingleShot(true);
             throttleTimer->setInterval(1000);
         }
         throttleTimer->start();
     }
 };
 
 using namespace KNSCore;
 
 typedef QHash<QString, QWeakPointer<Cache>> CacheHash;
 Q_GLOBAL_STATIC(CacheHash, s_caches)
 Q_GLOBAL_STATIC(QFileSystemWatcher, s_watcher)
 
 Cache::Cache(const QString &appName)
     : QObject(nullptr)
     , d(new CachePrivate(this))
 {
     const QString path = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1String("/knewstuff3/");
     QDir().mkpath(path);
     d->registryFile = path + appName + QStringLiteral(".knsregistry");
     qCDebug(KNEWSTUFFCORE) << "Using registry file: " << d->registryFile;
 
     s_watcher->addPath(d->registryFile);
 
     std::function<void()> changeChecker = [this, &changeChecker]() {
         if (d->writingRegistry) {
             QTimer::singleShot(0, this, changeChecker);
         } else {
             d->reloadingRegistry = true;
             const QSet<KNSCore::Entry> oldCache = d->cache;
             d->cache.clear();
             readRegistry();
             // First run through the old cache and see if any have disappeared (at
             // which point we need to set them as available and emit that change)
             for (const Entry &entry : oldCache) {
                 if (!d->cache.contains(entry) && entry.status() != KNSCore::Entry::Deleted) {
                     Entry removedEntry(entry);
                     removedEntry.setEntryDeleted();
                     Q_EMIT entryChanged(removedEntry);
                 }
             }
             // Then run through the new cache and see if there's any that were not
             // in the old cache (at which point just emit those as having changed,
             // they're already the correct status)
             for (const Entry &entry : std::as_const(d->cache)) {
                 auto iterator = oldCache.constFind(entry);
                 if (iterator == oldCache.constEnd()) {
                     Q_EMIT entryChanged(entry);
                 } else if ((*iterator).status() != entry.status()) {
                     // If there are entries which are in both, but which have changed their
                     // status, we should adopt the status from the newly loaded cache in place
                     // of the one in the old cache. In reality, what this means is we just
                     // need to emit the changed signal for anything in the new cache which
                     // doesn't match the old one
                     Q_EMIT entryChanged(entry);
                 }
             }
             d->reloadingRegistry = false;
         }
     };
     connect(&*s_watcher, &QFileSystemWatcher::fileChanged, this, [this, changeChecker](const QString &file) {
         if (file == d->registryFile) {
             changeChecker();
         }
     });
 }
 
 QSharedPointer<Cache> Cache::getCache(const QString &appName)
 {
     CacheHash::const_iterator it = s_caches()->constFind(appName);
     if ((it != s_caches()->constEnd()) && !(*it).isNull()) {
         return QSharedPointer<Cache>(*it);
     }
 
     QSharedPointer<Cache> p(new Cache(appName));
     s_caches()->insert(appName, QWeakPointer<Cache>(p));
     QObject::connect(p.data(), &QObject::destroyed, [appName] {
         if (auto cache = s_caches()) {
             cache->remove(appName);
         }
     });
 
     return p;
 }
 
 Cache::~Cache()
 {
     s_watcher->removePath(d->registryFile);
 }
 
 void Cache::readRegistry()
 {
     QFile f(d->registryFile);
     if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
         if (QFileInfo::exists(d->registryFile)) {
             qWarning() << "The file " << d->registryFile << " could not be opened.";
         }
         return;
     }
 
     QXmlStreamReader reader(&f);
     if (reader.hasError() || !reader.readNextStartElement()) {
         qCWarning(KNEWSTUFFCORE) << "The file could not be parsed.";
         return;
     }
 
     if (reader.name() != QLatin1String("hotnewstuffregistry")) {
         qCWarning(KNEWSTUFFCORE) << "The file doesn't seem to be of interest.";
         return;
     }
 
     for (auto token = reader.readNext(); !reader.atEnd(); token = reader.readNext()) {
         if (token != QXmlStreamReader::StartElement) {
             continue;
         }
         Entry e;
         e.setEntryXML(reader);
         e.setSource(Entry::Cache);
         d->cache.insert(e);
         Q_ASSERT(reader.tokenType() == QXmlStreamReader::EndElement);
     }
 
     qCDebug(KNEWSTUFFCORE) << "Cache read... entries: " << d->cache.size();
 }
 
 Entry::List Cache::registryForProvider(const QString &providerId)
 {
     Entry::List entries;
     for (const Entry &e : std::as_const(d->cache)) {
         if (e.providerId() == providerId) {
             entries.append(e);
         }
     }
     return entries;
 }
 
 Entry::List Cache::registry() const
 {
     Entry::List entries;
     for (const Entry &e : std::as_const(d->cache)) {
         entries.append(e);
     }
     return entries;
 }
 
 void Cache::writeRegistry()
 {
     if (!d->dirty) {
         return;
     }
 
     qCDebug(KNEWSTUFFCORE) << "Write registry";
 
     d->writingRegistry = true;
     QFile f(d->registryFile);
     if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
         qWarning() << "Cannot write meta information to" << d->registryFile;
         return;
     }
 
     QDomDocument doc(QStringLiteral("khotnewstuff3"));
     doc.appendChild(doc.createProcessingInstruction(QStringLiteral("xml"), QStringLiteral("version=\"1.0\" encoding=\"UTF-8\"")));
     QDomElement root = doc.createElement(QStringLiteral("hotnewstuffregistry"));
     doc.appendChild(root);
 
     for (const Entry &entry : std::as_const(d->cache)) {
         // Write the entry, unless the policy is CacheNever and the entry is not installed.
         if (entry.status() == KNSCore::Entry::Installed || entry.status() == KNSCore::Entry::Updateable) {
             QDomElement exml = entry.entryXML();
             root.appendChild(exml);
         }
     }
 
     QTextStream metastream(&f);
     metastream << doc.toByteArray();
 
     d->dirty = false;
     d->writingRegistry = false;
 }
 
 void Cache::registerChangedEntry(const KNSCore::Entry &entry)
 {
     // If we have intermediate states, like updating or installing we do not want to write them
     if (entry.status() == KNSCore::Entry::Updating || entry.status() == KNSCore::Entry::Installing) {
         return;
     }
     if (!d->reloadingRegistry) {
         d->dirty = true;
         d->cache.remove(entry); // If value already exists in the set, the set is left unchanged
         d->cache.insert(entry);
         d->throttleWrite();
     }
 }
 
 void Cache::insertRequest(const KNSCore::Provider::SearchRequest &request, const KNSCore::Entry::List &entries)
 {
     // append new entries
     auto &cacheList = d->requestCache[request.hashForRequest()];
     for (const auto &entry : entries) {
         if (!cacheList.contains(entry)) {
             cacheList.append(entry);
         }
     }
     qCDebug(KNEWSTUFFCORE) << request.hashForRequest() << " add to cache: " << entries.size() << " keys: " << d->requestCache.keys();
 }
 
 Entry::List Cache::requestFromCache(const KNSCore::Provider::SearchRequest &request)
 {
     qCDebug(KNEWSTUFFCORE) << "from cache" << request.hashForRequest();
     return d->requestCache.value(request.hashForRequest());
 }
 
 void KNSCore::Cache::removeDeletedEntries()
 {
     QMutableSetIterator<KNSCore::Entry> i(d->cache);
     while (i.hasNext()) {
         const KNSCore::Entry &entry = i.next();
         bool installedFileExists{false};
         const QStringList installedFiles = entry.installedFiles();
         for (const auto &installedFile : installedFiles) {
             // Handle the /* notation, BUG: 425704
             if (installedFile.endsWith(QLatin1String("/*"))) {
                 if (QDir(installedFile.left(installedFile.size() - 2)).exists()) {
                     installedFileExists = true;
                     break;
                 }
             } else if (QFile::exists(installedFile)) {
                 installedFileExists = true;
                 break;
             }
         }
         if (!installedFileExists) {
             i.remove();
             d->dirty = true;
         }
     }
     writeRegistry();
 }
 
 KNSCore::Entry KNSCore::Cache::entryFromInstalledFile(const QString &installedFile) const
 {
     for (const Entry &entry : std::as_const(d->cache)) {
         if (entry.installedFiles().contains(installedFile)) {
             return entry;
         }
     }
     return Entry{};
 }
 
 #include "moc_cache.cpp"