Java IO реализация unix / linux "tail -f"

Question

Мне интересно, какие методы и / или библиотеку использовать для реализации функциональности команды linux "tail -f". По сути, я ищу падение в надстройку / замену для java.io.FileReader. Код клиента может выглядеть примерно так:

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
}

Отсутствующий фрагмент является разумной реализацией TailFileReader. Он должен быть в состоянии прочитать части файла, которые существуют до открытия файла, а также добавленные строки.

Answer 1

Взгляните на реализацию Apache Commons класса Tailer . Кажется, он также обрабатывает ротацию бревен.

Answer 2

Возможность продолжить чтение файла и подождать, пока в файле появятся еще какие-то обновления, для вас не должно быть так сложно выполнить код самостоятельно. Вот некоторый псевдокод:

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

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

Answer 3

Проверьте JLogTailer , который выполняет эту логику.

Основной пункт в коде:

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 4

Некоторое время назад я построил короткую реализацию "tail -f" в Scala: tailf . Он также заботится о ротации файлов, и вы можете определить свою собственную логику, что делать, когда он достигает EOF или обнаруживает, что файл был переименован.

Вы можете посмотреть и перенести его на Java, так как на самом деле там нет ничего сложного. Несколько замечаний: основной файл - Tail.scala и в основном он определяет FollowingInputStream, который заботится о EOF / переименовании и методе follow, который переносит FollowingInputStream в неограниченное перечисление в SequenceInputStream. Таким образом, как только FollowingInputStream заканчивается, SequenceInputStream запрашивает следующий элемент у Enumeration и создается еще один FollowingInputStream.

Answer 5

Я недавно наткнулся на rxjava-файл , это расширение RxJava . В отличие от других решений это использует Java NIO.

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 6

Я нашел эту хорошую реализацию хвоста.

Автор: amelandri

Соус из: 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 7

Просто столкнулся с той же проблемой - нашел здесь "простейшую" реализацию: Java Tail .

* Отличный материал * - готов к производству;)

Я надеюсь, что цитирование кода не приведет к потере лицензии.

    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 8

Если ваш код когда-либо будет работать только на Unix-системах, вам, возможно, удастся сойти с рук, просто выкинув и позвонив tail -f напрямую.

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

Answer 9

Вот небольшой рассказ, который вы можете использовать в качестве указателя:

Я кодировал TailingInputStream на работе по той же причине. Он в основном использует File и обновляет его содержимое по требованию и проверяет его по внутреннему буферу, если он значительно изменился (метка памяти 4KB IIRC), а затем сделал то, что делает tail -f. Немного хакерский, да, но он работает отлично и не связывается с Threads или чем-то подобным - он по крайней мере совместим с версией 1.4.2.

Тем не менее, это было намного проще, чем ReverseInputStream, который шел от конца файла к началу и не умирал, если файл обновлялся на лету ...