WebCache.h

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include <iostream>
#include <string>
#include <filesystem>
#include <map>
#include <mutex>
#include <optional>
#include <fstream>
#include <list>
#include <utility>
#include <future>
#include <vector>
#include "CommonSignals.h"

namespace rose {

    struct WebCacheItem {
        uint32_t key;
        std::string_view name;
    };

    using WebCacheProtocol = Protocol<uint32_t,long>;

    using namespace std::filesystem;

    class WebCache {
        GraphicsModelFrameProtocol::slot_type mFrameProtocol{};

    public:
        using key_t = uint32_t;
        using local_id_t = std::string;
        using result_t = std::tuple<long, key_t>;
        using item_map_t = std::map<key_t, local_id_t>;

        using AsyncList = std::vector<std::future<result_t>>;

        template<typename T>
        static std::chrono::system_clock::time_point fileClockToSystemClock(T fileTimePoint) {
            using namespace std::chrono_literals;
            using namespace std::chrono;

            auto sysWriteTime = time_point_cast<system_clock::duration>(
                    fileTimePoint - decltype(fileTimePoint)::clock::now() +
                    system_clock::now());
            return sysWriteTime;
        }

        static std::chrono::system_clock::time_point fileClockToSystemClock(const path &filePath) {
            return fileClockToSystemClock(std::filesystem::last_write_time(filePath));
        }

        WebCacheProtocol::signal_type cacheLoaded{};

    protected:
        std::error_code mEc{};          
        std::string mRootURI{};         
        path mStoreRoot{};              
        mutable file_status mStoreStatus{};     
        std::mutex mMutex;              

        item_map_t mItemMap{};          

        AsyncList mAsyncList{};         

        std::chrono::system_clock::duration mCacheValidDuration{};

        void asyncFetchItem(item_map_t::value_type& item) {
            auto itemPath = mStoreRoot;
            auto tempPath = mStoreRoot;
            auto itemName = translateItemLocalId(item.second);
            itemPath.append(itemName);
            tempPath.append('.' + itemName);
            if (!itemPath.empty()) {
                std::optional<time_t> cacheFileTime{};
                if (exists(itemPath))
                    if (cacheFileTime = cacheTime(itemPath); !cacheFileTime) {
                        cacheLoaded.transmit(item.first, 503);
                        return;
                    }

                mAsyncList.emplace_back(
                        std::async(std::launch::async, fetch, item.first, constructUrl(item.second), itemPath, tempPath,
                                   cacheFileTime));
                CommonSignals::getCommonSignals().frameSignal.connect(mFrameProtocol);
            }
        }

    public:
        WebCache() = delete;

        virtual ~WebCache() = default;

        WebCache(const std::string &rootUri, const path &xdgDir, const std::string &storeRoot,
                 std::chrono::system_clock::duration duration);

        template<typename It>
        WebCache(const std::string &rootUri, const path &xdgDir, const std::string &storeRoot,
                 std::chrono::system_clock::duration duration, It first, It last)
                 : WebCache(rootUri, xdgDir, storeRoot, duration) {
                     setCacheItem(first, last);
                 }

        void setCacheItem(key_t key, local_id_t localId) {
            mItemMap[key] = std::move(localId);
        }

        template<typename It>
        void setCacheItem(It first, It last) {
            while (first != last) {
                setCacheItem(first->key, std::string(first->name));
                first++;
            }
        }

        bool storeExists() const {
            if (!status_known(mStoreStatus))
                mStoreStatus = status(mStoreRoot);

            return exists(mStoreStatus) && is_directory(mStoreStatus);
        }

        virtual std::string translateItemLocalId(local_id_t localId) {
            return localId;
        }

        path itemLocalPath(key_t key) {
            if (auto item = mItemMap.find(key); item != mItemMap.end()) {
                auto itemPath = mStoreRoot;
                itemPath.append(translateItemLocalId(item->second));
                return itemPath;
            }
            return path{};
        }

        std::optional<path> localItemExists(key_t key) {
            if (auto itemPath = itemLocalPath(key); !itemPath.empty()) {
                if (exists(itemPath))
                    return itemPath;
            }
            return std::nullopt;
        }

        std::optional<time_t> cacheTime(const path &itemPath) {
            auto cacheFiletime = fileClockToSystemClock(std::filesystem::last_write_time(itemPath));
            auto cacheFileAge = std::chrono::system_clock::now() - cacheFiletime;
            if (cacheFileAge > mCacheValidDuration)
                return std::chrono::system_clock::to_time_t(cacheFiletime);
            return std::nullopt;
        }

        static WebCache::result_t
        fetch(WebCache::key_t key, const std::string &itemUrl, const path &itemPath, const path &tempPath,
              std::optional<time_t> cacheFileTime);

        virtual std::string constructUrl(const local_id_t &localId) {
            return mRootURI + localId;
        }

        bool itemKnown(key_t key) {
            return mItemMap.find(key) != mItemMap.end();
        }

        bool fetchAll() {
            AsyncList asyncList{};
            std::lock_guard<std::mutex> lockGuard{mMutex};

            for (auto &item : mItemMap) {
                asyncFetchItem(item);
            }
            return !mAsyncList.empty();
        }

        bool fetchItem(key_t key) {
            auto item = mItemMap.find(key);
            if (item != mItemMap.end()) {
                asyncFetchItem(*item);
            }
            return !mAsyncList.empty();
        }

        bool pendingFutures() const {
            return !mAsyncList.empty();
        }

        bool processFutures() {
            if (mAsyncList.empty())
                return false;

            std::lock_guard<std::mutex> lockGuard{mMutex};
            std::chrono::milliseconds span{100};
            for (auto &item : mAsyncList) {
                try {
                    if (item.valid()) {
                        if (auto futureStatus = item.wait_for(span); futureStatus == std::future_status::ready) {
                            auto[status, key] = item.get();
                            cacheLoaded.transmit(key,status);
                        }
                    }
                } catch (const std::exception &e) {
                    std::cout << __PRETTY_FUNCTION__ << ' ' << e.what() << '\n';
                }
            }

            mAsyncList.erase(std::remove_if(mAsyncList.begin(), mAsyncList.end(),
                                           [](std::future<result_t> &f) -> bool { return !f.valid(); }),
                            mAsyncList.end());

            return !mAsyncList.empty();
        }
    };
}