Initial commit

Code/Tools/AssetProcessor/Platform/Mac/native/FileWatcher/FileWatcher_macos.cpp

@@ -0,0 +1,176 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#include <native/FileWatcher/FileWatcher.h>
+
+#include <native/utilities/BatchApplicationManager.h>
+
+#include <AzCore/Debug/Trace.h>
+#include <CoreServices/CoreServices.h>
+
+void FileEventStreamCallback(ConstFSEventStreamRef streamRef, void *clientCallBackInfo, size_t numEvents, void *eventPaths, const FSEventStreamEventFlags eventFlags[], const FSEventStreamEventId eventIds[]);
+
+struct FolderRootWatch::PlatformImplementation
+{
+    PlatformImplementation() : m_stream(nullptr), m_runLoop(nullptr) { }
+
+    FSEventStreamRef m_stream;
+    CFRunLoopRef m_runLoop;
+    QString m_renameFileDirectory;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+/// FolderWatchRoot
+FolderRootWatch::FolderRootWatch(const QString rootFolder)
+    : m_root(rootFolder)
+    , m_shutdownThreadSignal(false)
+    , m_fileWatcher(nullptr)
+    , m_platformImpl(new PlatformImplementation())
+{
+}
+
+FolderRootWatch::~FolderRootWatch()
+{
+    // Destructor is required in here since this file contains the definition of struct PlatformImplementation
+    Stop();
+
+    delete m_platformImpl;
+}
+
+bool FolderRootWatch::Start()
+{
+    m_shutdownThreadSignal = false;
+
+    CFStringRef rootPath = CFStringCreateWithCString(kCFAllocatorDefault, m_root.toStdString().data(), kCFStringEncodingMacRoman);
+    CFArrayRef pathsToWatch = CFArrayCreate(NULL, (const void **)&rootPath, 1, NULL);
+    
+    // The larger this number, the larger the delay between the kernel knowing a file changed
+    // and us actually consuming the event.  It is very important for asset processor to deal with
+    // file changes as fast as possible, since we use file "fencing" to control network access
+    // For example, if someone asks (over the network) "does file xyz exist?" we actually put a random file on disk
+    // and only answer their query when we see that file appear on our file monitor, so that we know all other
+    // file creations/modifications/deletions have been seen before we answer their question.
+    // as such, having a slow response time here can cause a dramatic slowdown for all other operations.
+    CFAbsoluteTime timeBetweenKernelUpdateAndNotification = 0.001;
+
+    // Set ourselves as the value for the context info field so that in the callback
+    // we get passed into it and the callback can call our public API to handle
+    // the file change events
+    FSEventStreamContext streamContext;
+    ::memset(&streamContext, 0, sizeof(streamContext));
+    streamContext.info = this;
+
+    m_platformImpl->m_stream = FSEventStreamCreate(NULL,
+                                 FileEventStreamCallback,
+                                 &streamContext,
+                                 pathsToWatch,
+                                 kFSEventStreamEventIdSinceNow,
+                                 timeBetweenKernelUpdateAndNotification,
+                                 kFSEventStreamCreateFlagFileEvents);
+
+    AZ_Error("FileWatcher", (m_platformImpl->m_stream != nullptr), "FSEventStreamCreate returned a nullptr. No file events will be reported for %s", m_root.toStdString().c_str());
+
+    m_thread = std::thread(std::bind(&FolderRootWatch::WatchFolderLoop, this));
+
+    CFRelease(pathsToWatch);
+    CFRelease(rootPath);
+
+    return (m_platformImpl->m_stream != nullptr);
+}
+
+void FolderRootWatch::Stop()
+{
+    m_shutdownThreadSignal = true;
+
+    if (m_thread.joinable())
+    {
+        m_thread.join(); // wait for the thread to finish
+        m_thread = std::thread(); //destroy
+    }
+
+    FSEventStreamStop(m_platformImpl->m_stream);
+    FSEventStreamInvalidate(m_platformImpl->m_stream);
+    FSEventStreamRelease(m_platformImpl->m_stream);
+}
+
+void FolderRootWatch::WatchFolderLoop()
+{
+    // Use a half second timeout interval so that we can check if
+    // m_shutdownThreadSignal has been changed while we were running the RunLoop
+    static const CFTimeInterval secondsToProcess = 0.5;
+
+    m_platformImpl->m_runLoop = CFRunLoopGetCurrent();
+    FSEventStreamScheduleWithRunLoop(m_platformImpl->m_stream, m_platformImpl->m_runLoop, kCFRunLoopDefaultMode);
+    FSEventStreamStart(m_platformImpl->m_stream);
+
+    const bool returnAfterFirstEventHandled = false;
+
+    while (!m_shutdownThreadSignal)
+    {
+        CFRunLoopRunInMode(kCFRunLoopDefaultMode, secondsToProcess, returnAfterFirstEventHandled);
+    }
+}
+
+void FileEventStreamCallback(ConstFSEventStreamRef streamRef, void *clientCallBackInfo, size_t numEvents, void *eventPaths, const FSEventStreamEventFlags eventFlags[], const FSEventStreamEventId eventIds[])
+{
+    FolderRootWatch* watcher = reinterpret_cast<FolderRootWatch*>(clientCallBackInfo);
+
+    const char** filePaths = reinterpret_cast<const char**>(eventPaths);
+
+    for (int i = 0; i < numEvents; ++i)
+    {
+        QFileInfo fileInfo(QDir::cleanPath(filePaths[i]));
+        QString fileAndPath = fileInfo.absoluteFilePath();
+
+        if (!fileInfo.isHidden())
+        {
+            // Some events will be aggreated into one so it is possible we will get
+            // multiple event flags set for a single file (create/modify as an example)
+            // so check for all of them
+            if (eventFlags[i] & kFSEventStreamEventFlagItemCreated)
+            {
+                watcher->ProcessNewFileEvent(fileAndPath);
+            }
+
+            if (eventFlags[i] & kFSEventStreamEventFlagItemModified)
+            {
+                watcher->ProcessModifyFileEvent(fileAndPath);
+            }
+
+            if (eventFlags[i] & kFSEventStreamEventFlagItemRemoved)
+            {
+                watcher->ProcessDeleteFileEvent(fileAndPath);
+            }
+
+            if (eventFlags[i] & kFSEventStreamEventFlagItemRenamed)
+            {
+                if (fileInfo.exists())
+                {
+                    watcher->ProcessNewFileEvent(fileAndPath);
+
+                    // macOS does not send out an event for the directory being
+                    // modified when a file has been renamed but the FileWatcher
+                    // API expects it so send out the modification event ourselves.
+                    watcher->ProcessModifyFileEvent(fileInfo.absolutePath());
+                }
+                else
+                {
+                    watcher->ProcessDeleteFileEvent(fileAndPath);
+
+                    // macOS does not send out an event for the directory being
+                    // modified when a file has been renamed but the FileWatcher
+                    // API expects it so send out the modification event ourselves.
+                    watcher->ProcessModifyFileEvent(fileInfo.absolutePath());
+                }
+            }
+        }
+    }
+}

Code/Tools/AssetProcessor/Platform/Mac/native/FileWatcher/FileWatcher_win.cpp

@@ -0,0 +1,134 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <native/FileWatcher/FileWatcher.h>
+
+#include <AzCore/PlatformIncl.h>
+
+struct FolderRootWatch::PlatformImplementation
+{
+    PlatformImplementation() : m_directoryHandle(nullptr), m_ioHandle(nullptr) { }
+    HANDLE m_directoryHandle;
+    HANDLE m_ioHandle;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+/// FolderWatchRoot
+FolderRootWatch::FolderRootWatch(const QString rootFolder)
+    : m_root(rootFolder)
+    , m_shutdownThreadSignal(false)
+    , m_fileWatcher(nullptr)
+    , m_platformImpl(new PlatformImplementation())
+{
+}
+
+FolderRootWatch::~FolderRootWatch()
+{
+    // Destructor is required in here since this file contains the definition of struct PlatformImplementation
+    Stop();
+
+    delete m_platformImpl;
+}
+
+bool FolderRootWatch::Start()
+{
+    m_platformImpl->m_directoryHandle = ::CreateFileW(m_root.toStdWString().data(), FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, nullptr);
+
+    if (m_platformImpl->m_directoryHandle != INVALID_HANDLE_VALUE)
+    {
+        m_platformImpl->m_ioHandle = ::CreateIoCompletionPort(m_platformImpl->m_directoryHandle, nullptr, 1, 0);
+        if (m_platformImpl->m_ioHandle != INVALID_HANDLE_VALUE)
+        {
+            m_shutdownThreadSignal = false;
+            m_thread = std::thread(std::bind(&FolderRootWatch::WatchFolderLoop, this));
+            return true;
+        }
+    }
+    return false;
+}
+
+void FolderRootWatch::Stop()
+{
+    m_shutdownThreadSignal = true;
+    CloseHandle(m_platformImpl->m_ioHandle);
+    m_platformImpl->m_ioHandle = nullptr;
+
+    if (m_thread.joinable())
+    {
+        m_thread.join(); // wait for the thread to finish
+        m_thread = std::thread(); //destroy
+    }
+    CloseHandle(m_platformImpl->m_directoryHandle);
+    m_platformImpl->m_directoryHandle = nullptr;
+}
+
+void FolderRootWatch::WatchFolderLoop()
+{
+    FILE_NOTIFY_INFORMATION aFileNotifyInformationList[50000];
+    QString path;
+    OVERLAPPED aOverlapped;
+    LPOVERLAPPED pOverlapped;
+    DWORD dwByteCount;
+    ULONG_PTR ulKey;
+
+    while (!m_shutdownThreadSignal)
+    {
+        ::memset(aFileNotifyInformationList, 0, sizeof(aFileNotifyInformationList));
+        ::memset(&aOverlapped, 0, sizeof(aOverlapped));
+
+        if (::ReadDirectoryChangesW(m_platformImpl->m_directoryHandle, aFileNotifyInformationList, sizeof(aFileNotifyInformationList), true, FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_FILE_NAME, nullptr, &aOverlapped, nullptr))
+        {
+            //wait for up to a second for I/O to signal
+            dwByteCount = 0;
+            if (::GetQueuedCompletionStatus(m_platformImpl->m_ioHandle, &dwByteCount, &ulKey, &pOverlapped, INFINITE))
+            {
+                //if we are signaled to shutdown bypass
+                if (!m_shutdownThreadSignal && ulKey)
+                {
+                    if (dwByteCount)
+                    {
+                        int offset = 0;
+                        FILE_NOTIFY_INFORMATION* pFileNotifyInformation = aFileNotifyInformationList;
+                        do
+                        {
+                            pFileNotifyInformation = (FILE_NOTIFY_INFORMATION*)((char*)pFileNotifyInformation + offset);
+
+                            path.clear();
+                            path.append(m_root);
+                            path.append(QString::fromWCharArray(pFileNotifyInformation->FileName, pFileNotifyInformation->FileNameLength / 2));
+
+                            QString file = QDir::toNativeSeparators(QDir::cleanPath(path));
+
+                            switch (pFileNotifyInformation->Action)
+                            {
+                            case FILE_ACTION_ADDED:
+                            case FILE_ACTION_RENAMED_NEW_NAME:
+                                ProcessNewFileEvent(file);
+                                break;
+                            case FILE_ACTION_REMOVED:
+                            case FILE_ACTION_RENAMED_OLD_NAME:
+                                ProcessDeleteFileEvent(file);
+                                break;
+                            case FILE_ACTION_MODIFIED:
+                                ProcessModifyFileEvent(file);
+                                break;
+                            }
+
+                            offset = pFileNotifyInformation->NextEntryOffset;
+                        } while (offset);
+                    }
+                }
+            }
+        }
+    }
+}
+