Wie überwache ich eine Datei auf Änderungen?

Question 1

Ich habe eine Protokolldatei, die von einem anderen Prozess geschrieben wird, den ich auf Änderungen überwachen möchte. Jedes Mal, wenn eine Änderung auftritt, möchte ich die neuen Daten einlesen, um sie zu verarbeiten.

Was ist der beste Weg, dies zu tun? Ich hatte gehofft, dass es eine Art Haken aus der PyWin32-Bibliothek geben würde. Ich habe die gefunden win32file.FindNextChangeNotification funktionieren, aber keine Ahnung haben, wie man es auffordert, eine bestimmte Datei anzusehen.

Wenn jemand so etwas gemacht hat, wäre ich wirklich dankbar zu hören, wie …

[Edit] Ich hätte erwähnen sollen, dass ich nach einer Lösung suchte, die keine Abfrage erfordert.

[Edit] Flüche! Es scheint, dass dies nicht über ein zugeordnetes Netzlaufwerk funktioniert. Ich vermute, dass Windows keine Aktualisierungen der Datei so “hört”, wie es auf einer lokalen Festplatte der Fall ist.

Question 2

Haben Sie versucht, zu verwenden Wachhund?

Python-API-Bibliothek und Shell-Dienstprogramme zur Überwachung von Dateisystemereignissen.

Verzeichnisüberwachung leicht gemacht mit

Eine plattformübergreifende API.

Ein Shell-Tool zum Ausführen von Befehlen als Reaktion auf Verzeichnisänderungen.

Beginnen Sie schnell mit einem einfachen Beispiel in Schnellstart…

Question 3

Wenn die Abfrage für Sie gut genug ist, würde ich einfach beobachten, ob sich der Dateistatus “Geänderte Zeit” ändert. Um es zu lesen:

os.stat(filename).st_mtime

(Beachten Sie auch, dass die Windows-native Änderungsereignislösung nicht unter allen Umständen funktioniert, z. B. auf Netzlaufwerken.)

import os

class Monkey(object):
    def __init__(self):
        self._cached_stamp = 0
        self.filename="/path/to/file"

    def ook(self):
        stamp = os.stat(self.filename).st_mtime
        if stamp != self._cached_stamp:
            self._cached_stamp = stamp
            # File has changed, so do something...

Question 4

Wenn Sie eine Multiplattform-Lösung wünschen, dann prüfen Sie QFileSystemWatcher. Hier ein Beispielcode (nicht bereinigt):

from PyQt4 import QtCore

@QtCore.pyqtSlot(str)
def directory_changed(path):
    print('Directory Changed!!!')

@QtCore.pyqtSlot(str)
def file_changed(path):
    print('File Changed!!!')

fs_watcher = QtCore.QFileSystemWatcher(['/path/to/files_1', '/path/to/files_2', '/path/to/files_3'])

fs_watcher.connect(fs_watcher, QtCore.SIGNAL('directoryChanged(QString)'), directory_changed)
fs_watcher.connect(fs_watcher, QtCore.SIGNAL('fileChanged(QString)'), file_changed)

Question 5

Es sollte nicht unter Windows funktionieren (vielleicht mit Cygwin?), aber für Unix-Benutzer sollten Sie den Systemaufruf “fcntl” verwenden. Hier ist ein Beispiel in Python. Es ist meistens der gleiche Code, wenn Sie ihn in C schreiben müssen (gleiche Funktionsnamen)

import time
import fcntl
import os
import signal

FNAME = "/HOME/TOTO/FILETOWATCH"

def handler(signum, frame):
    print "File %s modified" % (FNAME,)

signal.signal(signal.SIGIO, handler)
fd = os.open(FNAME,  os.O_RDONLY)
fcntl.fcntl(fd, fcntl.F_SETSIG, 0)
fcntl.fcntl(fd, fcntl.F_NOTIFY,
            fcntl.DN_MODIFY | fcntl.DN_CREATE | fcntl.DN_MULTISHOT)

while True:
    time.sleep(10000)

Question 6

Kasse pynotifizieren.

inotify ersetzt dnotify (aus einer früheren Antwort) in neueren Linux-Versionen und ermöglicht die Überwachung auf Dateiebene statt auf Verzeichnisebene.

Question 7

Nun, nachdem ich Tim Goldens Skript ein wenig gehackt habe, habe ich Folgendes, was ziemlich gut zu funktionieren scheint:

import os

import win32file
import win32con

path_to_watch = "." # look at the current directory
file_to_watch = "test.txt" # look for changes to a file called test.txt

def ProcessNewData( newData ):
    print "Text added: %s"%newData

# Set up the bits we'll need for output
ACTIONS = {
  1 : "Created",
  2 : "Deleted",
  3 : "Updated",
  4 : "Renamed from something",
  5 : "Renamed to something"
}
FILE_LIST_DIRECTORY = 0x0001
hDir = win32file.CreateFile (
  path_to_watch,
  FILE_LIST_DIRECTORY,
  win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE,
  None,
  win32con.OPEN_EXISTING,
  win32con.FILE_FLAG_BACKUP_SEMANTICS,
  None
)

# Open the file we're interested in
a = open(file_to_watch, "r")

# Throw away any exising log data
a.read()

# Wait for new data and call ProcessNewData for each new chunk that's written
while 1:
  # Wait for a change to occur
  results = win32file.ReadDirectoryChangesW (
    hDir,
    1024,
    False,
    win32con.FILE_NOTIFY_CHANGE_LAST_WRITE,
    None,
    None
  )

  # For each change, check to see if it's updating the file we're interested in
  for action, file in results:
    full_filename = os.path.join (path_to_watch, file)
    #print file, ACTIONS.get (action, "Unknown")
    if file == file_to_watch:
        newText = a.read()
        if newText != "":
            ProcessNewData( newText )

Es könnte wahrscheinlich eine Menge mehr Fehlerprüfung vertragen, aber um einfach eine Protokolldatei zu beobachten und etwas zu verarbeiten, bevor sie auf den Bildschirm gespuckt wird, funktioniert dies gut.

Vielen Dank an alle für Ihren Beitrag – tolle Sache!

Question 8

Zum Ansehen einer einzelnen Datei mit Abfrage und minimalen Abhängigkeiten finden Sie hier ein vollständig ausgearbeitetes Beispiel, das auf der Antwort von Deestan (oben) basiert:

import os
import sys 
import time

class Watcher(object):
    running = True
    refresh_delay_secs = 1

    # Constructor
    def __init__(self, watch_file, call_func_on_change=None, *args, **kwargs):
        self._cached_stamp = 0
        self.filename = watch_file
        self.call_func_on_change = call_func_on_change
        self.args = args
        self.kwargs = kwargs

    # Look for changes
    def look(self):
        stamp = os.stat(self.filename).st_mtime
        if stamp != self._cached_stamp:
            self._cached_stamp = stamp
            # File has changed, so do something...
            print('File changed')
            if self.call_func_on_change is not None:
                self.call_func_on_change(*self.args, **self.kwargs)

    # Keep watching in a loop        
    def watch(self):
        while self.running: 
            try: 
                # Look for changes
                time.sleep(self.refresh_delay_secs) 
                self.look() 
            except KeyboardInterrupt: 
                print('\nDone') 
                break 
            except FileNotFoundError:
                # Action on file not found
                pass
            except: 
                print('Unhandled error: %s' % sys.exc_info()[0])

# Call this function each time a change happens
def custom_action(text):
    print(text)

watch_file="my_file.txt"

# watcher = Watcher(watch_file)  # simple
watcher = Watcher(watch_file, custom_action, text="yes, changed")  # also call custom action function
watcher.watch()  # start the watch going