Как я наблюдаю файл за изменениями?

Я попробовал бы что-то вроде этого.

    try:
            f = open(filePath)
    except IOError:
            print "No such file: %s" % filePath
            raw_input("Press Enter to close window")
    try:
            lines = f.readlines()
            while True:
                    line = f.readline()
                    try:
                            if not line:
                                    time.sleep(1)
                            else:
                                    functionThatAnalisesTheLine(line)
                    except Exception, e:
                            # handle the exception somehow (for example, log the trace) and raise the same exception again
                            raw_input("Press Enter to close window")
                            raise e
    finally:
            f.close()

цикл проверяет, существует ли новая строка (строки) с прошлого раза, когда файл был считан - если существует, это читается и передается эти functionThatAnalisesTheLine функция. В противном случае сценарий ожидает 1 секунда и повторяет процесс.

Я не знаю Windows определенная функция. Вы могли попытаться добраться, хеш MD5 файла каждую вторую/минуту/час (зависит от того, как быстро Вам нужен он), и сравните его с последним хешем. Когда это отличается, Вы знаете, что файл был изменен, и Вы считываете новейшие строки.

Как Вы видите в статья Tim Golden, на которую указывают Horst Gutmann , WIN32 относительно сложен и смотрит каталоги, ни один файл.

я хотел бы предложить, чтобы Вы изучили IronPython, который является .NET реализация Python. С IronPython можно использовать весь .NET функциональность - включая

System.IO.FileSystemWatcher

, Который обрабатывает единственные файлы с простым интерфейс Event .

Ну, так как Вы используете Python, можно просто открыть файл и продолжать читать строки из него.

f = open('file.log')

, Если чтение строки не пусто , Вы обрабатываете его.

line = f.readline()
if line:
    // Do what you want with the line

можно пропускать это, нормально продолжать звонить readline в EOF. Это будет просто продолжать возвращать пустую строку в этом случае. И когда что-то добавляется к файлу журнала, чтение продолжится от того, где это остановилось, как Вам нужно.

при поиске решения, которое использует события или конкретную библиотеку, определите это в вопросе. Иначе я думаю, что это решение очень хорошо.

Проверьте мой ответ к подобный вопрос . Вы могли попробовать тот же цикл в Python. Эта страница предлагает:

import time

while 1:
    where = file.tell()
    line = file.readline()
    if not line:
        time.sleep(1)
        file.seek(where)
    else:
        print line, # already has newline

Также посмотрите вопрос хвост () файл с Python .

Много позже небольшого количества взламывания сценария Tim Golden у меня есть следующее, которое, кажется, работает вполне хорошо:

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 )

Это могло, вероятно, сделать с загрузкой больше проверки ошибок, но для того, чтобы просто наблюдать файл журнала и сделать некоторую обработку на нем перед выкладыванием его на экран, это работает хорошо.

Спасибо все для Вашего входа - большой материал!

Это не должно работать над окнами (возможно, с cygwin?), но для пользователя UNIX, необходимо использовать "fcntl" системный вызов. Вот пример в Python. Это - главным образом тот же код, если необходимо записать его в C (те же имена функций)

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)

Если бы опрос достаточно хорош для Вас, я просто смотрел бы, если "измененное время" статистика файла изменяется. Считать его:

os.stat(filename).st_mtime

(Также отмечают, что собственное решение для события изменения Windows не работает при всех обстоятельствах, например, на сетевых дисках.)

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...

связанное решение @ 4Oh4 плавное изменение для списка файлов для просмотра;

import os
import sys
import time

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

    # Constructor
    def __init__(self, watch_files, call_func_on_change=None, *args, **kwargs):
        self._cached_stamp = 0
        self._cached_stamp_files = {}
        self.filenames = watch_files
        self.call_func_on_change = call_func_on_change
        self.args = args
        self.kwargs = kwargs

    # Look for changes
    def look(self):
        for file in self.filenames:
            stamp = os.stat(file).st_mtime
            if not file in self._cached_stamp_files:
                self._cached_stamp_files[file] = 0
            if stamp != self._cached_stamp_files[file]:
                self._cached_stamp_files[file] = stamp
                # File has changed, so do something...
                file_to_read = open(file, 'r')
                value = file_to_read.read()
                print("value from file", value)
                file_to_read.seek(0)
                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 Exception as e:
                print(e)
                print('Unhandled error: %s' % sys.exc_info()[0])

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

watch_files = ['/Users/mexekanez/my_file.txt', '/Users/mexekanez/my_file1.txt']

# watcher = Watcher(watch_file)  # simple



if __name__ == "__main__":
    watcher = Watcher(watch_files, custom_action, text='yes, changed')  # also call custom action function
    watcher.watch()  # start the watch going

Вот упрощенная версия кода Кендера, которая, похоже, выполняет тот же трюк и не импортирует весь файл:

# Check file for new data.

import time

f = open(r'c:\temp\test.txt', 'r')

while True:

    line = f.readline()
    if not line:
        time.sleep(1)
        print 'Nothing New'
    else:
        print 'Call Function: ', line

Проверьте pyinotify .

inotify заменяет dnotify (из более раннего ответа) в новых Linux и позволяет осуществлять мониторинг на уровне файлов, а не на уровне каталогов.