FileSystemWatcher.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Foundation/Compiler.h"
#ifndef SC_EXPORT_LIBRARY_FILE_SYSTEM_WATCHER
#define SC_EXPORT_LIBRARY_FILE_SYSTEM_WATCHER 0
#endif
#define SC_FILE_SYSTEM_WATCHER_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_FILE_SYSTEM_WATCHER)
 
#include "../Foundation/Function.h"
#include "../Foundation/OpaqueObject.h"
#include "../Foundation/Result.h"
#include "../Foundation/StringPath.h"
 
namespace SC
{
 
 
 
 
struct FileSystemWatcher
{
  private:
    struct Internal;
 
    struct InternalDefinition
    {
        static constexpr int Windows = 3 * sizeof(void*);
        static constexpr int Apple   = 42 * sizeof(void*);
        static constexpr int Linux   = sizeof(void*) * 4;
        static constexpr int Default = Linux;
 
        static constexpr size_t Alignment = alignof(void*);
 
        using Object = Internal;
    };
 
  public:
    // Must be public to avoid GCC complaining
    using InternalOpaque = OpaqueObject<InternalDefinition>;
 
  private:
    InternalOpaque internal;
 
    //...
    struct ThreadRunnerInternal;
    struct ThreadRunnerDefinition
    {
        static constexpr int MaxWatchablePaths = 1024;
 
        static constexpr int Windows = (2 * MaxWatchablePaths + 2) * sizeof(void*) + sizeof(uint64_t);
        static constexpr int Apple   = sizeof(void*);
        static constexpr int Linux   = sizeof(void*) * 6;
        static constexpr int Default = Linux;
 
        static constexpr size_t Alignment = alignof(void*);
 
        using Object = ThreadRunnerInternal;
    };
 
    struct FolderWatcherInternal;
    struct FolderWatcherSizes
    {
        static constexpr int MaxNumberOfSubdirs   = 128; // Max number of subfolders tracked in a watcher
        static constexpr int MaxChangesBufferSize = 1024;
 
        static constexpr int Windows = MaxChangesBufferSize + sizeof(void*) + sizeof(void*);
        static constexpr int Apple   = sizeof(void*);
        static constexpr int Linux   = 1056 + 4096 + 8;
        static constexpr int Default = Linux;
 
        static constexpr size_t Alignment = alignof(void*);
 
        using Object = FolderWatcherInternal;
    };
 
  public:
    enum class Operation
    {
        Modified,        
        AddRemoveRename, 
    };
 
    struct Notification
    {
        StringSpan basePath;                        
        StringSpan relativePath;                    
        Operation  operation = Operation::Modified; 
 
        SC::Result getFullPath(StringPath& path) const;
 
      private:
        friend struct Internal;
#if SC_PLATFORM_APPLE
        StringSpan fullPath;
#endif
    };
 
    struct FolderWatcher
    {
        FolderWatcher(Span<char> subFolderRelativePathsBuffer = {});
 
        Function<void(const Notification&)> notifyCallback; 
 
        Result stopWatching();
 
        void setDebugName(const char* debugName);
 
      private:
        friend struct FileSystemWatcher;
        template <typename T_AsyncEventLoop>
        friend struct FileSystemWatcherAsyncT;
#if SC_PLATFORM_WINDOWS
#if SC_ASYNC_ENABLE_LOG
        AlignedStorage<120> asyncStorage;
#else
        AlignedStorage<112> asyncStorage;
#endif
#endif
        OpaqueObject<FolderWatcherSizes> internal;
 
        FileSystemWatcher* parent = nullptr;
        FolderWatcher*     next   = nullptr;
        FolderWatcher*     prev   = nullptr;
 
        StringPath path;
 
#if SC_PLATFORM_LINUX
        Span<char> subFolderRelativePathsBuffer;
#endif
    };
 
    struct EventLoopRunner
    {
        virtual ~EventLoopRunner() {}
 
      protected:
#if SC_PLATFORM_APPLE
        virtual Result appleStartWakeUp()       = 0;
        virtual void   appleSignalEventObject() = 0;
        virtual Result appleWakeUpAndWait()     = 0;
 
#elif SC_PLATFORM_LINUX
        virtual Result linuxStartSharedFilePoll() = 0;
        virtual Result linuxStopSharedFilePoll()  = 0;
 
        int notifyFd = -1;
 
#else
        virtual Result windowsStartFolderFilePoll(FolderWatcher& watcher, void* handle) = 0;
        virtual Result windowsStopFolderFilePoll(FolderWatcher& watcher)                = 0;
        virtual void*  windowsGetOverlapped(FolderWatcher& watcher)                     = 0;
#endif
        friend struct Internal;
        FileSystemWatcher* fileSystemWatcher = nullptr;
 
        void internalInit(FileSystemWatcher& fsWatcher, int handle);
    };
 
    using ThreadRunner = OpaqueObject<ThreadRunnerDefinition>;
 
    Result init(ThreadRunner& runner);
 
    Result init(EventLoopRunner& runner);
 
    Result close();
 
    Result watch(FolderWatcher& watcher, StringSpan path);
 
    void asyncNotify(FolderWatcher* watcher);
 
  private:
    friend decltype(internal);
    friend decltype(FolderWatcher::internal);
    template <typename T_AsyncEventLoop>
    friend struct FileSystemWatcherAsyncT;
    // Trimmed duplicate of IntrusiveDoubleLinkedList<T>
    struct WatcherLinkedList
    {
        FolderWatcher* back  = nullptr; // has no next
        FolderWatcher* front = nullptr; // has no prev
 
        void queueBack(FolderWatcher& watcher);
        void remove(FolderWatcher& watcher);
    };
    WatcherLinkedList watchers;
};
 
template <typename T_AsyncEventLoop>
struct FileSystemWatcherAsyncT : public FileSystemWatcher::EventLoopRunner
{
    using Self = FileSystemWatcherAsyncT;
 
    using T_AsyncLoopWakeUp = typename T_AsyncEventLoop::LoopWakeUp;
    using T_AsyncFilePoll   = typename T_AsyncEventLoop::FilePoll;
    using T_EventObject     = typename T_AsyncEventLoop::EventObjectType;
    using T_AsyncResult     = typename T_AsyncEventLoop::ResultType;
 
    void init(T_AsyncEventLoop& loop) { eventLoop = &loop; }
 
  protected:
    T_AsyncEventLoop* eventLoop = nullptr;
 
#if SC_PLATFORM_APPLE
    virtual Result appleStartWakeUp() override
    {
        SC_TRY_MSG(eventLoop != nullptr and fileSystemWatcher != nullptr, "FileSystemWatcherAsync not initialized");
        T_AsyncLoopWakeUp& wakeUp = asyncWakeUp;
        wakeUp.callback.template bind<Self, &Self::onEventLoopNotification>(*this);
        return wakeUp.start(*eventLoop, eventObject);
    }
 
    virtual void appleSignalEventObject() override { eventObject.signal(); }
 
    virtual Result appleWakeUpAndWait() override
    {
        const Result res = asyncWakeUp.wakeUp(*eventLoop);
        eventObject.wait();
        return res;
    }
 
    void onEventLoopNotification(typename T_AsyncLoopWakeUp::Result& result)
    {
        fileSystemWatcher->asyncNotify(nullptr);
        result.reactivateRequest(true);
    }
 
    T_AsyncLoopWakeUp asyncWakeUp = {};
    T_EventObject     eventObject = {};
#elif SC_PLATFORM_LINUX
    virtual Result linuxStartSharedFilePoll() override
    {
        SC_TRY_MSG(eventLoop != nullptr and fileSystemWatcher != nullptr, "FileSystemWatcherAsync not initialized");
        SC_TRY(eventLoop->associateExternallyCreatedFileDescriptorHandle(notifyFd));
        asyncPoll.callback.template bind<Self, &Self::onEventLoopNotification>(*this);
        return asyncPoll.start(*eventLoop, notifyFd);
    }
 
    virtual Result linuxStopSharedFilePoll() override { return asyncPoll.stop(*eventLoop); }
 
    void onEventLoopNotification(typename T_AsyncFilePoll::Result& result)
    {
        fileSystemWatcher->asyncNotify(nullptr);
        result.reactivateRequest(true);
    }
 
    T_AsyncFilePoll asyncPoll = {};
#else
    using FolderWatcher = FileSystemWatcher::FolderWatcher;
    virtual Result windowsStartFolderFilePoll(FolderWatcher& watcher, void* handle) override
    {
        SC_TRY_MSG(eventLoop != nullptr and fileSystemWatcher != nullptr, "FileSystemWatcherAsync not initialized");
        SC_TRY(eventLoop->associateExternallyCreatedFileDescriptorHandle(handle));
        T_AsyncFilePoll& asyncPoll = watcher.asyncStorage.template reinterpret_as<T_AsyncFilePoll>();
        placementNew(asyncPoll);
        asyncPoll.setDebugName("FileSystemWatcherAsync Poll");
        asyncPoll.callback.template bind<Self, &Self::onEventLoopNotification>(*this);
        return asyncPoll.start(*eventLoop, handle);
    }
 
    virtual Result windowsStopFolderFilePoll(FolderWatcher& watcher) override
    {
        // This is not strictly needed as file handle is being closed soon after anyway
        // SC_TRUST_RESULT(eventLoop->removeAllAssociationsFor(fwi.fileHandle));
        T_AsyncFilePoll& asyncPoll = watcher.asyncStorage.template reinterpret_as<T_AsyncFilePoll>();
 
        onAsyncPollClose = [&watcher](T_AsyncResult&)
        {
            T_AsyncFilePoll& asyncPoll = watcher.asyncStorage.template reinterpret_as<T_AsyncFilePoll>();
            asyncPoll.~T_AsyncFilePoll();
        };
        return asyncPoll.stop(*eventLoop, &onAsyncPollClose);
    }
 
    virtual void* windowsGetOverlapped(FolderWatcher& watcher) override
    {
        T_AsyncFilePoll& asyncPoll = watcher.asyncStorage.template reinterpret_as<T_AsyncFilePoll>();
        return asyncPoll.getOverlappedPtr();
    }
 
    void onEventLoopNotification(typename T_AsyncFilePoll::Result& result)
    {
        SC_COMPILER_WARNING_PUSH_OFFSETOF;
        auto&          storage = reinterpret_cast<decltype(FolderWatcher::asyncStorage)&>(result.getAsync());
        FolderWatcher& watcher = SC_COMPILER_FIELD_OFFSET(FolderWatcher, asyncStorage, storage);
        fileSystemWatcher->asyncNotify(&watcher);
        result.reactivateRequest(true);
        SC_COMPILER_WARNING_POP;
    }
 
    Function<void(T_AsyncResult&)> onAsyncPollClose;
#endif
};
 
} // namespace SC