Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage Java Discussion :

implémenter un tail -f Unix ?


Sujet :

Langage Java

  1. #1
    Membre habitué
    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
    ++

  2. #2
    Membre expérimenté
    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.
    @+

    Fabszn
    Twitter : @fsznajderman

    N'oubliez pas le bouton
    Comment bien poser ses questions sur le forum


  3. #3
    Membre habitué
    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

  4. #4
    Expert éminent sénior
    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 :Sélectionner tout -Visualiser dans une fenêtre à part
    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++
    Cette signature n'a pas pu être affichée car elle comporte des erreurs.

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

###raw>template_hook.ano_emploi###