Evite detectar archivos incompletos al mirar un directorio para ver cambios en Java

Question

Estoy viendo un directorio para archivos entrantes (usando FileAlterationObserver desde Apache commons).

class Example implements FileAlterationListener { 
    public void prepare() { 
     File directory = new File("/tmp/incoming"); 
     FileAlterationObserver observer = new FileAlterationObserver(directory); 
     observer.addListener(this); 
     FileAlterationMonitor monitor = new FileAlterationMonitor(10); 
     monitor.addObserver(observer); 
     monitor.start(); 
     // ... 
    } 

    public void handleFile(File f) { 
     // FIXME: this should be called when the writes that 
     // created the file have completed, not before 
    } 

    public void onFileCreate(File f) { 
     handleFile(f); 
    } 

    public void onFileChange(File f) { 
     handleFile(f); 
    } 
} 

Los archivos están escritos en el lugar por procesos que no tengo control.

El problema que tengo con ese código es que mi devolución de llamada se desencadena cuando se crea el archivo inicialmente. Necesito que se active cuando se haya cambiado el archivo y se haya completado la escritura en el archivo. (tal vez al detectar cuando el archivo detuvo cambiando)

¿Cuál es la mejor manera de hacerlo?

Answer 1

No creo que pueda lograr lo que desea a menos que tenga algunas limitaciones y garantías del sistema de archivos. Por ejemplo, ¿qué pasaría si usted tiene el siguiente escenario:

• Archivo X creado
• Un montón de eventos de cambio se desencadenan que se corresponden con la escritura de archivos X
• Una gran cantidad de tiempo pasa sin cambios a archivo X
• El archivo X se ha actualizado.

Si el archivo X no puede ser actualizado después de que ha escrito a cabo, puede tener un hilo de ejecución que calcula el tiempo transcurrido desde la última actualización de ahora, y después de un cierto intervalo decide que el archivo de escritura es completa. Pero incluso esto tiene problemas. Si el sistema de archivos está bloqueado y la escritura no se produce durante un tiempo, puede concluir erróneamente que el archivo ha terminado de escribirse.

Answer 2

Puede verificar el tamaño del archivo 2 o más veces en un par de segundos y si el tamaño no cambia, puede decidir que el cambio de archivo se ha completado y proceder con su propia ejecución.

Answer 3

Tuve un problema similar. Al principio pensé que podría usar el servicio FileWatcher, pero no funciona en volúmenes remotos, y tuve que controlar los archivos entrantes a través de una unidad montada en la red.

Luego pensé que podría simplemente controlar el cambio en el tamaño del archivo durante un período de tiempo y considerar el archivo hecho una vez que el tamaño del archivo se haya estabilizado (como sugirió fmucar). Pero descubrí que, en algunos casos, en archivos grandes, el sistema de host informaría el tamaño completo del archivo que estaba copiando, en lugar de la cantidad de bytes que había escrito en el disco. Esto, por supuesto, hizo que el archivo pareciera estable, y mi detector captaría el archivo mientras todavía estaba en proceso de escritura.

Eventualmente logré que el monitor funcionara, mediante el uso de una excepción FileInputStream, que funcionó maravillosamente al detectar si se estaba escribiendo un archivo, incluso cuando el archivo estaba en una unidad montada en la red.

 long oldSize = 0L; 
     long newSize = 1L; 
     boolean fileIsOpen = true; 

     while((newSize > oldSize) || fileIsOpen){ 
      oldSize = this.thread_currentFile.length(); 
      try { 
      Thread.sleep(2000); 
      } catch (InterruptedException e) { 
      e.printStackTrace(); 
      } 
      newSize = this.thread_currentFile.length(); 

      try{ 
       new FileInputStream(this.thread_currentFile); 
       fileIsOpen = false; 
      }catch(Exception e){} 
     } 

     System.out.println("New file: " + this.thread_currentFile.toString()); 

Answer 4

Si utiliza FileAlterationListener y añadir un FileAlterationListenerAdaptor se puede poner en práctica los métodos que necesita y supervisar los archivos con un FileAlterationMonitor ...

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

    FileAlterationObserver fao = new FileAlterationObserver(dir); 
    final long interval = 500; 
    FileAlterationMonitor monitor = new FileAlterationMonitor(interval); 
    FileAlterationListener listener = new FileAlterationListenerAdaptor() { 

     @Override 
     public void onFileCreate(File file) { 
      try { 
       System.out.println("File created: " + file.getCanonicalPath()); 
      } catch(IOException e) { 
       e.printStackTrace(System.err); 
      } 
     } 

     @Override 
     public void onFileDelete(File file) { 
      try { 
       System.out.println("File removed: " + file.getCanonicalPath()); 
      } catch(IOException e) { 
       e.printStackTrace(System.err); 
      } 
     } 

     @Override 
     public void onFileChange(File file) { 
      try { 
       System.out.println(file.getName() + " changed: "); 
      } catch(Exception e) { 
       e.printStackTrace(); 
      } 
     } 
    }; 
    // Add listeners... 
    fao.addListener(listener); 
    monitor.addObserver(fao); 
    monitor.start(); 
} 

Answer 5

Una solución genérica a este problema parece imposible desde el " consumidor "fin. El "productor" puede cerrar temporalmente el archivo y luego volver a agregarlo. O el "productor" puede bloquearse, dejando un archivo incompleto en el sistema de archivos.

Un patrón razonable es hacer que el "productor" escriba en un archivo temporal que no está supervisado por el "consumidor". Cuando termine de escribir, cambie el nombre del archivo a algo que esté realmente monitoreado por el "consumidor", momento en el cual el "consumidor" recogerá el archivo completo.