1248 lines
43 KiB
C++
1248 lines
43 KiB
C++
// MIT License
|
|
//
|
|
// Copyright(c) 2017 Thomas Monkman
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files(the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions :
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
// SOFTWARE.
|
|
|
|
#ifndef FILEWATCHER_H
|
|
#define FILEWATCHER_H
|
|
|
|
#include <cstdio>
|
|
#include <fstream>
|
|
#ifdef _WIN32
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#ifndef NOMINMAX
|
|
#define NOMINMAX
|
|
#endif
|
|
#include <windows.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <tchar.h>
|
|
#include <Pathcch.h>
|
|
#include <shlwapi.h>
|
|
#endif // WIN32
|
|
|
|
#if __unix__
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <sys/types.h>
|
|
#include <sys/inotify.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <dirent.h>
|
|
#include <unistd.h>
|
|
#endif // __unix__
|
|
|
|
#ifdef __linux__
|
|
#include <linux/limits.h>
|
|
#endif
|
|
|
|
#if defined(__APPLE__) || defined(__MACH__)
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
#include <CoreServices/CoreServices.h>
|
|
#include <sys/param.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <dirent.h>
|
|
#define FILEWATCH_PLATFORM_MAC 1
|
|
#endif
|
|
|
|
#include <functional>
|
|
#include <atomic>
|
|
#include <thread>
|
|
#include <mutex>
|
|
#include <condition_variable>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include <array>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <system_error>
|
|
#include <string>
|
|
#include <algorithm>
|
|
#include <type_traits>
|
|
#include <future>
|
|
#include <regex>
|
|
#include <cstddef>
|
|
#include <cstring>
|
|
#include <cwchar>
|
|
#include <cassert>
|
|
#include <cstdlib>
|
|
#include <iostream>
|
|
|
|
#ifdef FILEWATCH_PLATFORM_MAC
|
|
extern "C" int __getdirentries64(int, char *, int, long *);
|
|
#endif // FILEWATCH_PLATFORM_MAC
|
|
|
|
namespace filewatch {
|
|
enum class Event {
|
|
added,
|
|
removed,
|
|
modified,
|
|
renamed_old,
|
|
renamed_new
|
|
};
|
|
|
|
template<typename StringType>
|
|
struct IsWChar {
|
|
static constexpr bool value = false;
|
|
};
|
|
|
|
template<>
|
|
struct IsWChar<wchar_t> {
|
|
static constexpr bool value = true;
|
|
};
|
|
|
|
template<typename Fn, typename... Args>
|
|
struct Invokable {
|
|
static Fn make() {
|
|
return (Fn*)0;
|
|
}
|
|
|
|
template<typename T>
|
|
static T defaultValue() {
|
|
return *(T*)0;
|
|
}
|
|
|
|
static void call(int) {
|
|
make()(defaultValue<Args...>());
|
|
}
|
|
|
|
static int call(long value);
|
|
|
|
static constexpr bool value = std::is_same<decltype(call(0)), int>::value;
|
|
};
|
|
|
|
#define _FILEWATCH_TO_STRING(x) #x
|
|
#define FILEWATCH_TO_STRING(x) _FILEWATCH_TO_STRING(x)
|
|
|
|
[[maybe_unused]] static const char* event_to_string(Event event) {
|
|
switch (event) {
|
|
case Event::added:
|
|
return FILEWATCH_TO_STRING(Event::added);
|
|
case Event::removed:
|
|
return FILEWATCH_TO_STRING(Event::removed);
|
|
case Event::modified:
|
|
return FILEWATCH_TO_STRING(Event::modified);
|
|
case Event::renamed_old:
|
|
return FILEWATCH_TO_STRING(Event : renamed_old);
|
|
case Event::renamed_new:
|
|
return FILEWATCH_TO_STRING(Event::renamed_new);
|
|
}
|
|
assert(false);
|
|
}
|
|
|
|
template<typename StringType>
|
|
static typename std::enable_if<std::is_same<typename StringType::value_type, wchar_t>::value, bool>::type
|
|
isParentOrSelfDirectory(const StringType& path) {
|
|
return path == L"." || path == L"..";
|
|
}
|
|
|
|
template<typename StringType>
|
|
static typename std::enable_if<std::is_same<typename StringType::value_type, char>::value, bool>::type
|
|
isParentOrSelfDirectory(const StringType& path) {
|
|
return path == "." || path == "..";
|
|
}
|
|
|
|
/**
|
|
* \class FileWatch
|
|
*
|
|
* \brief Watches a folder or file, and will notify of changes via function callback.
|
|
*
|
|
* \author Thomas Monkman
|
|
*
|
|
*/
|
|
template<class StringType>
|
|
class FileWatch
|
|
{
|
|
typedef typename StringType::value_type C;
|
|
typedef std::basic_string<C, std::char_traits<C>> UnderpinningString;
|
|
typedef std::basic_regex<C, std::regex_traits<C>> UnderpinningRegex;
|
|
|
|
public:
|
|
|
|
FileWatch(StringType path, UnderpinningRegex pattern, std::function<void(const StringType& file, const Event event_type)> callback) :
|
|
_path(absolute_path_of(path)),
|
|
_pattern(pattern),
|
|
_callback(callback),
|
|
_directory(get_directory(path))
|
|
{
|
|
init();
|
|
}
|
|
|
|
FileWatch(StringType path, std::function<void(const StringType& file, const Event event_type)> callback) :
|
|
FileWatch<StringType>(path, UnderpinningRegex(_regex_all), callback) {}
|
|
|
|
~FileWatch() {
|
|
destroy();
|
|
}
|
|
|
|
FileWatch(const FileWatch<StringType>& other) : FileWatch<StringType>(other._path, other._callback) {}
|
|
|
|
FileWatch<StringType>& operator=(const FileWatch<StringType>& other)
|
|
{
|
|
if (this == &other) { return *this; }
|
|
|
|
destroy();
|
|
_path = other._path;
|
|
_callback = other._callback;
|
|
_directory = get_directory(other._path);
|
|
init();
|
|
return *this;
|
|
}
|
|
|
|
// Const memeber varibles don't let me implent moves nicely, if moves are really wanted std::unique_ptr should be used and move that.
|
|
FileWatch<StringType>(FileWatch<StringType>&&) = delete;
|
|
FileWatch<StringType>& operator=(FileWatch<StringType>&&) & = delete;
|
|
|
|
private:
|
|
static constexpr C _regex_all[] = { '.', '*', '\0' };
|
|
static constexpr C _this_directory[] = { '.', '/', '\0' };
|
|
|
|
struct PathParts
|
|
{
|
|
PathParts(StringType directory, StringType filename) : directory(directory), filename(filename) {}
|
|
StringType directory;
|
|
StringType filename;
|
|
};
|
|
const StringType _path;
|
|
|
|
UnderpinningRegex _pattern;
|
|
|
|
static constexpr std::size_t _buffer_size = { 1024 * 256 };
|
|
|
|
// only used if watch a single file
|
|
StringType _filename;
|
|
|
|
std::function<void(const StringType& file, const Event event_type)> _callback;
|
|
|
|
std::thread _watch_thread;
|
|
|
|
std::condition_variable _cv;
|
|
std::mutex _callback_mutex;
|
|
std::vector<std::pair<StringType, Event>> _callback_information;
|
|
std::thread _callback_thread;
|
|
|
|
std::promise<void> _running;
|
|
std::atomic<bool> _destory = { false };
|
|
bool _watching_single_file = { false };
|
|
|
|
#pragma mark "Platform specific data"
|
|
#ifdef _WIN32
|
|
HANDLE _directory = { nullptr };
|
|
HANDLE _close_event = { nullptr };
|
|
|
|
const DWORD _listen_filters =
|
|
FILE_NOTIFY_CHANGE_SECURITY |
|
|
FILE_NOTIFY_CHANGE_CREATION |
|
|
FILE_NOTIFY_CHANGE_LAST_ACCESS |
|
|
FILE_NOTIFY_CHANGE_LAST_WRITE |
|
|
FILE_NOTIFY_CHANGE_SIZE |
|
|
FILE_NOTIFY_CHANGE_ATTRIBUTES |
|
|
FILE_NOTIFY_CHANGE_DIR_NAME |
|
|
FILE_NOTIFY_CHANGE_FILE_NAME;
|
|
|
|
const std::unordered_map<DWORD, Event> _event_type_mapping = {
|
|
{ FILE_ACTION_ADDED, Event::added },
|
|
{ FILE_ACTION_REMOVED, Event::removed },
|
|
{ FILE_ACTION_MODIFIED, Event::modified },
|
|
{ FILE_ACTION_RENAMED_OLD_NAME, Event::renamed_old },
|
|
{ FILE_ACTION_RENAMED_NEW_NAME, Event::renamed_new }
|
|
};
|
|
#endif // WIN32
|
|
|
|
#if __unix__
|
|
struct FolderInfo {
|
|
int folder;
|
|
int watch;
|
|
};
|
|
|
|
FolderInfo _directory;
|
|
|
|
const std::uint32_t _listen_filters = IN_MODIFY | IN_CREATE | IN_DELETE;
|
|
|
|
const static std::size_t event_size = (sizeof(struct inotify_event));
|
|
#endif // __unix__
|
|
|
|
#if FILEWATCH_PLATFORM_MAC
|
|
struct FileState
|
|
{
|
|
int fd;
|
|
uint32_t nlink;
|
|
time_t last_modification;
|
|
|
|
FileState(int fd, uint32_t nlink, time_t lt)
|
|
: fd(fd), nlink(nlink),
|
|
last_modification(lt)
|
|
{
|
|
|
|
}
|
|
FileState(const FileState&) = delete;
|
|
FileState& operator=(const FileState&) = delete;
|
|
FileState(FileState&& other) : fd(other.fd), nlink(other.nlink), last_modification(other.last_modification)
|
|
{
|
|
other.fd = -1;
|
|
}
|
|
|
|
FileState invalidate_and_clone() {
|
|
int fd = this->fd;
|
|
|
|
this->fd = -1;
|
|
return FileState{ fd, nlink, last_modification };
|
|
}
|
|
|
|
~FileState()
|
|
{
|
|
if (fd != -1) {
|
|
close(fd);
|
|
}
|
|
}
|
|
};
|
|
std::unordered_map<StringType, FileState> _directory_snapshot{};
|
|
bool _previous_event_is_rename = false;
|
|
CFRunLoopRef _run_loop = nullptr;
|
|
int _file_fd = -1;
|
|
struct timespec _last_modification_time = {};
|
|
FSEventStreamRef _directory;
|
|
// fd for single file
|
|
#endif // FILEWATCH_PLATFORM_MAC
|
|
|
|
void init()
|
|
{
|
|
#ifdef _WIN32
|
|
_close_event = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
if (!_close_event) {
|
|
throw std::system_error(GetLastError(), std::system_category());
|
|
}
|
|
#endif // WIN32
|
|
|
|
_callback_thread = std::thread([this]() {
|
|
try {
|
|
callback_thread();
|
|
}
|
|
catch (...) {
|
|
try {
|
|
_running.set_exception(std::current_exception());
|
|
}
|
|
catch (...) {} // set_exception() may throw too
|
|
}
|
|
});
|
|
|
|
_watch_thread = std::thread([this]() {
|
|
try {
|
|
monitor_directory();
|
|
}
|
|
catch (...) {
|
|
try {
|
|
_running.set_exception(std::current_exception());
|
|
}
|
|
catch (...) {} // set_exception() may throw too
|
|
}
|
|
});
|
|
|
|
std::future<void> future = _running.get_future();
|
|
future.get(); //block until the monitor_directory is up and running
|
|
}
|
|
|
|
void destroy()
|
|
{
|
|
_destory = true;
|
|
_running = std::promise<void>();
|
|
|
|
#ifdef _WIN32
|
|
SetEvent(_close_event);
|
|
#elif __unix__
|
|
inotify_rm_watch(_directory.folder, _directory.watch);
|
|
#elif FILEWATCH_PLATFORM_MAC
|
|
if (_run_loop) {
|
|
CFRunLoopStop(_run_loop);
|
|
}
|
|
#endif // __unix__
|
|
|
|
_cv.notify_all();
|
|
_watch_thread.join();
|
|
_callback_thread.join();
|
|
|
|
#ifdef _WIN32
|
|
CloseHandle(_directory);
|
|
#elif __unix__
|
|
close(_directory.folder);
|
|
#elif FILEWATCH_PLATFORM_MAC
|
|
FSEventStreamStop(_directory);
|
|
FSEventStreamInvalidate(_directory);
|
|
FSEventStreamRelease(_directory);
|
|
_directory = nullptr;
|
|
#endif // FILEWATCH_PLATFORM_MAC
|
|
}
|
|
|
|
const PathParts split_directory_and_file(const StringType& path) const
|
|
{
|
|
const auto predict = [](C character) {
|
|
#ifdef _WIN32
|
|
return character == C('\\') || character == C('/');
|
|
#elif __unix__ || FILEWATCH_PLATFORM_MAC
|
|
return character == C('/');
|
|
#endif // __unix__
|
|
};
|
|
|
|
UnderpinningString path_string = path;
|
|
const auto pivot = std::find_if(path_string.rbegin(), path_string.rend(), predict).base();
|
|
//if the path is something like "test.txt" there will be no directory part, however we still need one, so insert './'
|
|
const StringType directory = [&]() {
|
|
const auto extracted_directory = UnderpinningString(path_string.begin(), pivot);
|
|
return (extracted_directory.size() > 0) ? extracted_directory : UnderpinningString(_this_directory);
|
|
}();
|
|
const StringType filename = UnderpinningString(pivot, path_string.end());
|
|
return PathParts(directory, filename);
|
|
}
|
|
|
|
bool pass_filter(const UnderpinningString& file_path)
|
|
{
|
|
if (_watching_single_file) {
|
|
const UnderpinningString extracted_filename = { split_directory_and_file(file_path).filename };
|
|
//if we are watching a single file, only that file should trigger action
|
|
return extracted_filename == _filename;
|
|
}
|
|
return std::regex_match(file_path, _pattern);
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
template<typename... Args> DWORD GetFileAttributesX(const char* lpFileName, Args... args) {
|
|
return GetFileAttributesA(lpFileName, args...);
|
|
}
|
|
template<typename... Args> DWORD GetFileAttributesX(const wchar_t* lpFileName, Args... args) {
|
|
return GetFileAttributesW(lpFileName, args...);
|
|
}
|
|
|
|
template<typename... Args> HANDLE CreateFileX(const char* lpFileName, Args... args) {
|
|
return CreateFileA(lpFileName, args...);
|
|
}
|
|
template<typename... Args> HANDLE CreateFileX(const wchar_t* lpFileName, Args... args) {
|
|
return CreateFileW(lpFileName, args...);
|
|
}
|
|
|
|
HANDLE get_directory(const StringType& path)
|
|
{
|
|
auto file_info = GetFileAttributesX(path.c_str());
|
|
|
|
if (file_info == INVALID_FILE_ATTRIBUTES)
|
|
{
|
|
throw std::system_error(GetLastError(), std::system_category());
|
|
}
|
|
_watching_single_file = (file_info & FILE_ATTRIBUTE_DIRECTORY) == false;
|
|
|
|
const StringType watch_path = [this, &path]() {
|
|
if (_watching_single_file)
|
|
{
|
|
const auto parsed_path = split_directory_and_file(path);
|
|
_filename = parsed_path.filename;
|
|
return parsed_path.directory;
|
|
}
|
|
else
|
|
{
|
|
return path;
|
|
}
|
|
}();
|
|
|
|
HANDLE directory = CreateFileX(
|
|
watch_path.c_str(), // pointer to the file name
|
|
FILE_LIST_DIRECTORY, // access (read/write) mode
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, // share mode
|
|
nullptr, // security descriptor
|
|
OPEN_EXISTING, // how to create
|
|
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, // file attributes
|
|
HANDLE(0)); // file with attributes to copy
|
|
|
|
if (directory == INVALID_HANDLE_VALUE)
|
|
{
|
|
throw std::system_error(GetLastError(), std::system_category());
|
|
}
|
|
return directory;
|
|
}
|
|
|
|
void convert_wstring(const std::wstring& wstr, std::string& out)
|
|
{
|
|
int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
|
|
out.resize(size_needed, '\0');
|
|
WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &out[0], size_needed, NULL, NULL);
|
|
}
|
|
|
|
void convert_wstring(const std::wstring& wstr, std::wstring& out)
|
|
{
|
|
out = wstr;
|
|
}
|
|
|
|
void monitor_directory()
|
|
{
|
|
std::vector<BYTE> buffer(_buffer_size);
|
|
DWORD bytes_returned = 0;
|
|
OVERLAPPED overlapped_buffer{ 0 };
|
|
|
|
overlapped_buffer.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
if (!overlapped_buffer.hEvent) {
|
|
std::cerr << "Error creating monitor event" << std::endl;
|
|
}
|
|
|
|
std::array<HANDLE, 2> handles{ overlapped_buffer.hEvent, _close_event };
|
|
|
|
auto async_pending = false;
|
|
_running.set_value();
|
|
do {
|
|
std::vector<std::pair<StringType, Event>> parsed_information;
|
|
ReadDirectoryChangesW(
|
|
_directory,
|
|
buffer.data(), static_cast<DWORD>(buffer.size()),
|
|
TRUE,
|
|
_listen_filters,
|
|
&bytes_returned,
|
|
&overlapped_buffer, NULL);
|
|
|
|
async_pending = true;
|
|
|
|
switch (WaitForMultipleObjects(2, handles.data(), FALSE, INFINITE))
|
|
{
|
|
case WAIT_OBJECT_0:
|
|
{
|
|
if (!GetOverlappedResult(_directory, &overlapped_buffer, &bytes_returned, TRUE)) {
|
|
throw std::system_error(GetLastError(), std::system_category());
|
|
}
|
|
async_pending = false;
|
|
|
|
if (bytes_returned == 0) {
|
|
break;
|
|
}
|
|
|
|
FILE_NOTIFY_INFORMATION *file_information = reinterpret_cast<FILE_NOTIFY_INFORMATION*>(&buffer[0]);
|
|
do
|
|
{
|
|
std::wstring changed_file_w{ file_information->FileName, file_information->FileNameLength / sizeof(file_information->FileName[0]) };
|
|
UnderpinningString changed_file;
|
|
convert_wstring(changed_file_w, changed_file);
|
|
if (pass_filter(changed_file))
|
|
{
|
|
parsed_information.emplace_back(StringType{ changed_file }, _event_type_mapping.at(file_information->Action));
|
|
}
|
|
|
|
if (file_information->NextEntryOffset == 0) {
|
|
break;
|
|
}
|
|
|
|
file_information = reinterpret_cast<FILE_NOTIFY_INFORMATION*>(reinterpret_cast<BYTE*>(file_information) + file_information->NextEntryOffset);
|
|
} while (true);
|
|
break;
|
|
}
|
|
case WAIT_OBJECT_0 + 1:
|
|
// quit
|
|
break;
|
|
case WAIT_FAILED:
|
|
break;
|
|
}
|
|
//dispatch callbacks
|
|
{
|
|
std::lock_guard<std::mutex> lock(_callback_mutex);
|
|
_callback_information.insert(_callback_information.end(), parsed_information.begin(), parsed_information.end());
|
|
}
|
|
_cv.notify_all();
|
|
} while (_destory == false);
|
|
|
|
if (async_pending)
|
|
{
|
|
//clean up running async io
|
|
CancelIo(_directory);
|
|
GetOverlappedResult(_directory, &overlapped_buffer, &bytes_returned, TRUE);
|
|
}
|
|
}
|
|
#endif // WIN32
|
|
|
|
#if __unix__
|
|
|
|
bool is_file(const StringType& path) const
|
|
{
|
|
struct stat statbuf = {};
|
|
if (stat(path.c_str(), &statbuf) != 0)
|
|
{
|
|
throw std::system_error(errno, std::system_category());
|
|
}
|
|
return S_ISREG(statbuf.st_mode);
|
|
}
|
|
|
|
FolderInfo get_directory(const StringType& path)
|
|
{
|
|
const auto folder = inotify_init();
|
|
if (folder < 0)
|
|
{
|
|
throw std::system_error(errno, std::system_category());
|
|
}
|
|
|
|
_watching_single_file = is_file(path);
|
|
|
|
const StringType watch_path = [this, &path]() {
|
|
if (_watching_single_file)
|
|
{
|
|
const auto parsed_path = split_directory_and_file(path);
|
|
_filename = parsed_path.filename;
|
|
return parsed_path.directory;
|
|
}
|
|
else
|
|
{
|
|
return path;
|
|
}
|
|
}();
|
|
|
|
const auto watch = inotify_add_watch(folder, watch_path.c_str(), IN_MODIFY | IN_CREATE | IN_DELETE);
|
|
if (watch < 0)
|
|
{
|
|
throw std::system_error(errno, std::system_category());
|
|
}
|
|
return { folder, watch };
|
|
}
|
|
|
|
void monitor_directory()
|
|
{
|
|
std::vector<char> buffer(_buffer_size);
|
|
|
|
_running.set_value();
|
|
while (_destory == false)
|
|
{
|
|
const auto length = read(_directory.folder, static_cast<void*>(buffer.data()), buffer.size());
|
|
if (length > 0)
|
|
{
|
|
int i = 0;
|
|
std::vector<std::pair<StringType, Event>> parsed_information;
|
|
while (i < length)
|
|
{
|
|
struct inotify_event *event = reinterpret_cast<struct inotify_event *>(&buffer[i]); // NOLINT
|
|
if (event->len)
|
|
{
|
|
const UnderpinningString changed_file{ event->name };
|
|
if (pass_filter(changed_file))
|
|
{
|
|
if (event->mask & IN_CREATE)
|
|
{
|
|
parsed_information.emplace_back(StringType{ changed_file }, Event::added);
|
|
}
|
|
else if (event->mask & IN_DELETE)
|
|
{
|
|
parsed_information.emplace_back(StringType{ changed_file }, Event::removed);
|
|
}
|
|
else if (event->mask & IN_MODIFY)
|
|
{
|
|
parsed_information.emplace_back(StringType{ changed_file }, Event::modified);
|
|
}
|
|
}
|
|
}
|
|
i += event_size + event->len;
|
|
}
|
|
//dispatch callbacks
|
|
{
|
|
std::lock_guard<std::mutex> lock(_callback_mutex);
|
|
_callback_information.insert(_callback_information.end(), parsed_information.begin(), parsed_information.end());
|
|
}
|
|
_cv.notify_all();
|
|
}
|
|
}
|
|
}
|
|
#endif // __unix__
|
|
|
|
#if FILEWATCH_PLATFORM_MAC
|
|
static StringType absolute_path_of(const StringType& path) {
|
|
char buf[PATH_MAX];
|
|
int fd = open((const char*)path.c_str(), O_RDONLY);
|
|
const char* str = buf;
|
|
struct stat stat;
|
|
mbstate_t state;
|
|
|
|
assert(fd != -1);
|
|
fcntl(fd, F_GETPATH, buf);
|
|
fstat(fd, &stat);
|
|
|
|
if (stat.st_mode & S_IFREG || stat.st_mode & S_IFLNK) {
|
|
size_t len = strlen(buf);
|
|
|
|
for (size_t i = len - 1; i >= 0; i--) {
|
|
if (buf[i] == '/') {
|
|
buf[i] = '\0';
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
close(fd);
|
|
|
|
if (IsWChar<C>::value) {
|
|
size_t needed = mbsrtowcs(nullptr, &str, 0, &state) + 1;
|
|
StringType s;
|
|
|
|
s.reserve(needed);
|
|
mbsrtowcs((wchar_t*)&s[0], &str, s.size(), &state);
|
|
return s;
|
|
}
|
|
return StringType{ buf };
|
|
}
|
|
#elif defined(__unix__)
|
|
static StringType absolute_path_of(const StringType& path) {
|
|
char buf[PATH_MAX];
|
|
const char* str = buf;
|
|
struct stat stat;
|
|
mbstate_t state;
|
|
|
|
realpath((const char*)path.c_str(), buf);
|
|
::stat((const char*)path.c_str(), &stat);
|
|
|
|
if (stat.st_mode & S_IFREG || stat.st_mode & S_IFLNK) {
|
|
size_t len = strlen(buf);
|
|
|
|
for (size_t i = len - 1; i >= 0; i--) {
|
|
if (buf[i] == '/') {
|
|
buf[i] = '\0';
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IsWChar<C>::value) {
|
|
size_t needed = mbsrtowcs(nullptr, &str, 0, &state) + 1;
|
|
StringType s;
|
|
|
|
s.reserve(needed);
|
|
mbsrtowcs((wchar_t*)&s[0], &str, s.size(), &state);
|
|
return s;
|
|
}
|
|
return StringType{ buf };
|
|
}
|
|
#elif _WIN32
|
|
static StringType absolute_path_of(const StringType& path) {
|
|
constexpr size_t size = IsWChar<C>::value ? MAX_PATH : 32767 * sizeof(wchar_t);
|
|
char buf[size];
|
|
|
|
DWORD length = IsWChar<C>::value ?
|
|
GetFullPathNameW((LPCWSTR)path.c_str(),
|
|
size / sizeof(TCHAR),
|
|
(LPWSTR)buf,
|
|
nullptr) :
|
|
GetFullPathNameA((LPCSTR)path.c_str(),
|
|
size / sizeof(TCHAR),
|
|
buf,
|
|
nullptr);
|
|
return StringType{ (C*)buf, length };
|
|
}
|
|
#endif
|
|
|
|
#if FILEWATCH_PLATFORM_MAC
|
|
static StringType utf8StringToUtf32String(const char* buffer) {
|
|
mbstate_t state{};
|
|
StringType s{};
|
|
|
|
size_t needed = mbsrtowcs(nullptr, &buffer, 0, &state) + 1;
|
|
s.reserve(needed);
|
|
mbsrtowcs((wchar_t*)&s[0], &buffer, s.size(), &state);
|
|
return s;
|
|
}
|
|
|
|
template<typename Fn, class = std::enable_if<Invokable<Fn, StringType>::value>>
|
|
static void walkDirectory(const StringType& path, Fn callback) {
|
|
int fd = open(path.c_str(), O_RDONLY);
|
|
char buf[1024];
|
|
long basep = 0;
|
|
|
|
if (fd == -1) {
|
|
return;
|
|
}
|
|
|
|
int ret = __getdirentries64(fd, buf, sizeof(buf), &basep);
|
|
|
|
while (ret > 0) {
|
|
char* current = buf;
|
|
int offset = 0;
|
|
|
|
while (offset < ret) {
|
|
struct dirent* dirent = (struct dirent*)current;
|
|
StringType name = IsWChar<C>::value ?
|
|
utf8StringToUtf32String(dirent->d_name)
|
|
: StringType(dirent->d_name);
|
|
|
|
callback(std::move(name));
|
|
current += dirent->d_reclen;
|
|
offset += dirent->d_reclen;
|
|
}
|
|
ret = __getdirentries64(fd, buf, sizeof(buf), &basep);
|
|
}
|
|
close(fd);
|
|
}
|
|
|
|
static StringType nameofFd(int fd) {
|
|
size_t len = 0;
|
|
char buf[MAXPATHLEN];
|
|
|
|
if (fcntl(fd, F_GETPATH, buf) == -1) {
|
|
return StringType{};
|
|
}
|
|
if (IsWChar<C>::value) {
|
|
return utf8StringToUtf32String(buf);
|
|
}
|
|
|
|
len = strnlen(buf, MAXPATHLEN);
|
|
for (int i = len - 1; i >= 0; i--) {
|
|
if (buf[i] == '/') {
|
|
return StringType{ buf + i + 1, len - i - 1 };
|
|
}
|
|
}
|
|
return StringType{ buf, len };
|
|
}
|
|
|
|
static StringType fullPathOfFd(int fd) {
|
|
char buf[MAXPATHLEN];
|
|
|
|
if (fcntl(fd, F_GETPATH, buf) == -1) {
|
|
return StringType{};
|
|
}
|
|
if (IsWChar<C>::value) {
|
|
return utf8StringToUtf32String(buf);
|
|
}
|
|
return StringType{ (C*)buf };
|
|
}
|
|
|
|
static StringType pathOfFd(int fd) {
|
|
size_t len = 0;
|
|
char buf[MAXPATHLEN];
|
|
|
|
if (fcntl(fd, F_GETPATH, buf) == -1) {
|
|
return StringType{};
|
|
}
|
|
if (IsWChar<C>::value) {
|
|
return utf8StringToUtf32String(buf);
|
|
}
|
|
|
|
len = strnlen(buf, MAXPATHLEN);
|
|
for (int i = len - 1; i >= 0; i--) {
|
|
if (buf[i] == '/') {
|
|
return StringType{ buf, static_cast<size_t>(i) };
|
|
}
|
|
}
|
|
return StringType{ buf, len };
|
|
}
|
|
|
|
static bool fdIsRemoved(int fd) {
|
|
char buf[MAXPATHLEN];
|
|
return fcntl(fd, F_GETPATH, buf) == -1;
|
|
}
|
|
|
|
FileState makeFileState(const StringType& path) {
|
|
int fd = openFile(path);
|
|
struct stat stat;
|
|
|
|
fstat(fd, &stat);
|
|
|
|
return FileState{
|
|
openFile(path),
|
|
stat.st_nlink,
|
|
stat.st_mtimespec.tv_sec
|
|
};
|
|
}
|
|
|
|
static StringType filenameOf(const StringType& file) {
|
|
for (int i = file.size() - 1; i >= 0; i--) {
|
|
if (file[i] == '/') {
|
|
return file.substr(i + 1);
|
|
}
|
|
}
|
|
return file;
|
|
}
|
|
|
|
static bool isInDirectory(const StringType& file, const StringType& path) {
|
|
if (file.size() < path.size()) {
|
|
return false;
|
|
}
|
|
return strncmp(file.data(), path.data(), path.size()) == 0;
|
|
}
|
|
|
|
PathParts splitPath(const StringType& path) {
|
|
PathParts split = split_directory_and_file(path);
|
|
|
|
if (split.directory.size() > 0 && split.directory[split.directory.size() - 1] == '/') {
|
|
split.directory.erase(split.directory.size() - 1);
|
|
}
|
|
return split;
|
|
}
|
|
|
|
StringType fullPathOf(const StringType& file) {
|
|
return _path + '/' + file;
|
|
}
|
|
|
|
int openFile(const StringType& file) {
|
|
int fd = open(fullPathOf(file).c_str(), O_RDONLY);
|
|
assert(fd != -1);
|
|
return fd;
|
|
}
|
|
|
|
void walkAndSeeChanges() {
|
|
struct RenamedPair {
|
|
StringType old;
|
|
StringType current;
|
|
};
|
|
struct EventInfo {
|
|
StringType file;
|
|
struct timespec time;
|
|
Event event;
|
|
};
|
|
std::unordered_map<StringType, FileState> newSnapshot{};
|
|
std::vector<EventInfo> events{};
|
|
|
|
for (auto& entry : _directory_snapshot) {
|
|
struct stat stat;
|
|
|
|
fstat(entry.second.fd, &stat);
|
|
if (fdIsRemoved(entry.second.fd)) {
|
|
events.push_back(EventInfo{
|
|
.event = Event::removed,
|
|
.file = entry.first,
|
|
.time = stat.st_ctimespec
|
|
});
|
|
continue;
|
|
}
|
|
|
|
StringType fullPath = fullPathOfFd(entry.second.fd);
|
|
PathParts pathPair = splitPath(fullPath);
|
|
|
|
if (pathPair.directory != _path) {
|
|
events.push_back(EventInfo{
|
|
.event = Event::removed,
|
|
.file = entry.first,
|
|
.time = stat.st_ctimespec
|
|
});
|
|
continue;
|
|
}
|
|
if (entry.first != pathPair.filename) {
|
|
events.push_back(EventInfo{
|
|
.event = Event::renamed_old,
|
|
.file = entry.first,
|
|
.time = stat.st_ctimespec
|
|
});
|
|
events.push_back(EventInfo{
|
|
.event = Event::renamed_new,
|
|
.file = pathPair.filename,
|
|
.time = stat.st_ctimespec
|
|
});
|
|
}
|
|
else {
|
|
if (stat.st_mtimespec.tv_sec > entry.second.last_modification) {
|
|
entry.second.last_modification = stat.st_mtimespec.tv_sec;
|
|
events.push_back(EventInfo{
|
|
.event = Event::modified,
|
|
.file = pathPair.filename,
|
|
.time = stat.st_mtimespec
|
|
});
|
|
}
|
|
}
|
|
newSnapshot.insert(std::make_pair(std::move(pathPair.filename),
|
|
std::move(entry.second.invalidate_and_clone())));
|
|
}
|
|
|
|
walkDirectory(_path, [&](StringType file) {
|
|
if (isParentOrSelfDirectory(file) || !std::regex_match(file, _pattern)) {
|
|
return;
|
|
}
|
|
if (newSnapshot.count(file) == 0) {
|
|
FileState state = makeFileState(file);
|
|
struct stat stat;
|
|
|
|
fstat(state.fd, &stat);
|
|
events.push_back(EventInfo{
|
|
.event = Event::added,
|
|
.file = file,
|
|
.time = stat.st_mtimespec
|
|
});
|
|
newSnapshot.insert(std::make_pair(file, std::move(state)));
|
|
}
|
|
});
|
|
|
|
std::swap(_directory_snapshot, newSnapshot);
|
|
|
|
std::sort(events.begin(), events.end(), [](const EventInfo& a, EventInfo& b) {
|
|
if (a.time.tv_sec == b.time.tv_sec) {
|
|
return a.time.tv_nsec < b.time.tv_nsec;
|
|
}
|
|
return a.time.tv_sec < b.time.tv_sec;
|
|
});
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(_callback_mutex);
|
|
|
|
for (const auto& event : events) {
|
|
_callback_information.push_back(std::make_pair(event.file, event.event));
|
|
}
|
|
}
|
|
_cv.notify_all();
|
|
}
|
|
|
|
void seeSingleFileChanges() {
|
|
struct EventInfo {
|
|
StringType file;
|
|
Event event;
|
|
};
|
|
|
|
int eventCount = 1;
|
|
EventInfo eventInfos[2];
|
|
|
|
if (fdIsRemoved(_file_fd)) {
|
|
eventInfos[0].event = Event::removed;
|
|
eventInfos[0].file = _filename;
|
|
}
|
|
else {
|
|
StringType absPath = pathOfFd(_file_fd);
|
|
PathParts split = splitPath(absPath);
|
|
|
|
if (split.directory != _path) {
|
|
eventInfos[0].event = Event::removed;
|
|
eventInfos[0].file = _filename;
|
|
}
|
|
else if (split.filename != _filename) {
|
|
eventInfos[0].event = Event::renamed_old;
|
|
eventInfos[0].file = std::move(_filename);
|
|
eventInfos[1].event = Event::renamed_new;
|
|
eventInfos[1].file = split.filename;
|
|
eventCount = 2;
|
|
_filename = std::move(split.filename);
|
|
}
|
|
else {
|
|
struct stat stat;
|
|
|
|
fstat(_file_fd, &stat);
|
|
|
|
if (stat.st_mtimespec.tv_sec > _last_modification_time.tv_sec) {
|
|
eventInfos[0].event = Event::modified;
|
|
eventInfos[0].file = _filename;
|
|
_last_modification_time = stat.st_mtimespec;
|
|
}
|
|
else if (stat.st_mtimespec.tv_nsec > _last_modification_time.tv_nsec) {
|
|
eventInfos[0].event = Event::modified;
|
|
eventInfos[0].file = _filename;
|
|
_last_modification_time = stat.st_mtimespec;
|
|
}
|
|
else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(_callback_mutex);
|
|
for (int i = 0; i < eventCount; i++) {
|
|
_callback_information.push_back(
|
|
std::make_pair(eventInfos[i].file, eventInfos[i].event));
|
|
}
|
|
}
|
|
_cv.notify_all();
|
|
}
|
|
|
|
void notify(CFStringRef path, const FSEventStreamEventFlags flags) {
|
|
CFIndex pathLength = CFStringGetLength(path);
|
|
CFIndex written = 0;
|
|
char buffer[PATH_MAX + 1];
|
|
|
|
CFStringGetBytes(path,
|
|
CFRange{
|
|
.location = 0,
|
|
.length = pathLength,
|
|
},
|
|
IsWChar<C>::value ? kCFStringEncodingUTF32 : kCFStringEncodingUTF8,
|
|
0,
|
|
false,
|
|
(UInt8*)buffer,
|
|
PATH_MAX,
|
|
&written);
|
|
|
|
buffer[written] = 0;
|
|
|
|
StringType absolutePath{ (const C*)buffer, static_cast<size_t>(pathLength) };
|
|
PathParts pathPair = splitPath(absolutePath);
|
|
|
|
if (_watching_single_file && pathPair.filename != _filename) {
|
|
return;
|
|
}
|
|
if (pathPair.directory != _path || !std::regex_match(pathPair.filename, _pattern)) {
|
|
return;
|
|
}
|
|
|
|
Event event = Event::modified;
|
|
if (_previous_event_is_rename) {
|
|
event = Event::renamed_new;
|
|
_directory_snapshot.insert(std::make_pair(pathPair.filename,
|
|
std::move(makeFileState(pathPair.filename))));
|
|
_previous_event_is_rename = false;
|
|
}
|
|
else if (flags & kFSEventStreamEventFlagItemRenamed) {
|
|
const auto state = _directory_snapshot.find(pathPair.filename);
|
|
assert(state != _directory_snapshot.end());
|
|
StringType fdPath = pathOfFd(state->second.fd);
|
|
|
|
// moved/delete to Trash folder
|
|
if (!isInDirectory(absolutePath, fdPath)) {
|
|
event = Event::removed;
|
|
_directory_snapshot.erase(pathPair.filename);
|
|
}
|
|
else {
|
|
event = Event::renamed_old;
|
|
_previous_event_is_rename = true;
|
|
}
|
|
}
|
|
else if (flags & kFSEventStreamEventFlagItemCreated) {
|
|
_directory_snapshot.insert(std::make_pair(pathPair.filename,
|
|
std::move(makeFileState(pathPair.filename))));
|
|
event = Event::added;
|
|
}
|
|
else if (flags & kFSEventStreamEventFlagItemRemoved) {
|
|
_directory_snapshot.erase(pathPair.filename);
|
|
event = Event::removed;
|
|
}
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(_callback_mutex);
|
|
_callback_information.push_back(std::make_pair(std::move(pathPair.filename), event));
|
|
}
|
|
_cv.notify_all();
|
|
}
|
|
|
|
static void handleFsEvent(__attribute__((unused)) ConstFSEventStreamRef streamFef,
|
|
void* clientCallBackInfo,
|
|
size_t numEvents,
|
|
CFArrayRef eventPaths,
|
|
const FSEventStreamEventFlags* eventFlags,
|
|
__attribute__((unused)) const FSEventStreamEventId* eventIds) {
|
|
FileWatch<StringType>* self = (FileWatch<StringType>*)clientCallBackInfo;
|
|
|
|
for (size_t i = 0; i < numEvents; i++) {
|
|
FSEventStreamEventFlags flag = eventFlags[i];
|
|
CFStringRef path = (CFStringRef)CFArrayGetValueAtIndex(eventPaths, i);
|
|
|
|
if (self->_watching_single_file) {
|
|
self->seeSingleFileChanges();
|
|
}
|
|
else if (flag & kFSEventStreamEventFlagMustScanSubDirs) {
|
|
self->walkAndSeeChanges();
|
|
}
|
|
else {
|
|
self->notify(path, flag);
|
|
}
|
|
}
|
|
}
|
|
|
|
FSEventStreamRef openStream(const StringType& directory) {
|
|
CFStringEncoding encoding = IsWChar<C>::value ?
|
|
kCFStringEncodingUTF32 : kCFStringEncodingASCII;
|
|
CFStringRef path = CFStringCreateWithBytes(kCFAllocatorDefault,
|
|
(const UInt8*)directory.data(),
|
|
directory.size(),
|
|
encoding,
|
|
false);
|
|
CFArrayRef paths = CFArrayCreate(
|
|
kCFAllocatorDefault,
|
|
(const void**)&path,
|
|
1,
|
|
nullptr);
|
|
FSEventStreamContext context{
|
|
.info = (void*)this
|
|
};
|
|
FSEventStreamRef event = FSEventStreamCreate(
|
|
kCFAllocatorDefault,
|
|
(FSEventStreamCallback)handleFsEvent,
|
|
&context,
|
|
paths,
|
|
kFSEventStreamEventIdSinceNow,
|
|
0,
|
|
kFSEventStreamCreateFlagNoDefer | kFSEventStreamCreateFlagFileEvents |
|
|
kFSEventStreamCreateFlagUseCFTypes);
|
|
|
|
CFRelease(path);
|
|
CFRelease(paths);
|
|
return event;
|
|
}
|
|
|
|
FSEventStreamRef openStreamForDirectory(const StringType& directory) {
|
|
FSEventStreamRef stream = openStream(directory);
|
|
walkDirectory(directory, [this](StringType path) mutable {
|
|
if (!isParentOrSelfDirectory(path) && std::regex_match(path, _pattern)) {
|
|
_directory_snapshot.insert(std::make_pair(std::move(path),
|
|
std::move(makeFileState(path))));
|
|
}
|
|
});
|
|
return stream;
|
|
}
|
|
|
|
FSEventStreamRef openStreamForFile(const StringType& file) {
|
|
PathParts split = splitPath(file);
|
|
|
|
_watching_single_file = true;
|
|
_filename = std::move(split.filename);
|
|
_file_fd = openFile(file);
|
|
return openStreamForDirectory(split.directory);
|
|
}
|
|
|
|
FSEventStreamRef get_directory(const StringType& directory) {
|
|
struct stat stat;
|
|
|
|
::stat((const char*)directory.c_str(), &stat);
|
|
if (stat.st_mode & S_IFDIR) {
|
|
return openStreamForDirectory(directory);
|
|
}
|
|
_last_modification_time = stat.st_mtimespec;
|
|
return openStreamForFile(directory);
|
|
}
|
|
|
|
void monitor_directory() {
|
|
_run_loop = CFRunLoopGetCurrent();
|
|
FSEventStreamScheduleWithRunLoop(_directory,
|
|
_run_loop,
|
|
kCFRunLoopDefaultMode);
|
|
FSEventStreamStart(_directory);
|
|
_running.set_value();
|
|
CFRunLoopRun();
|
|
}
|
|
#endif // FILEWATCH_PLATFORM_MAC
|
|
|
|
void callback_thread()
|
|
{
|
|
while (_destory == false) {
|
|
std::unique_lock<std::mutex> lock(_callback_mutex);
|
|
if (_callback_information.empty() && _destory == false) {
|
|
_cv.wait(lock, [this] { return _callback_information.size() > 0 || _destory; });
|
|
}
|
|
decltype(_callback_information) callback_information = {};
|
|
std::swap(callback_information, _callback_information);
|
|
lock.unlock();
|
|
|
|
for (const auto& file : callback_information) {
|
|
if (_callback) {
|
|
try
|
|
{
|
|
_callback(file.first, file.second);
|
|
}
|
|
catch (const std::exception&)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
template<class StringType> constexpr typename FileWatch<StringType>::C FileWatch<StringType>::_regex_all[];
|
|
template<class StringType> constexpr typename FileWatch<StringType>::C FileWatch<StringType>::_this_directory[];
|
|
}
|
|
#endif |