FileSystemWatcher.Windows.cpp

#include "Logging/Logger.h"
#include "FileSystemWatcher.h"
 
#include "IO.h"
 
#define DR_FSW_IMPLEMENTATION
#include <dr_libs/dr_fsw.h>
 
#include <atomic>
#include <mutex>
#include <thread>
#include <unordered_map>
 
namespace Cogs {
  constexpr Cogs::Logging::Log logger = Cogs::Logging::getLogger("FileSystemWatcher");
 
  struct FileEntry {
    std::vector<FileSystemWatcher::CallbackFn>  callbacks;
    fs::file_time_type                          fileTime;
  };
 
  struct DirectoryEntry {
    std::atomic<int> usage = {};
    bool initial = true;
  };
 
  struct Storage {
    drfsw_context * fswContext = nullptr;
 
    std::mutex directoriesMutex;
    std::unordered_map<std::string, DirectoryEntry> directories;
 
    std::mutex filesMutex;
    std::unordered_map<std::string, FileEntry> files;
 
    std::thread watcherThread;
    std::atomic<bool> watcherDone = false;
  };  
}
 
Cogs::FileSystemWatcher::FileSystemWatcher()
{
  storage = new Storage();
  storage->fswContext = drfsw_create_context();
 
  if (!storage->fswContext) {
    // ...
    return;
  }
 
  storage->watcherThread = std::thread([this]{
    drfsw_event e;
    while (!storage->watcherDone && drfsw_next_event(storage->fswContext, &e)) {
      switch (e.type) {
        case drfsw_event_type_updated:
        {
          const std::string canonicalFilePath = IO::canonical(e.absolutePath);
 
          if (std::strcmp(e.absoluteBasePath, e.absolutePath) == 0) {
 
            // If base path and path is equal, this is an extra event
            // when a directory watch is just become operational. 
 
            std::unique_lock dirsLock(storage->directoriesMutex);
            if (auto dirIt = storage->directories.find(canonicalFilePath); dirIt != storage->directories.end()) {
              DirectoryEntry& dirEntry = dirIt->second;
 
              // First check if this is the first time we get such an event, if not, ignore it.
              if (!dirEntry.initial) {
                break;  // Found directory and it was not first visit, done with event.
              }
              else {
                dirEntry.initial = false; // First visit
                dirsLock.unlock();        // Done with directories and dirEntry
 
                // Now, check all files with this prefix if the timestamp has changed.
                const size_t N = canonicalFilePath.length();
 
                std::lock_guard filesLock(storage->filesMutex);
                for (auto& fileIt : storage->files) {
                  const std::string& filePath = fileIt.first;
 
                  // Check if directory is a prefix of path
                  if (N <= canonicalFilePath.size() && (std::strncmp(canonicalFilePath.c_str(), filePath.c_str(), N) == 0)) {
 
                    // Yes, check if filetime has changed
                    FileEntry& fileEntry = fileIt.second;
                    IO::FileTimeType fileTime = IO::getFileTime(filePath);
                    if (fileEntry.fileTime != fileTime) {
                      fileEntry.fileTime = fileTime;
 
                      // Yes, we have a missing file modification
                      LOG_DEBUG(logger, "Detected modification between watcher issued and operational: %s", filePath.c_str());
                      FileSystemWatcher::Event args = { filePath, FileSystemWatcher::EventType::FileUpdated };
                      for (auto& callback : fileEntry.callbacks) {
                        callback(args);
                      }
                    }
                  }
                }
              }
            }
          }
 
          else {
 
            // Run through callbacks and see if we have a match
            std::lock_guard filesLock(storage->filesMutex);
            if (auto cbIt = storage->files.find(canonicalFilePath); cbIt != storage->files.end()) {
              FileEntry& fileEntry = cbIt->second;
 
              IO::FileTimeType fileTime = IO::getFileTime(canonicalFilePath);
              if (fileEntry.fileTime != fileTime) {
                fileEntry.fileTime = fileTime;
 
                LOG_DEBUG(logger, "Detected modification: %s", canonicalFilePath.c_str());
 
                FileSystemWatcher::Event args = { cbIt->first, FileSystemWatcher::EventType::FileUpdated };
                for (auto& callback : fileEntry.callbacks) {
                  callback(args);
                }
              }
              break;  // Found entry and checked timestamp, done with event
            }
          }
        }
        break;
      default:
        break;
      }
    }
  });
}
 
Cogs::FileSystemWatcher::~FileSystemWatcher()
{
  if (storage->fswContext) {
    // See dr_fsw.h for shutdown sequence documentation.
    auto fswContext = storage->fswContext;
    storage->fswContext = nullptr;
    drfsw_delete_context(fswContext);
  }
 
  if (storage->watcherThread.joinable()) {
    storage->watcherDone = true;
    storage->watcherThread.join();
  }
 
  delete storage;
}
 
bool Cogs::FileSystemWatcher::watchFile(const StringView& path, const CallbackFn& callback)
{
  const std::string absoluteFilePath = IO::absolute(path);
 
  if (!IO::exists(absoluteFilePath)) return false;
 
  const std::string canonicalPath = IO::canonical(absoluteFilePath);
  const std::string directoryPath = IO::parentPath(canonicalPath);
 
  {
    std::lock_guard lock(storage->filesMutex);
 
    // If this is the first watch for a file, we set the timestamp to the current
    // timestamp as this is the version that the caller will see when we return.
    auto it = storage->files.insert({ canonicalPath, {{}, IO::getFileTime(canonicalPath) } });
    it.first->second.callbacks.emplace_back(callback);
  }
 
  {
    // Set up a watcher for this directory if we don't already have one. 
    std::lock_guard lock(storage->directoriesMutex);
    if (auto found = storage->directories.find(directoryPath); found == storage->directories.end()) {
      storage->directories[directoryPath].usage++;
      drfsw_add_directory(storage->fswContext, directoryPath.c_str());
    }
  }
 
 
  return true;
}
 
bool Cogs::FileSystemWatcher::unwatchFile(const StringView & path)
{
  const std::string absoluteFilePath = IO::absolute(path);
 
  if (!IO::exists(absoluteFilePath)) return false;
 
  const std::string canonicalPath = IO::canonical(path);
  const std::string directoryPath = IO::parentPath(canonicalPath);
 
  {
    std::lock_guard lock(storage->directoriesMutex);
 
    auto found = storage->directories.find(directoryPath);
 
    if (found == storage->directories.end()) {
      return false;
    }
 
    if (found->second.usage.fetch_sub(1) == 1) {
      drfsw_remove_directory(storage->fswContext, directoryPath.c_str());
 
      storage->directories.erase(found);
    }
  }
 
  std::lock_guard lock(storage->filesMutex);
  if (auto fileIt = storage->files.find(absoluteFilePath); fileIt != storage->files.end()) {
    storage->files.erase(fileIt);
  }
 
  return true;
}