前言
在我们使用服务器的时候，有时候需要监控文件或文件夹的变化。例如，定期扫描文件夹下是否有某一类型的文件生成。
今天，我们介绍如何使用 Python 来监控文件系统。
在 Python 中，主要有两个监控文件系统的库：
-
pyinotify：https://github.com/seb-m/pyinotify/wiki
pyinotify 依赖的是 Linux 的 inotify，所以它只能在 linux 中使用
-
watchdog：http://pythonhosted.org/watchdog/
watchdog 是跨平台（linux、Windows、macOS）的库，对不同平台都进行了封装。但是需要安装依赖库。
通常我们使用的服务器都是 linux 系统，所以为了避免安装依赖包的麻烦，我们使用 pyinotify 库来实现我们的监控文件系统的功能。
介绍
1. 安装
- 依赖
Linux kernel with inotify ≥ 2.6.13Python ≥ 2.4 or 3.x
- 安装
pip install pyinotify
使用
比方说，我们要监视 /tmp 及其所有子目录中的每一个新文件的创建或删除。为了简单起见，我们只在标准输出上打印每个通知的消息
现在有几种读取事件并采取适当操作的策略，其中有四种流行的模式：
使用 的
loop()方法进行不间断的监视。在这种情况下，当前进程只需要专注于此任务通过在
Notifier中使用timeout通知程序在方便时显式调用处理方法来进行定期监视。在这种情况下，它不会阻塞您当前的线程，但是如果超时值设置得太小，也可能导致少量的响应性丢失或资源使用增加生成新线程来独立地监视文件事件，此方法实例化
ThreadedNotifier通过
AsyncNotifier类进行异步监控
具体使用哪种策略主要取决于您的需要和您的环境，下面我们来实现这四种策略
共有代码
import pyinotify
# The watch manager stores the watches and provides operations on watches
wm = pyinotify.WatchManager()
# 监视事件
mask = pyinotify.IN_DELETE | pyinotify.IN_CREATE
class EventHandler(pyinotify.ProcessEvent):
def process_IN_CREATE(self, event):
print "Creating:", event.pathname
def process_IN_DELETE(self, event):
print "Removing:", event.pathname
我们定义了一个 EventHandler 类，并继承一个 ProcessEvent 处理事件类。
对于某一 EVENT_TYPE，其对应的 process_EVENT_TYPE 函数将被执行。
EVENT_TYPE 包括：
image.png
1. 不加 timeout 的 Notifier
# 创建事件处理对象
handler = EventHandler()
notifier = pyinotify.Notifier(wm, handler)
wdd = wm.add_watch('/tmp', mask, rec=True)
notifier.loop()
接下去就要添加需要监听的目录
wdd = wm.add_watch('/tmp', mask, rec=True)
最后，执行监听，在使用 Ctrl+C 终止之前，程序都会一直运行
notifier.loop()
2. 使用 timeout 的 Notifier
如果您希望定期检查事件而不是阻塞事件，可以使用较短的超时值来构造 Notifier
notifier = pyinotify.Notifier(wm, handler, timeout=10)
并使用这样的函数检查和处理事件
def quick_check(notifier):
assert notifier._timeout is not None, 'Notifier must be constructed with a short timeout'
notifier.process_events()
while notifier.check_events(): #loop in case more events appear while we are processing
notifier.read_events()
notifier.process_events()
3. 使用 ThreadedNotifier 类
notifier = pyinotify.ThreadedNotifier(wm, EventHandler())
notifier.start()
wdd = wm.add_watch('/tmp', mask, rec=True)
wm.rm_watch(wdd.values())
notifier.stop()
当然，在需要的时候，我们也可以删除监视目录
if wdd['/tmp'] > 0: # test if the wd is valid, ie. if /tmp is being watched, this test is not mandatory though
wm.rm_watch(wdd['/tmp'])
注意：如果 /tmp 中存在子目录，那么还会监听其子目录。如果要删除 /tmp 及其子目录的监听，可以使用 rec=True
wm.rm_watch(wdd['/tmp'], rec=True)
或者
wm.rm_watch(wdd.values())
在我们操作完目录之后，最后需要将监听事件停止
notifier.stop()
4. 使用 AsyncNotifier 类
import asyncore
notifier = pyinotify.AsyncNotifier(wm, EventHandler())
wdd = wm.add_watch('/tmp', mask, rec=True)
asyncore.loop()
这个 AsyncNotifier 类依赖于 Python 标准模块 asyncore，是轮询事件的一个替代方法。
示例
import pyinotify
import sys
class EventHandler(pyinotify.ProcessEvent):
def my_init(self, file_object=sys.stdout):
"""
This is your constructor it is automatically called from
ProcessEvent.__init__(), And extra arguments passed to __init__() would
be delegated automatically to my_init().
"""
self._file_object = file_object
self.sign = False
def process_IN_CREATE(self, event):
"""
This method processes a specific type of event: IN_CREATE. event
is an instance of Event.
"""
if hasattr(event, 'pathname') and event.pathname.endswith('.xls'):
print('%s have been created.\n' % event.pathname, file=self._file_object)
def process_IN_DELETE(self, event):
"""
This method processes a specific type of event: IN_DELETE. event
is an instance of Event.
"""
print('deleting: %s\n' % event.pathname, file=self._file_object)
# pass
def process_IN_CLOSE(self, event):
"""
This method is called on these events: IN_CLOSE_WRITE and
IN_CLOSE_NOWRITE.
"""
# print('closing: %s\n' % event.pathname, file=self._file_object)
pass
def process_IN_CLOSE_WRITE(self, event):
"""
This method processes a specific type of event: IN_CLOSE_WRITE
"""
pass
def process_default(self, event):
"""
Eventually, this method is called for all others types of events.
This method can be useful when an action fits all events.
"""
# print('default processing\n', file=self._file_object)
pass
def watching(path, exclude_path=None, rec=False, read_freq=0, timeout=None):
""" watch files or directories
@args:
path: str or list of str, Path to watch, the path can either be a
file or a directory. Also accepts a sequence (list) of paths.
exclude_path: str or list, predicate (boolean function), which returns True
if the current path must be excluded from being watched. This
argument has precedence over exclude_filter passed to the
class' constructor.
rec: Recursively add watches from path on all its subdirectories,
set to False by default (doesn't follows symlinks in any case)
read_freq: if read_freq == 0, events are read asap, if read_freq is > 0,
this thread sleeps max(0, read_freq - (timeout / 1000)) seconds.
But if timeout is None it may be different because poll is
blocking waiting for something to read.
timeout: see read_freq above. If provided, it must be set in milliseconds
"""
# Instanciate a new WatchManager (will be used to store watches)
wm = pyinotify.WatchManager()
# events types
mask = pyinotify.IN_DELETE | pyinotify.IN_CREATE
# Associate this WatchManager with a Notifier (will be used to report and process events).
notifier = pyinotify.Notifier(wm, EventHandler(), read_freq=read_freq, timeout=timeout)
# Add a new watch on 'path' for some XXX_EVENTS.
if isinstance(path, str) or isinstance(path, list):
print("now starting monitor %s." %path)
wm.add_watch(path, mask, rec=rec, exclude_filter=exclude_path)
else:
raise ValueError("the %s seems not valid path" %(path))
# Loop forever and handle events.
notifier.loop()
if __name__ == '__main__':
path = '~/jupyter/Others/Wechat'
watching(path)
这个脚本监控目录下 .xls 类型文件的创建和任意文件删除
- 运行
$ python watching.py
now starting monitor ~/jupyter/Others/Wechat.
- 新建 xls 文件
touch a.xls b.xls c.txt
- 输出
~/jupyter/Others/Wechat/a.xls have been created.
~/jupyter/Others/Wechat/b.xls have been created.
- 删除文件
ls | egrep '.*xls|txt' | xargs rm
- 输出
deleting: ~/jupyter/Others/Wechat/a.xls
deleting: ~/jupyter/Others/Wechat/b.xls
deleting: ~/jupyter/Others/Wechat/c.txt
总结
上面的脚本主要用来监听目录下面文件的创建和删除，如果想要监听其他事件，可以在脚本的基础上进行改下，并添加对应的时间处理。
同时，如果想要定时监控的话，可以设置 read_freq 和 timeout 参数。
计算公式为：
max(0, read_freq - (timeout / 1000))
文件 github 地址：
https://github.com/dxsbiocc/learn/blob/main/Python/utils/watching.py
