DiskCache.cpp

#include "DiskCache.h"
#include "JsonSerialization.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
#include <fstream>
 
namespace fs = std::filesystem;
 
namespace {
  using namespace Cogs::Core;
  using namespace Cogs::Core::TerrainProvider;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("DiskCache");
 
#if 0
  uint64_t combine(uint32_t a, uint32_t b)
  {
    return (uint64_t(a) << 32) | uint64_t(b);
  }
#endif
 
  std::string buildPath(const std::string& pathPrefix, unsigned i, unsigned j, unsigned level, TerrainProvider::MimeType& kind)
  {
    std::string suffix;
    switch (kind) {
    case TerrainProvider::MimeType::None: suffix = ".none"; break;
    case TerrainProvider::MimeType::Png:  suffix = ".png";  break;
    case TerrainProvider::MimeType::Gif:  suffix = ".gif";  break;
    case TerrainProvider::MimeType::Jpeg: suffix = ".jpg";  break;
    case TerrainProvider::MimeType::Tiff: suffix = ".tif";  break;
    case TerrainProvider::MimeType::F32:  suffix = ".f32";  break;
    case TerrainProvider::MimeType::RGBA8:suffix = ".rgba"; break;
    default:
      assert(false);
      break;
    }
 
    std::string filename = std::to_string(j) + suffix;
 
    return Cogs::IO::combine(pathPrefix, Cogs::IO::combine(std::to_string(level), Cogs::IO::combine(std::to_string(i), filename)));
  }
 
}
 
bool Cogs::Core::TerrainProvider::DiskCache::init(Context* context, const BaseConfig* providerConf, StringView cachesPath)
{
  assert(providerConf);
  assert(providerConf->cacheKey != NoString);
 
  mimeType = providerConf->mimeType;
  if (mimeType == MimeType::None) {
    LOG_ERROR(logger, "No mimetype set.");
    return false;
  }
 
  std::error_code ec;
 
  rootPath = IO::combine(cachesPath.to_string(), Strings::getC(providerConf->cacheKey));
  offline = providerConf->offline;
 
  // Make sure cache directory exists
  if (!fs::exists(rootPath, ec) && !ec) {
    if (offline) {
      LOG_ERROR(logger, "Path '%s' does not exist.", rootPath.c_str());
      return false;
    }
    else {
      if (!fs::create_directories(rootPath, ec) && !ec) {
        LOG_ERROR(logger, "Failed to create path '%s'", rootPath.c_str());
        return false;
      }
      else if (ec) {
        LOG_ERROR(logger, "Failure when creating path %s: %s", rootPath.c_str(), ec.message().c_str());
        return false;
      }
    }
  }
  else if (ec) {
    LOG_ERROR(logger, "Failure when checking path %s: %s", rootPath.c_str(), ec.message().c_str());
    return false;
  }
 
  // Check if there is a config file in the cache directory
 
  auto paramPath = IO::combine(rootPath, "RasterSourceParameters.json");
  auto paramFile = IO::readFileSync(paramPath);
  if (paramFile) {
 
    auto cacheConf = deserializeRastersourceConfig(context, StringView((const char*)paramFile->ptr, paramFile->size));
 
    if (!cacheConf) return false;
 
    if (!providerConf->compatible(cacheConf.get())) {
      LOG_ERROR(logger, "Incompatible configurations");
      return false;
    }
 
  }
  else {
    if (offline) {
      LOG_ERROR(logger, "Failed to read %s", paramPath.c_str());
      return false;
    }
    else {
 
      if (!fs::is_empty(rootPath)) {
        LOG_ERROR(logger, "%s is not empty and does not contain a rastersource config file", rootPath.c_str());
        return false;
      }
 
      Cogs::Memory::MemoryBuffer buf;
      if (!serializeConfig(buf, providerConf)) {
        LOG_ERROR(logger, "Failed to serialize rastersource");
        return false;
      }
      if (!IO::writeBinaryFile(paramPath, buf.data(), buf.size())) {
        LOG_ERROR(logger, "Error writing %s", paramPath.c_str());
        return false;
      }
    }
  }
 
 
 
  LOG_DEBUG(logger, "Using disk cache at %s%s", rootPath.c_str(), offline ? " (offline)" : "");
 
  initialized = true;
  return true;
}
 
bool Cogs::Core::TerrainProvider::DiskCache::getTile(Memory::MemoryBuffer& contents, MimeType& kind, const TileId& id)
{
  if (!initialized) return false;
 
  kind = mimeType;
  auto tilePath = buildPath(rootPath, id.i, id.j, id.level, kind);
  std::ifstream in(tilePath, std::ios::binary | std::ios::in | std::ios::ate);
  if (!in.is_open()) {
    return false;
  }
 
  in.seekg(0, std::ios::end);
  size_t file_size = in.tellg();
  contents.resize(file_size, false);
 
  in.seekg(0, std::ios::beg);
  in.read((char*)contents.data(), contents.size());
  in.close();
 
  return contents.size() != 0;
}
 
bool Cogs::Core::TerrainProvider::DiskCache::storeTile(const Memory::MemoryBuffer& contents, MimeType kind, const TileId& id, StringView debugLog)
{
  if (contents.size() == 0 && debugLog.size() == 0) return true;
 
  std::error_code ec;
 
  auto tilePath = buildPath(rootPath, id.i, id.j, id.level, kind);
  auto parentPath = fs::path(tilePath).parent_path();
 
  if (!fs::exists(parentPath, ec) && !ec) {
 
    if (!fs::create_directories(parentPath, ec) && !ec) {
      LOG_ERROR(logger, "Failed to create path: %s", parentPath.generic_string().c_str());
      return false;
    }
    else if (ec) {
      LOG_ERROR(logger, "Failure when creating path %s: %s", parentPath.generic_string().c_str(), ec.message().c_str());
      return false;
    }
  }
  else if (ec) {
    LOG_ERROR(logger, "Failure checking tile path: %s", ec.message().c_str());
    return false;
  }
 
 
  if (contents.size() != 0 && kind != MimeType::None) {
 
    if (kind != mimeType) {
      LOG_ERROR(logger, "Mismatched mime-type, cache mime-type=%s, tile mime-type=%s",
                Strings::getC(mimeTypeString(mimeType)),
                Strings::getC(mimeTypeString(kind)));
      return false;
    }
 
    if (!IO::writeBinaryFile(tilePath, contents.data(), contents.size())) {
      LOG_ERROR(logger, "Error writing %s", tilePath.c_str());
      return false;
    }
  }
 
  if (!debugLog.empty()) {
    auto logPath = tilePath + ".txt";
    if (!IO::writeBinaryFile(logPath, debugLog.data(), debugLog.size())) {
      LOG_ERROR(logger, "Error writing debug log %s", logPath.c_str());
      return false;
    }
  }
 
  return true;
}