implémenter un tail -f Unix ?

Version imprimable

27/07/2007, 17h41
ramislebob

implémenter un tail -f Unix ?

Mon programme (proxy nntp) génère des fichiers logs (texte).
Vu la nature du soft, il n'a pas besoin d'interface graphique. Cependant, je suis supposé en faire une basique.
J'aimerai notamment implémenter un GUI avec un onglet de log qui afficherai en comme un tail -f les nouvelles lignes du fichier de log.
Avec les redirections et les InputStream sur un File, je ne pense pas qu'on puisse y arriver à cause du handler de fichier. dommage...
je peux rafraichir manuellement toutes les x secondes, mais il n'y aurait pas un moyen de gérer ça via un event ? un trigger sur la taille d'un fichier par ex ?
merci d'avance pour vos idées ;)
++
27/07/2007, 19h05
fabszn

Hello,

Peut-être en implantant un thread scrutant, effectivement, la taille du fichier.

Puis an utilisant le pattern Observer te permettant de raffraichir ton GUI.

C'est idée.. A voir maintenant les possibilités de réalisation.
27/07/2007, 20h09
ramislebob

merci pour ta réponse.
je ne trouve pas ça très élégant mais je ne vois pas trop d'autres idées.
maybe utiliser des pipes entre threads (PipedInputStream, PipedOutputStream, PipedReader et PipedWriter) mais je n'ai jamais utilisé ça pour l'instant et je ne pense pas qu'on puisse faire du pipe multicast (un producteur pour 2 consommateurs : fichier log et GUI)..
je verrai bien.
Je ne connais pas ton pattern Observer pour les rafraichissements, je regarderai ça. Pour l'instant je pensais utiliser une JTable avec AbstractTableModel, CellEditor, CellRenderer et Listener.
Si y a plus simple je suis preneur ;)

Salut,

Citation:

Envoyé par ramislebob

Avec les redirections et les InputStream sur un File, je ne pense pas qu'on puisse y arriver à cause du handler de fichier.

Et pourtant c'est amplement suffisant !

Il suffit de ne pas fermer le flux lorsqu'on atteint la fin, mais faire une boucle infini sur la lecture même s'il n'y a plus de données à lire. Dès que des données seront ajoutées dans le fichier elle seront lu par le programme...

On peut éventuellement utiliser available() pour savoir s'il y a des données.
Il faut bien sûr faire une pause entre deux essai afin d'éviter de faire une attente active.
Et éventuellement permettre une sortie propre de la boucle via les interruptions...

Ce qui donne vite fait bien fait pour un "tail -f" :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class Tail {
 
        public static void main(String[] args) throws IOException {
                System.out.println( args.length );
                if (args.length != 1) {
                        System.err.println("Nombre de paramètre incorrect !");
                        System.exit(1);
                }
 
                FileInputStream in = new FileInputStream(args[0]);
                try {
                        byte buf[] = new byte[8192];
                        int len;
 
                        /* On ne sort pas de la boucle, sauf en cas */
                        /* d'interruption du Thread via interrupt() */
                        while ( !Thread.interrupted() ) {
                                /* Tant qu'il y a des données à lire : */
                                while (in.available() > 0) {
                                        /* On lit les données : */
                                        len=in.read(buf);
                                        if (len>0) {
                                                /* Et on écrit les données : */
                                                System.out.write(buf, 0, len);
                                        }
                                }
 
                                /* Il n'y a plus rien à lire pour le moment */
                                /* On fait une pause avant de continuer afin */
                                /* d'éviter de faire une attente active : */
                                try {
                                        Thread.sleep(200);
                                } catch (InterruptedException ignored) {
                                        /* Interruption pendant le sleep() */
                                        /* -> on sort de la boucle */
                                        break;
                                }
                        }
                } finally {
                        in.close();
                }
        }
}

a++

27/07/2007, 22h30
ramislebob

rah... trop bien !
merci beaucoup ! :king:
je ne pensais pas qu'on puisse faire une boucle infinie... (j'ai meme pas essayé :s)
encore merci ;)