FileSystemWatcher.Linux.cpp

#include "FileSystemWatcher.h"
 
#include "IO.h"
 
#include <stdio.h>
#include <sys/inotify.h>
#include <unistd.h>
 
#include <chrono>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_map>
 
using namespace std::chrono;
 
namespace Cogs {
  struct Item {
    Item(const FileSystemWatcher::CallbackFn& callback, int descriptor, const std::string& filename) : descriptor(descriptor) {
      callbacks.push_back(callback);
      fileTime = IO::getFileTime(filename);
    }
 
    FileSystemWatcher::CallbackList callbacks;
    fs::file_time_type              fileTime;
    int                             descriptor;
  };
 
  struct Storage {
    typedef std::unordered_map<std::string, Item> ItemMap;
 
    int             notifyHandle = -1;
    std::mutex      mutex;
    ItemMap         items;
    std::thread     watcherThread;
    bool volatile   watcherDone = false;
 
    ItemMap::const_iterator FindItem(int wd) const {
      auto  e = items.end();
 
      for (auto i = items.begin(); i != e; ++i) {
        if (i->second.descriptor == wd) {
          return i;
        }
      }
      return e;
    }
  };
}
 
Cogs::FileSystemWatcher::FileSystemWatcher() {
  storage = new Storage();
  storage->notifyHandle = inotify_init1(IN_NONBLOCK);
 
  if (storage->notifyHandle == -1) {
    // ...
    return;
  }
 
  storage->watcherThread = std::thread([this]{
    uint8_t         buffer[sizeof(inotify_event)];
    inotify_event*  e = reinterpret_cast<inotify_event*>(buffer);
    size_t          bytesread = 0;
 
    while (!storage->watcherDone) {
      int justread = read(storage->notifyHandle, buffer + bytesread, sizeof(inotify_event) - bytesread);
 
      if (justread == -1) {
        switch (errno) {
          case EWOULDBLOCK: {
            std::this_thread::sleep_for(500ms);
            break;
          }
          default: {
            bytesread = 0;
            break;
          }
        }
      }
      else {
        bytesread += justread;
 
        if (bytesread == sizeof(inotify_event)) {
          switch (e->mask) {
            case IN_MODIFY: {
              std::lock_guard<std::mutex> lock(storage->mutex);
              auto                        i = storage->FindItem(e->wd);
 
              if (i != storage->items.end()) {
                Event e = { i->first, EventType::FileUpdated };
 
                for (auto& callback : i->second.callbacks) {
                  callback(e);
                }
              }
              break;
            }
            //case IN_MOVE_SELF:
            case IN_DELETE_SELF:
            {
              std::lock_guard<std::mutex> lock(storage->mutex);
              auto                        i = storage->FindItem(e->wd);
 
              if (i != storage->items.end()) {
                Event e = { i->first, EventType::FileDeleted };
 
                for (auto& callback : i->second.callbacks) {
                  callback(e);
                }
                inotify_rm_watch(storage->notifyHandle, i->second.descriptor);
                storage->items.erase(i);
              }
              break;
            }
          }
          bytesread = 0;
        }
      }
    }
  });
}
 
Cogs::FileSystemWatcher::~FileSystemWatcher() {
  if (storage->watcherThread.joinable()) {
    storage->watcherDone = true;
    storage->watcherThread.join();
  }
  close(storage->notifyHandle);
  delete storage;
}
 
bool Cogs::FileSystemWatcher::watchFile(const StringView& path, const CallbackFn& callback) {
  const auto absoluteFilePath = IO::absolute(path.to_string());
 
  if (IO::exists(absoluteFilePath)) {
    std::lock_guard<std::mutex> lock(storage->mutex);
    auto                        i = storage->items.find(absoluteFilePath);
 
    if (i == storage->items.end()) {
      int descriptor = inotify_add_watch(storage->notifyHandle, absoluteFilePath.c_str(), IN_MODIFY | IN_MOVE_SELF | IN_DELETE_SELF);
 
      if (descriptor >= 0) {
        storage->items.emplace(absoluteFilePath, Item(callback, descriptor, absoluteFilePath));
        return true;
      }
    }
    else {
      i->second.callbacks.push_back(callback);
      return true;
    }
  }
  return false;
}
 
bool Cogs::FileSystemWatcher::unwatchFile(const StringView& path) {
  const auto                  absoluteFilePath = IO::absolute(path.to_string());
  std::lock_guard<std::mutex> lock(storage->mutex);
  auto                        i = storage->items.find(absoluteFilePath);
 
  if (i != storage->items.end()) {
    inotify_rm_watch(storage->notifyHandle, i->second.descriptor);
    storage->items.erase(i);
    return true;
  }
  return false;
}