Implementación de Java IO de Unix/Linux "tail-f"

file file-io

Question

Me pregunto qué técnicas y / o biblioteca usar para implementar la funcionalidad del comando de Linux "tail -f". Básicamente, estoy buscando un complemento de add-on / replacement para java.io.FileReader . El código del cliente podría verse más o menos así:

TailFileReader lft = new TailFileReader("application.log");
BufferedReader br = new BufferedReader(lft);
String line;
try {
  while (true) {
    line= br.readLine();
    // do something interesting with line
  }
} catch (IOException e) {
  // barf
}

La pieza faltante es una implementación razonable de TailFileReader . Debería poder leer partes del archivo que existen antes de que se abra el archivo, así como las líneas que se agregan.

Answer 1

Aquí hay una historia corta que puedes usar como un puntero:

He codificado TailingInputStream en el trabajo por la misma razón. Básicamente, utiliza File y actualiza sus contenidos según demanda y se compara con el búfer interno si ha cambiado significativamente (4 KB de memoria de sello IIRC) y luego hizo lo que hace el tail -f. Un poco hacky, sí, pero funciona perfectamente y no se mezcla con Threads o algo así de sofisticado; es compatible desde 1.426 al menos.

Dicho esto, fue mucho más fácil de hacer que ReverseInputStream, que pasó del final del archivo al inicio y no murió si el archivo se actualizó sobre la marcha ...

Answer 2

Compruebe JLogTailer , que hace esta lógica.

El punto principal en el código es:

public void run() {
    try {
        while (_running) {
            Thread.sleep(_updateInterval);
            long len = _file.length();
            if (len < _filePointer) {
                // Log must have been jibbled or deleted.
                this.appendMessage("Log file was reset. Restarting logging from start of file.");
                _filePointer = len;
            }
            else if (len > _filePointer) {
                // File must have had something added to it!
                RandomAccessFile raf = new RandomAccessFile(_file, "r");
                raf.seek(_filePointer);
                String line = null;
                while ((line = raf.readLine()) != null) {
                    this.appendLine(line);
                }
                _filePointer = raf.getFilePointer();
                raf.close();
            }
        }
    }
    catch (Exception e) {
        this.appendMessage("Fatal error reading log file, log tailing has stopped.");
    }
    // dispose();
}

Answer 3

Construí una implementación corta de "tail -f" en Scala hace un tiempo: tailf . También se ocupa de la rotación de archivos y puede definir su propia lógica qué hacer cuando llega a EOF o encuentra que el archivo ha sido renombrado.

Puedes echarle un vistazo y llevarlo a Java, ya que en realidad no hay nada complejo allí. Pocas notas: el archivo principal es Tail.scala y básicamente define Tail.scala que se encarga de EOF / rename y follow método, que envuelve a FollowingInputStream en una enumeración ilimitada en SequenceInputStream . Entonces, tan pronto como FollowingInputStream finaliza, SequenceInputStream solicita el siguiente elemento de una Enumeration y se crea otro FollowingInputStream .

Answer 4

Eche un vistazo a la implementación Apache Commons de la clase Tailer . Parece que también maneja la rotación de registros.

Answer 5

Encontré esta buena implementación de cola.

Autor: amelandri

Souce desde: https://gist.github.com/amelandri/1376896

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * Java implementation of the Unix tail command
 * 
 * @param args[0] File name
 * @param args[1] Update time (seconds). Optional. Default value is 1 second
 * 
 * @author Luigi Viggiano (original author) http://it.newinstance.it/2005/11/19/listening-changes-on-a-text-file-unix-tail-implementation-with-java/
 * @author Alessandro Melandri (modified by)
 * */
public class Tail {

  static long sleepTime = 1000;

  public static void main(String[] args) throws IOException {

    if (args.length > 0){

      if (args.length > 1)
        sleepTime = Long.parseLong(args[1]) * 1000;

      BufferedReader input = new BufferedReader(new FileReader(args[0]));
      String currentLine = null;

      while (true) {

        if ((currentLine = input.readLine()) != null) {
          System.out.println(currentLine);
          continue;
        }

        try {
          Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
          break;
        }

      }
      input.close();

    } else {
      System.out.println("Missing parameter!/nUsage: java JavaTail fileName [updateTime (Seconds. default to 1 second)]");
        }
      }

}

Answer 6

La capacidad de continuar leyendo un archivo y esperar hasta que el archivo tenga más actualizaciones no debería ser tan difícil de lograr en el código. Aquí hay un pseudo-código:

BufferedReader br = new BufferedReader(...);
String line;
while (keepReading) {
    line = reader.readLine();
    if (line == null) {
        //wait until there is more of the file for us to read
        Thread.sleep(1000);
    }
    else {
        //do something interesting with the line
    }
}

Supongo que le gustaría poner este tipo de funcionalidad en su propio subproceso, para que pueda dormir y no afectar a otras áreas de su aplicación. keepReading exponer keepReading en un setter para que su clase principal / otras partes de la aplicación puedan cerrar el hilo de forma segura sin ningún otro dolor de cabeza, simplemente llamando a stopReading() o algo similar.

Answer 7

Me encontré recientemente con rxjava-file , es una extensión de RxJava . A diferencia de las otras soluciones, esto hace uso del NIO de Java.

import rx.Observable;
import rx.functions.Action1;
import com.github.davidmoten.rx.FileObservable;

// ... class definition omitted

public void tailLogFile() throws InterruptedException {
    Observable<String> tailer = FileObservable.tailer()
                                .file("application.log") // absolute path
                                .tailText();

    tailer.subscribe(
        new Action1<String>() {
            @Override
            public void call(String line) {
                System.out.println("you got line: " + line);
            }
        },
        new Action1<Throwable>() {
            @Override
            public void call(Throwable e) {
                System.out.println("you got error: " + e);
                e.printStackTrace();
            }
        }
    );

// this solution operates threaded, so something  
// is required that prevents premature termination

    Thread.sleep(120000);
}

Answer 8

Si su código solo tendrá que ejecutarse en los sistemas Unix, podrá salirse con la suya y llamar a tail -f directamente.

Como una alternativa más complicada, podría echar un vistazo a la implementación de la cola y el puerto de GNU que se extienden a Java. (No estoy seguro de si esto ya no haría que tu código fuera un trabajo derivado, sin embargo).

Answer 9

Solo me enfrenté al mismo problema: encontré la implementación más simple aquí: Java Tail .

* Gran material * - listo para producción;)

Espero que la cita del código no deje caer una licencia.

    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;

    /**
     * Java implementation of the Unix tail command
     * 
     * @param args[0] File name
     * @param args[1] Update time (seconds). Optional. Default value is 1 second
     * 
     * @author Luigi Viggiano (original author) http://it.newinstance.it/2005/11/19/listening-changes-on-a-text-file-unix-tail-implementation-with-java/
     * @author Alessandro Melandri (modified by)
     * */
    public class Tail {

      static long sleepTime = 1000;

      public static void main(String[] args) throws IOException {

        if (args.length > 0){

          if (args.length > 1)
        sleepTime = Long.parseLong(args[1]) * 1000;

          BufferedReader input = new BufferedReader(new FileReader(args[0]));
          String currentLine = null;

          while (true) {

        if ((currentLine = input.readLine()) != null) {
          System.out.println(currentLine);
          continue;
        }

        try {
          Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
          break;
        }

          }
          input.close();

        } else {
          System.out.println("Missing parameter!/nUsage: java JavaTail fileName [updateTime (Seconds. default to 1 second)]");
        }
      }
    }