datacache.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_DATACACHE_H
#define SWIFT_MISC_DATACACHE_H
 
#include <future>
#include <memory>
#include <utility>
#include <vector>
 
#include <QDateTime>
#include <QFileSystemWatcher>
#include <QJsonArray>
#include <QJsonObject>
#include <QList>
#include <QLockFile>
#include <QMap>
#include <QMutex>
#include <QObject>
#include <QPointer>
#include <QSet>
#include <QString>
#include <QStringList>
#include <QUuid>
#include <QtGlobal>
 
#include "misc/identifier.h"
#include "misc/propertyindexref.h"
#include "misc/statusmessage.h"
#include "misc/swiftmiscexport.h"
#include "misc/threadutils.h"
#include "misc/valuecache.h"
#include "misc/valuecacheprivate.h"
#include "misc/variantmap.h"
#include "misc/worker.h"
 
namespace swift::misc
{
    namespace private_ns
    {
        class SWIFT_MISC_EXPORT CDataPageQueue : public QObject
        {
            Q_OBJECT
 
        public:
            CDataPageQueue(CValuePage *parent) : QObject(parent), m_page(parent) {}
 
            void queueValuesFromCache(const swift::misc::CValueCachePacket &values, QObject *changedBy);
 
            void setQueuedValuesFromCache();
 
            void setQueuedValueFromCache(const QString &key);
 
        private:
            CValuePage *m_page = nullptr;
            QList<std::pair<CValueCachePacket, QObject *>> m_queue;
            QMutex m_mutex;
        };
    } // namespace private_ns
 
    class CDataCache;
 
    class SWIFT_MISC_EXPORT CDataCacheRevision
    {
    public:
        CDataCacheRevision(const QString &basename);
 
        ~CDataCacheRevision();
 
        CDataCacheRevision(const CDataCacheRevision &) = delete;
        CDataCacheRevision &operator=(const CDataCacheRevision &) = delete;
 
        class LockGuard;
 
        LockGuard beginUpdate(const QMap<QString, qint64> &timestamps, bool updateUuid = true, bool pinsOnly = false);
 
        void writeNewRevision(const QMap<QString, qint64> &timestamps, const QSet<QString> &excludeKeys = {});
 
        void regenerate(const CValueCachePacket &keys);
 
        void finishUpdate(bool keepPromises = false);
 
        bool isFound() const;
 
        bool isPendingRead() const;
 
        void notifyPendingWrite();
 
        QSet<QString> keysWithNewerTimestamps() const;
 
        const QMap<QString, qint64> &newerTimestamps() const;
 
        bool isNewerValueAvailable(const QString &key, qint64 timestamp);
 
        std::future<void> promiseLoadedValue(const QString &key, qint64 currentTimestamp);
 
        std::vector<std::promise<void>> loadedValuePromises();
 
        void breakPromises();
 
        QString timestampsAsString() const;
 
        void setTimeToLive(const QString &key, int ttl);
 
        void overrideTimestamp(const QString &key, qint64 timestamp);
 
        qint64 getTimestampOnDisk(const QString &key);
 
        void pinValue(const QString &key);
 
        void deferValue(const QString &key);
 
        void admitValue(const QString &key);
 
        void sessionValue(const QString &key);
 
    private:
        mutable QRecursiveMutex m_mutex;
        bool m_updateInProgress = false;
        bool m_found = false;
        bool m_pendingRead = false;
        bool m_pendingWrite = false;
        QString m_basename;
        QLockFile m_lockFile { m_basename + "/.lock" };
        QUuid m_uuid;
        QMap<QString, qint64> m_timestamps;
        QMap<QString, qint64> m_originalTimestamps;
        QMap<QString, qint64> m_timesToLive;
        QSet<QString> m_pinnedValues;
        QSet<QString> m_deferredValues;
        QSet<QString> m_admittedValues;
        QSet<QString> m_admittedQueue;
        QMap<QString, QUuid> m_sessionValues;
        std::vector<std::promise<void>> m_promises;
 
        class Session;
        std::unique_ptr<Session> m_session;
 
        static QJsonObject toJson(const QMap<QString, qint64> &timestamps);
        static QMap<QString, qint64> fromJson(const QJsonObject &timestamps);
        static QJsonArray toJson(const QSet<QString> &pins);
        static QSet<QString> fromJson(const QJsonArray &pins);
        static QJsonObject toJson(const QMap<QString, QUuid> &session);
        static QMap<QString, QUuid> sessionFromJson(const QJsonObject &session);
    };
 
    class SWIFT_MISC_EXPORT CDataCacheSerializer : public swift::misc::CContinuousWorker
    {
        Q_OBJECT
 
    public:
        static const QStringList &getLogCategories();
 
        CDataCacheSerializer(CDataCache *owner, const QString &revisionFileName);
 
        void saveToStore(const swift::misc::CVariantMap &values, const swift::misc::CValueCachePacket &baseline);
 
        CDataCacheRevision::LockGuard loadFromStore(const swift::misc::CValueCachePacket &baseline, bool defer = false,
                                                    bool pinsOnly = false);
 
    signals:
        void valuesLoadedFromStore(const swift::misc::CValueCachePacket &values,
                                   const swift::misc::CIdentifier &originator);
 
    private:
        const QString &persistentStore() const;
        void applyDeferredChanges();
        void deliverPromises(std::vector<std::promise<void>>);
 
        CDataCache *const m_cache = nullptr;
        QUuid m_revision;
        const QString m_revisionFileName;
        swift::misc::CValueCachePacket m_deferredChanges;
    };
 
    class SWIFT_MISC_EXPORT CDataCache : public swift::misc::CValueCache
    {
        Q_OBJECT
 
    public:
        virtual ~CDataCache() override;
 
        static CDataCache *instance();
 
        static const QString &persistentStore();
 
        static const QString &revisionFileName();
 
        static QString filenameForKey(const QString &key);
 
        QStringList enumerateStore() const;
 
        bool synchronize(const QString &key);
 
        void setTimeToLive(const QString &key, int ttl);
 
        void renewTimestamp(const QString &key, qint64 timestamp);
 
        qint64 getTimestampOnDisk(const QString &key);
 
        void pinValue(const QString &key);
 
        void deferValue(const QString &key);
 
        void admitValue(const QString &key, bool triggerLoad);
 
        void sessionValue(const QString &key);
 
        static const QString &relativeFilePath();
 
    private:
        CDataCache();
 
        void saveToStoreAsync(const swift::misc::CValueCachePacket &values);
        void loadFromStoreAsync();
 
        virtual void connectPage(private_ns::CValuePage *page) override;
 
        QFileSystemWatcher m_watcher;
 
        CDataCacheSerializer *m_serializer = nullptr;
        CDataCacheRevision m_revision { persistentStore() + "/" };
        friend class CDataCacheSerializer; // to access m_revision and protected members of CValueCache
    };
 
    template <typename Trait>
    class CData : public CCached<typename Trait::type>
    {
    public:
        template <typename T>
        CData(T *owner)
            : CData::CCached(CDataCache::instance(), Trait::key(), Trait::humanReadable(), Trait::isValid,
                             Trait::defaultValue(), owner)
        {
            if (!this->isInitialized())
            {
                this->onOwnerNameChanged([this, owner] { private_ns::reconstruct(this, owner); });
                return;
            }
            if (Trait::timeToLive() >= 0)
            {
                CDataCache::instance()->setTimeToLive(this->getKey(), Trait::timeToLive());
            }
            if (Trait::isPinned()) { CDataCache::instance()->pinValue(this->getKey()); }
            if (Trait::isDeferred()) { CDataCache::instance()->deferValue(this->getKey()); }
            if (Trait::isSession()) { CDataCache::instance()->sessionValue(this->getKey()); }
            static_assert(!(Trait::isPinned() && Trait::isDeferred()), "trait can not be both pinned and deferred");
        }
 
        template <typename T, typename F>
        CData(T *owner, F slot) : CData(owner)
        {
            this->setNotifySlot(slot);
        }
 
        CStatusMessage set(const typename Trait::type &value, qint64 timestamp = 0)
        {
            CDataCache::instance()->admitValue(this->getKey(), false);
            return CCached<typename Trait::type>::set(value, timestamp);
        }
 
        CStatusMessage setProperty(CPropertyIndexRef index, const CVariant &value, qint64 timestamp = 0)
        {
            CDataCache::instance()->admitValue(this->getKey(), false);
            return CCached<typename Trait::type>::setProperty(index, value, timestamp);
        }
 
        CStatusMessage setDefault() { return this->set(Trait::defaultValue()); }
 
        QString getFilename() const { return CDataCache::filenameForKey(this->getKey()); }
 
        bool isStale() const
        {
            return Trait::timeToLive() >= 0 &&
                   this->getTimestamp() + Trait::timeToLive() > QDateTime::currentMSecsSinceEpoch();
        }
 
        void renewTimestamp(qint64 timestamp)
        {
            return CDataCache::instance()->renewTimestamp(this->getKey(), timestamp);
        }
 
        QDateTime getAvailableTimestamp() const
        {
            if (Trait::isDeferred())
            {
                return QDateTime::fromMSecsSinceEpoch(CDataCache::instance()->getTimestampOnDisk(this->getKey()));
            }
            return this->getTimestamp();
        }
 
        void admit()
        {
            if (Trait::isDeferred()) { CDataCache::instance()->admitValue(this->getKey(), true); }
        }
 
        void synchronize()
        {
            auto *queue = this->m_page->template findChild<private_ns::CDataPageQueue *>();
            Q_ASSERT(queue);
            this->admit();
            const QString key(this->getKey());
            CDataCache::instance()->synchronize(key);
            CDataCache::instance()->synchronize(
                key); // if load was in progress when admit() was called, synchronize with the next load
 
            // run in page thread
            if (CThreadUtils::isInThisThread(this->m_page)) { queue->setQueuedValueFromCache(key); }
            else
            {
                QPointer<QObject> myself(queue);
                QTimer::singleShot(0, queue, [=] {
                    if (!myself) { return; }
                    queue->setQueuedValueFromCache(key);
                });
            }
        }
 
        CStatusMessage setAndSave(const typename Trait::type &value, qint64 timestamp = 0) = delete;
        CStatusMessage setAndSaveProperty(CPropertyIndexRef index, const CVariant &value,
                                          qint64 timestamp = 0) = delete;
 
        CStatusMessage save() = delete;
    };
 
    template <typename Trait>
    class CDataReadOnly : public swift::misc::CData<Trait>
    {
    public:
        using CData<Trait>::CData;
 
        CStatusMessage set(const typename Trait::type &value, qint64 timestamp = 0) = delete;
        CStatusMessage setProperty(CPropertyIndexRef index, const CVariant &value, qint64 timestamp = 0) = delete;
        CStatusMessage setDefault() = delete;
        void renewTimestamp(qint64 timestamp) = delete;
    };
 
    template <typename T>
    struct TDataTrait
    {
        using type = T;
 
        static const char *key()
        {
            qFatal("Not implemented");
            return "";
        }
 
        static const QString &humanReadable()
        {
            static const QString name;
            return name;
        }
 
        static bool isValid(const T &value, QString &reason)
        {
            Q_UNUSED(value);
            Q_UNUSED(reason);
            return true;
        }
 
        static const T &defaultValue()
        {
            static const T def {};
            return def;
        }
 
        static int timeToLive() { return -1; }
 
        static constexpr bool isPinned() { return false; }
 
        static constexpr bool isDeferred() { return false; }
 
        static constexpr bool isSession() { return false; }
 
        TDataTrait() = delete;
 
        TDataTrait(const TDataTrait &) = delete;
 
        TDataTrait &operator=(const TDataTrait &) = delete;
    };
} // namespace swift::misc
 
#endif // SWIFT_MISC_DATACACHE_H