FileCache.cpp

#include "FileCache.h"

#include "FileSystem.h"
#include "MimeTypes.h"
#include "Compression.h"
#include "ETag.h"
#include "LastModified.h"
#include "Logger.h"
#include "RequestInspector.h"

#include <iostream>

using namespace std;

unordered_map<string, FileCache::CacheEntry>
FileCache::cache;

std::mutex FileCache::mutex;

FileCache::CacheEntry
FileCache::get(const string& path)
{
    lock_guard<std::mutex> lock(FileCache::mutex);

    time_t currentModified =
        FileSystem::getLastWriteTime(path);

    auto it = cache.find(path);

    // ------------------------------
    // CACHE HIT
    // ------------------------------
    if(it != cache.end())
    {
        if(it->second.modifiedTime == currentModified)
        {
            RequestInspector::current().setMetadataCache("HIT");
            RequestInspector::current().setFileCache("HIT", "File already loaded in memory");

            return it->second;
        }

        RequestInspector::current().setMetadataCache("REFRESH");
        RequestInspector::current().setFileCache("REFRESH", "File modified on disk");
    }
    else
    {
        RequestInspector::current().setMetadataCache("MISS");
        RequestInspector::current().setFileCache("MISS", "First time loading file");
    }

    // ------------------------------
    // Build new cache entry
    // ------------------------------
    CacheEntry entry;

    entry.body =
        FileSystem::readFile(path);

    if(entry.body.empty())
    {
        return entry;
    }

    entry.modifiedTime = currentModified;

    entry.fileSize =
        FileSystem::getFileSize(path);

    entry.mimeType =
        MimeTypes::get(path);

    entry.etag =
        ETag::generate(path);

    entry.lastModified =
        LastModified::generate(path);

    bool compressible =
           entry.mimeType.find("text/") == 0
        || entry.mimeType == "application/javascript"
        || entry.mimeType == "application/json"
        || entry.mimeType == "image/svg+xml";

    if(compressible)
    {
        entry.gzipBody =
            Compression::gzip(entry.body);
    }

    cache[path] = entry;

    return entry;
}

void FileCache::clear()
{
    lock_guard<std::mutex> lock(FileCache::mutex);

    cache.clear();
}