Question

我尝试监控目录树的内容，其中包含大量文件（许多目录每个目录有9000个文件作为示例）。

同步模式：

我首先尝试在阻塞模式下使用 ReadDirectoryChangesW （同步），但是当我删除被监视的目录时，我最终陷入死锁，我无法检测也无法退出。

#
# Monitors a directory for changes and pass the changes to the queue
#
def MonitorDirectory(self, out_queue):

    print("Monitoring instance \'{0}\' is watching directory: {1}".format(self.name, self.path))

    # File monitor
    FILE_LIST_DIRECTORY = 0x0001

    buffer = win32file.AllocateReadBuffer(1024 * 64)

    hDir = win32file.CreateFile(self.path,
                                FILE_LIST_DIRECTORY,
                                win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE,
                                None,
                                win32con.OPEN_EXISTING,
                                win32con.FILE_FLAG_BACKUP_SEMANTICS,
                                None)

    # Monitor directory for changes
    while not self._shutdown.is_set():

        # Create handle to directory if missing
        #if os.path.isdir(self.path):

        self.fh.write("ReOpen Exists {0}\n".format(os.path.isdir(self.path)))
        self.fh.flush()
        try:
            hDir = win32file.CreateFile(self.path,
                                FILE_LIST_DIRECTORY,
                                win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE,
                                None,
                                win32con.OPEN_EXISTING,
                                win32con.FILE_FLAG_BACKUP_SEMANTICS,
                                None)
        except:
            self.fh.write("Handle is dead\n")
            self.fh.flush()

        try:
            self.fh.write("{0}\n".format(newH))
            self.fh.flush()
        except:
            self.fh.write("Write failed\n")
            self.fh.flush()

        self.fh.write("Check Changes\n")
        self.fh.flush()

        results = win32file.ReadDirectoryChangesW(hDir,
                                                    1024 * 64,
                                                    True,
                                                    win32con.FILE_NOTIFY_CHANGE_FILE_NAME |
                                                    win32con.FILE_NOTIFY_CHANGE_DIR_NAME |
                                                    win32con.FILE_NOTIFY_CHANGE_ATTRIBUTES |
                                                    win32con.FILE_NOTIFY_CHANGE_SIZE |
                                                    win32con.FILE_NOTIFY_CHANGE_LAST_WRITE |
                                                    win32con.FILE_NOTIFY_CHANGE_SECURITY,
                                                    None,
                                                    None)

        # Add all changes to queue
        for action, file in results:

            self.fh.write("Action: {0} on {1}\n".format(action, file))

            out_queue.put((action, time.time(), os.path.join(self.path, file)))

        self.fh.flush()


        #else:


    # Done main loop
    print("Monitoring instance \'{0}\' has finished watching directory: {1}".format(self.name, self.path))

当被删除的目录被删除时，似乎无法避免阻塞呼叫？

此外，当函数在一个线程中运行时，我无法在死锁时杀死它，从“supervisor”线程监视父目录中监视目录上的DELETE操作，我真的不喜欢这是一个很好的解决方案它涉及更多的代码。

异步模式：

然后我尝试了重叠模式（async），它不会在死锁中阻塞，但是当删除了diorectory时，我无法检测到目录句柄何时变为void。 WaitForSingleObject 调用时间刚刚结束，并且检查目录是否与 os.path.isdir 一起存在没有帮助，因为如果同时重新创建目录，它将会不返回False，但旧的目录句柄仍然无效，并且不会检测新创建的目录中具有相同名称的更改。

经过几天尝试各种方法，我最终得到了这个代码，然而它无法正常工作，因为它仍然没有检测到被监视目录的删除，并且在快速批量删除文件时也错过了一些文件。同步模式没有的东西。

#
# Monitors a directory for changes and pass the changes to the queue
#
def MonitorDirectory(self, out_queue):

    print("Monitoring instance \'{0}\' is watching directory: {1}".format(self.name, self.path))

    # File monitor
    FILE_LIST_DIRECTORY = 0x0001

    overlapped          = pywintypes.OVERLAPPED()
    overlapped.hEvent   = win32event.CreateEvent(None, False, 0, None)

    buffer  = win32file.AllocateReadBuffer(1024 * 64)

    # Main loop to keep watching active
    while not self._shutdown.is_set():

        # Open directory
        try:
            hDir = win32file.CreateFile(self.path,
                                        FILE_LIST_DIRECTORY,
                                        win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE,
                                        None,
                                        win32con.OPEN_EXISTING,
                                        win32con.FILE_FLAG_BACKUP_SEMANTICS | win32con.FILE_FLAG_OVERLAPPED,
                                        None)

        except: 

            # Wait before retry
            time.sleep(1)

        else:

            # Monitor directory for changes
            while not self._shutdown.is_set():

                win32file.ReadDirectoryChangesW(hDir,
                                                buffer,
                                                True,
                                                win32con.FILE_NOTIFY_CHANGE_FILE_NAME |
                                                win32con.FILE_NOTIFY_CHANGE_DIR_NAME |
                                                win32con.FILE_NOTIFY_CHANGE_ATTRIBUTES |
                                                win32con.FILE_NOTIFY_CHANGE_SIZE |
                                                win32con.FILE_NOTIFY_CHANGE_LAST_WRITE |
                                                win32con.FILE_NOTIFY_CHANGE_SECURITY,
                                                overlapped,
                                                None)

                # Wait for the changes
                rc = win32event.WaitForSingleObject(overlapped.hEvent, 10000)

                if rc == win32event.WAIT_OBJECT_0:

                    try:
                        bytes_returned = win32file.GetOverlappedResult(hDir, overlapped, True)

                    except:
                        raise Exception("Error: handle invalid?")

                    else:

                        # Get the changes
                        for action, file in win32file.FILE_NOTIFY_INFORMATION(buffer, bytes_returned):                        
                            out_queue.put((action, time.time(), os.path.join(self.path, file)))

                elif rc == win32event.WAIT_TIMEOUT:
                    print("Monitoring instance \'{0}\': Timeout, no actions")

                else:
                    raise Exception("Error?! RC = {0}".format(rc))

    # Done main loop
    print("Monitoring instance \'{0}\' has finished watching directory: {1}".format(self.name, self.path))

有没有办法处理检测到已删除监视目录的问题，而不仅仅是删除 win32con.FILE_SHARE_DELETE 标志？

Answer 1

<强>考虑：

1 ^st，我邀请您阅读[SO]: win32file.ReadDirectoryChangesW doesn't find all moved files (@CristiFati's answer)，了解有关[ActiveState.Docs]: win32file.ReadDirectoryChangesW（包装[MS.Docs]: ReadDirectoryChangesW function）的一般注意事项。我将在这里放置一些方面来自另一个答案（那些非常重要的）
始终瞄准<strong>异步，因为它允许在超时时正常退出（异常中断可能会保持打开资源直到程序退出（有时甚至超出！））
由于 GIL （[Python.Wiki]: GlobalInterpreterLock）

现在，关于 FILE_SHARE_DELETE 的几句话（可以在[MS.Docs]: CreateFileW function找到一些关于它的文档）：

黄金法则（或不可变的法律，如果你愿意）是用户不能真正删除具有打开句柄的文件（或目录）。

尝试删除或重命名（这似乎与当前问题无关，但事实并非如此）带有打开句柄的目录可能会有不同的结果（取决于创建句柄的方式和 API 用于重命名/删除目录）：

错误（ ERROR_ACCESS_DENIED ） - 未指定 FILE_SHARE_DELETE （以及其他一些情况）时发生
没有错误，但目录仍然存在 - 通常意味着它已被安排删除，并且一旦上次打开句柄将被关闭，它将自动消失
删除成功和目录。实际上，这不是真的，dir只是被移动（重命名）为“ RECYCLE.BIN ”（尝试从那里删除它将导致 ＃1。 ;所以试图真正在1 ^st地方删除它（ Shift + Del 来自 Explorer ））

我测试了上述场景，尝试以各种方式删除/重命名目录：

cmd ：rmdir /q /s，move /y
资源管理器： Del ， Shift + Del
Windows Commander ： F8 ， Shift + F8

我开始调查解决问题的方法，我遇到了[MS.Docs]: GetFinalPathNameByHandleW function（win32file.GetFinalPathNameByHandle）。玩过它：

>>> import sys
>>> import os
>>> import win32api
>>> import win32file
>>> import win32con
>>>
>>> print("Python {:s} on {:s}\n".format(sys.version, sys.platform))
Python 3.5.4 (v3.5.4:3f56838, Aug  8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)] on win32

>>> os.listdir()
['code.py', 'test']
>>> test_dir = ".\\test"
>>> os.path.abspath(test_dir)
'e:\\Work\\Dev\\StackOverflow\\q049652110\\test'
>>> h = win32file.CreateFile(test_dir, win32con.GENERIC_READ, win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE, None, win32con.OPEN_EXISTING, win32con.FILE_FLAG_BACKUP_SEMANTICS, None)
>>> h
<PyHANDLE:620>
>>> win32file.GetFinalPathNameByHandle(h, win32con.FILE_NAME_NORMALIZED)
'\\\\?\\E:\\Work\\Dev\\StackOverflow\\q049652110\\test'
>>> test_dir1 = test_dir + "1"
>>> os.rename(test_dir, test_dir1)
>>> os.listdir()
['code.py', 'test1']
>>> win32file.GetFinalPathNameByHandle(h, win32con.FILE_NAME_NORMALIZED)
'\\\\?\\E:\\Work\\Dev\\StackOverflow\\q049652110\\test1'
>>> os.rename(test_dir1, test_dir)
>>> os.listdir()
['code.py', 'test']
>>> win32file.GetFinalPathNameByHandle(h, win32con.FILE_NAME_NORMALIZED)
'\\\\?\\E:\\Work\\Dev\\StackOverflow\\q049652110\\test'
>>> os.unlink(test_dir)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
PermissionError: [WinError 5] Access is denied: '.\\test'
>>> # Delete the dir from elsewhere (don't use os.rmdir since that will only schedule the dir for deletion)
...
>>> os.listdir()
['code.py']
>>> win32file.GetFinalPathNameByHandle(h, win32con.FILE_NAME_NORMALIZED)
'\\\\?\\E:\\$RECYCLE.BIN\\S-1-5-21-1906798797-2830956273-3148971768-1002\\$RY7SH8D'
>>> os.mkdir(test_dir)
>>> os.listdir()
['code.py', 'test']
>>> win32file.GetFinalPathNameByHandle(h, win32con.FILE_NAME_NORMALIZED)
'\\\\?\\E:\\$RECYCLE.BIN\\S-1-5-21-1906798797-2830956273-3148971768-1002\\$RY7SH8D'
>>> os.rmdir(test_dir) # Since the new "test" dir wasn't open, operation successful
>>> os.listdir()
['code.py']
>>> win32file.GetFinalPathNameByHandle(h, win32con.FILE_NAME_NORMALIZED)
'\\\\?\\E:\\$RECYCLE.BIN\\S-1-5-21-1906798797-2830956273-3148971768-1002\\$RY7SH8D'
>>> # Restore the dir from RECYCLE.BIN
...
>>> os.listdir()
['code.py', 'test']
>>> win32file.GetFinalPathNameByHandle(h, win32con.FILE_NAME_NORMALIZED)
'\\\\?\\E:\\Work\\Dev\\StackOverflow\\q049652110\\test'
>>> os.rmdir(test_dir) # Still an open handle, scheduled to be deleted
>>> os.listdir()
['code.py', 'test']
>>> win32file.GetFinalPathNameByHandle(h, win32con.FILE_NAME_NORMALIZED)
'\\\\?\\E:\\Work\\Dev\\StackOverflow\\q049652110\\test'
>>> win32api.CloseHandle(h)
>>> os.listdir()
['code.py'] # After closing the handle the dir was deleted
>>> h
<PyHANDLE:0>
>>> win32file.GetFinalPathNameByHandle(h, win32con.FILE_NAME_NORMALIZED)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
pywintypes.error: (6, 'GetFinalPathNameByHandle', 'The handle is invalid.')

注意：我也尝试了[MS.Docs]: GetFileInformationByHandle function（win32file.GetFileInformationByHandle），但我无法重现这种行为，即使是3 pywintypes.datetime个字段之一（应该是上次访问/修改时间）;重命名/删除目录时，没有任何信息发生变化。我没有花时间去调查，我想到了两个可能的原因：

该数据以某种方式存储在 HANDLE 内部，并且该函数在调用时实际上不会查询 FS （与相对） GetFinalPathNameByHandle ）
重命名/删除目录时，其父目录的日期字段会发生变化

所以我们似乎有一个胜利者。我只会发布算法（代码应该相当简单）：

在 CreateFile 之后，在句柄上调用 GetFinalPathNameByHandle 并将其保存在变量中
在循环中（不断调用 ReadDirectoryChangesW ），在每次迭代（ WAIT_TIMEOUT ）上再次在句柄上调用 GetFinalPathNameByHandle 并比较结果保存的价值;如果它们不同（dir被重命名/“删除”），则采取适当的措施，例如：
- 突破循环
- 重新打开（重新创建）目录并重新开始
- 让用户知道

其他可能的方法（虽然不受欢迎）：

请勿指定 FILE_SHARE_DELETE （如您所述），这样dir将 unrenameable / 不可删除
监控父目录（作为 ReadDirectoryChangesW ）：

检索描述指定目录中的更改的信息。该功能不报告对指定目录本身的更改。
由于父目录可能包含您不关心的其他目录/文件，我想到了一个（跛脚）变通办法（获取）可能会或可能不会起作用：
- 选择一个目录（与我们谈论的完全不同）
- 创建我们目录的符号链接以监控内部（您控制该目录，没有其他人会乱用它）
- 监控它（这里我既不知道事件是通过符号链接转发，也不知道监控在断开链接时是如何反应的）

关于“事件丢失”，正如我在另一个答案中指出的那样，无法确定是否会处理所有这些事件，只有最小化丢失的号码的方法。

Answer 2

好记录：CristiFati的解决方案（以及对问题的解释）起到了作用。

实际上有两个问题：

当简单地删除文件时，它被移动到回收器，因此句柄实际上仍然有效，但更改了不再跟踪的地方。使用GetFinalPathNameByHandle就可以了！我可以检测到删除，并据此处理。

其次，在没有前往回收站的情况下删除文件时，出现错误，因为该文件在文件夹中仍然可见但无法访问，因此后续调用CreateFile失败并显示访问被拒绝错误。这是因为之前的文件句柄仍处于打开状态，因此删除无法完成并且刚刚排队。所以现在我在调用CreateFile之前尝试关闭任何打开的句柄。

现在是工作代码：

#
# Monitors a directory for changes and pass the changes to the queue
#
def MonitorDirectory(self, out_queue):

    print("Monitoring instance \'{0}\' is watching directory: {1}".format(self.name, self.path))

    # File monitor
    FILE_LIST_DIRECTORY = 0x0001

    overlapped          = pywintypes.OVERLAPPED()
    overlapped.hEvent   = win32event.CreateEvent(None, False, 0, None)

    buffer  = win32file.AllocateReadBuffer(1024 * 64)

    # Main loop to keep watching active
    while not self._shutdown.is_set():

        # Open directory
        try:    

            # Ensure handle is closed so delete event can fire and actually delete the folder
            try:
                win32file.CloseHandle(hDir)

            finally:
                hDir = win32file.CreateFile(self.path,
                                            FILE_LIST_DIRECTORY,
                                            win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE,
                                            None,
                                            win32con.OPEN_EXISTING,
                                            win32con.FILE_FLAG_BACKUP_SEMANTICS | win32con.FILE_FLAG_OVERLAPPED,
                                            None)

                hDirPath = win32file.GetFinalPathNameByHandle(hDir, win32con.FILE_NAME_NORMALIZED)

        except:

            print("Directory to monitor does not exist! Waiting...")

            # Wait before retry
            time.sleep(1)

        else:

            # Signal initialized event on queue, so the directory can be initialized
            out_queue.put((0, time.time(), None))

            # Monitor directory for changes
            while not self._shutdown.is_set():

                win32file.ReadDirectoryChangesW(hDir,
                                                buffer,
                                                True,
                                                win32con.FILE_NOTIFY_CHANGE_FILE_NAME |
                                                win32con.FILE_NOTIFY_CHANGE_DIR_NAME |
                                                win32con.FILE_NOTIFY_CHANGE_ATTRIBUTES |
                                                win32con.FILE_NOTIFY_CHANGE_SIZE |
                                                win32con.FILE_NOTIFY_CHANGE_LAST_WRITE |
                                                win32con.FILE_NOTIFY_CHANGE_SECURITY,
                                                overlapped,
                                                None)

                # Wait for the changes
                rc = win32event.WaitForSingleObject(overlapped.hEvent, 10000)

                # Detect move to Recycle bin
                try:
                    if hDirPath != win32file.GetFinalPathNameByHandle(hDir, win32con.FILE_NAME_NORMALIZED):

                        # Set watched dir as deleted (FileAction: 2 = delete)
                        out_queue.put( (2, time.time(), self.path) )

                        # Exits loop and wait for reinit
                        break;

                except:

                    print("Error: directory removed or invalid handle...")
                    break;


                if rc == win32event.WAIT_OBJECT_0:

                    try:
                        bytes_returned = win32file.GetOverlappedResult(hDir, overlapped, True)

                    except:
                        print("Error: directory removed or invalid handle...")
                        break;

                    else:

                        # Get the changes
                        for action, file in win32file.FILE_NOTIFY_INFORMATION(buffer, bytes_returned):
                            out_queue.put((action, time.time(), os.path.join(self.path, file)))

                elif rc == win32event.WAIT_TIMEOUT:
                    print("Monitoring instance \'{0}\': Timeout, no actions".format(self.name))

                else:
                    print("Error?! RC = {0}".format(rc))
                    break

    # Done main loop
    print("Monitoring instance \'{0}\' has finished watching directory: {1}".format(self.name, self.path))

ReadDirectoryChangesW无法检测和处理被监视目录

2 个答案: