¿Cómo implementar un equivalente pitónico de cola -F?

Question

¿Cuál es la forma pitónica de ver el final de un archivo en crecimiento por la aparición de ciertas palabras clave?

Con cáscara podría decir:

tail -f "$file" | grep "$string" | while read hit; do 
    #stuff 
done 

Answer 1

Bueno, la forma más sencilla sería leer constantemente desde el archivo, comprobar lo que es nuevo y prueba de golpes.

import time 

def watch(fn, words): 
    fp = open(fn, 'r') 
    while True: 
     new = fp.readline() 
     # Once all lines are read this just returns '' 
     # until the file changes and a new line appears 

     if new: 
      for word in words: 
       if word in new: 
        yield (word, new) 
     else: 
      time.sleep(0.5) 

fn = 'test.py' 
words = ['word'] 
for hit_word, hit_sentence in watch(fn, words): 
    print "Found %r in line: %r" % (hit_word, hit_sentence) 

Esta solución con readline obras si conoce sus datos aparecerán en las líneas.

Si los datos son algún tipo de flujo, necesita un búfer, más grande que el word más grande que está buscando, y llénelo primero. Se vuelve un poco más complicado de esa manera ...

Answer 2

Que yo sepa, no hay equivalente a "cola" en la lista de funciones de Python. La solución sería usar tell() (obtener tamaño de archivo) y read() para calcular las líneas finales.

¡Esta publicación del blog (no por mí) tiene la función escrita, me parece apropiada! http://www.manugarg.com/2007/04/real-tailing-in-python.html

Answer 3

Si no puede limitar el problema para trabajar con una lectura basada en línea, necesita recurrir a bloques.

Esto debería funcionar:

import sys 

needle = "needle" 

blocks = [] 

inf = sys.stdin 

if len(sys.argv) == 2: 
    inf = open(sys.argv[1]) 

while True: 
    block = inf.read() 
    blocks.append(block) 
    if len(blocks) >= 2: 
     data = "".join((blocks[-2], blocks[-1])) 
    else: 
     data = blocks[-1] 

    # attention, this needs to be changed if you are interested 
    # in *all* matches separately, not if there was any match ata all 
    if needle in data: 
     print "found" 
     blocks = [] 
    blocks[:-2] = [] 

    if block == "": 
     break 

El desafío consiste en garantizar que hacer coincidir la aguja incluso si está separada por dos bloques-límites.

Answer 4

EDITAR: como se indica en el comentario a continuación, O_NONBLOCK no funciona para los archivos en el disco. Esto todavía ayudará si alguien más busca datos de la cola procedentes de un socket o canalización con nombre u otro proceso, pero no responde la pregunta real que se le formuló al. La respuesta original permanece debajo para la posteridad. (Llamando a la cola y grep va a funcionar, pero es un no-respuesta de las clases de todos modos.)

abrir el archivo con O_NONBLOCK y utilizar select para sondear la disponibilidad de lectura y luego read para leer los nuevos datos y la cadena de métodos para filtrar líneas al final de un archivo ... o simplemente use el módulo subprocess y deje que tail y grep hagan el trabajo por usted como lo haría en el shell.

Answer 5

Puede usar collections.deque para implementar la cola.

De http://docs.python.org/library/collections.html#deque-recipes ...

def tail(filename, n=10): 
    'Return the last n lines of a file' 
    return deque(open(filename), n) 

Por supuesto, esto se lee el contenido del archivo entero, pero es una manera ordenada y concisa de la aplicación de la cola.

Answer 6

def tail(f): 
    f.seek(0, 2) 

    while True: 
     line = f.readline() 

     if not line: 
      time.sleep(0.1) 
      continue 

     yield line 

def process_matches(matchtext): 
    while True: 
     line = (yield) 
     if matchtext in line: 
      do_something_useful() # email alert, etc. 


list_of_matches = ['ERROR', 'CRITICAL'] 
matches = [process_matches(string_match) for string_match in list_of_matches]  

for m in matches: # prime matches 
    m.next() 

while True: 
    auditlog = tail(open(log_file_to_monitor)) 
    for line in auditlog: 
     for m in matches: 
      m.send(line) 

Utilizo esto para controlar los archivos de registro. En la implementación completa, guardo list_of_matches en un archivo de configuración para que pueda usarse con múltiples propósitos. En mi lista de mejoras es compatible con expresiones regulares en lugar de una simple coincidencia 'in'.

Answer 7

Puede usar seleccionar para sondear los nuevos contenidos en un archivo.

def tail(filename, bufsize = 1024): 
    fds = [ os.open(filename, os.O_RDONLY) ] 
    while True: 
     reads, _, _ = select.select(fds, [], []) 
     if 0 < len(reads): 
      yield os.read(reads[0], bufsize) 

Answer 8

Parece que hay un paquete para que: https://github.com/kasun/python-tail

Answer 9

puede utilizar pytailf: Simple pitón cola envoltorio -f

from tailf import tailf  

for line in tailf("myfile.log"): 
    print line 

Answer 10

Si sólo necesita una solución simple muerto Python 3 para el procesamiento las líneas de un archivo de texto tal como están escritas, y usted no necesita soporte de Windows, esto funcionó bien para mí:

import subprocess 
def tailf(filename): 
    #returns lines from a file, starting from the beginning 
    command = "tail -n +1 -F " + filename 
    p = subprocess.Popen(command.split(), stdout=subprocess.PIPE, universal_newlines=True) 
    for line in p.stdout: 
     yield line 
for line in tailf("logfile"): 
    #do stuff 

Bloquea la espera de que se escriban nuevas líneas, por lo que no es adecuado para uso asincrónico sin algunas modificaciones.