Comment faire un "tail -f" en Java

**Grand sorcier** · 09/11/2006, 16h17

Bonjour,

Sous UNIX, la command "tail -f <fichier>" permet de voir les nouvelles lignes ajoutées au fichier en temps réel. Comment vous programmeriez l'équivalent en Java ?

**Alghero** · 09/11/2006, 17h08

Ta question n'est pas trop claire , mais je ponse que ce n'est pas fesable.
la console java en effet, te mis les derniere ligne de l'output donc a mon avis (Un tail -f)
ciao

**plegat** · 09/11/2006, 19h33

Envoyé par Alghero

Ta question n'est pas trop claire , mais je ponse que ce n'est pas fesable.
la console java en effet, te mis les derniere ligne de l'output donc a mon avis (Un tail -f)
ciao

Pas compris là....

Sinon, tu veux faire quoi exactement? Lancer la commande système, ou avoir un équivalent qui fait la même chose programmé en Java?

**Grand sorcier** · 10/11/2006, 13h13

Envoyé par plegat

Pas compris là....

Sinon, tu veux faire quoi exactement? Lancer la commande système, ou avoir un équivalent qui fait la même chose programmé en Java?

Je voulais avoir un équivalent de la meme chose mais programmé en Java...
Comme je pense que c'est lié à de la programmation bas niveau, je pense que ça doit être impossible à faire en Java.

Pourtant une socket ou un file descriptor d'un fichier c'est la meme chose. Et quand des données sont disponibles sur une socket, le InputStream contient une variable "available" à jour... Pourquoi cela ne marcherait pas sur les files descriptor de fichiers...

**adiGuba** · 10/11/2006, 13h34

Salut,

Envoyé par Grand sorcier

Comme je pense que c'est lié à de la programmation bas niveau, je pense que ça doit être impossible à faire en Java.

Ben c'est juste du traitement de fichiers via les I/O... Je ne vois pas pourquoi ce serait impossible à faire...

Envoyé par Grand sorcier

Pourtant une socket ou un file descriptor d'un fichier c'est la meme chose. Et quand des données sont disponibles sur une socket, le InputStream contient une variable "available" à jour... Pourquoi cela ne marcherait pas sur les files descriptor de fichiers...

Ben ca marche exactement pareil justement :

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
	public static void tailForEver(File file) throws IOException, InterruptedException {
 
		final Thread currentThread = Thread.currentThread();
		InputStream stream = new FileInputStream(file);
		try {
			byte[] buf = new byte[8192];
			int len;
			while (!currentThread.isInterrupted()) {
				len = stream.read(buf);
				if (len<=0) {
					// Si on a atteint la fin du fichier,
					// on fait une pause avant de recommencer à lire
					Thread.sleep(1000);
					continue;
				}
				System.out.write(buf, 0, len);
			}
		} finally {
			stream.close();
		}
 
	}

En tout ca sur mon poste cela fonctionne très bien...

a++

**Grand sorcier** · 10/11/2006, 14h14

Bravissimo merci !

**Grand sorcier** · 10/11/2006, 14h27

En fait j'utilise JMeter sous Windows. Il y a un fichier jmeter.log qui mets des resultats de mes tests en charge.

Mon problème est qu'il fallait que j'ouvre continuellement le fichier pour avoir les résultats. Mais avec ce code ma vie va s'améliorer

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
44
45
46
47
48
49
50
51
52
53
54
55
56
 
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.Thread;
import java.lang.InterruptedException;
 
public class Tail
{
	public static void main (String... args)
	throws
		IOException,
		InterruptedException
	{
		if (args.length == 0)
		{
			System.out.println ("Need a file name");
			System.exit (1);
		}
 
		File file = new File (args[0]);
		tailForEver (file);
		System.exit (0);
	}
 
	public static void tailForEver (File file)
	throws
		IOException,
		InterruptedException
	{
		final Thread currentThread = Thread.currentThread();
		InputStream stream = new FileInputStream (file);
		try
		{
			byte[] buf = new byte[8192];
			int len;
			while (!currentThread.isInterrupted ())
			{
				len = stream.read(buf);
				if (len<=0)
				{
					// Si on a atteint la fin du fichier,
					// on fait une pause avant de recommencer à lire
					Thread.sleep (1000);
					continue;
				}
				System.out.write (buf, 0, len);
			}
		}
		finally
		{
			stream.close();
		}
	}
}

Le seul souci qui reste c'est qu'avec "tail" on peut taper sur enter
pour mettre des lignes vides de séparation avec les nouveaux
flux qui vont arriver. Or dans mon code il n'y a pas cela...

**Grand sorcier** · 10/11/2006, 14h46

Les read() étant bloquant, j'utilise available() pour savoir s'il y a de choses à lire. De plus je peux maintenant mettre des lignes blanches comme avec le "tail -f" de UNIX.

Voici le code final qui me convient bien

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.Thread;
import java.lang.InterruptedException;
 
public class Tail
{
	public static void main (String... args)
	throws
		IOException,
		InterruptedException
	{
		if (args.length == 0)
		{
			System.out.println ("Need a file name");
			System.exit (1);
		}
 
		File file = new File (args[0]);
		tailForEver (file);
		System.exit (0);
	}
 
	public static void tailForEver (File file)
	throws
		IOException,
		InterruptedException
	{
		final Thread currentThread = Thread.currentThread();
		InputStream stream = new FileInputStream (file);
		try
		{
			byte[] buf = new byte[8192];
			byte[] input = new byte[128];
			int len;
			while (!currentThread.isInterrupted ())
			{
				len = System.in.available ();
				if (len > 0)
				{
					System.in.read (input);
					System.out.println ();
				}
 
				len = stream.available ();
				if (len > 0)
				{
					len = stream.read (buf);
					System.out.write (buf, 0, len);
				}
 
				Thread.sleep (100);
				continue;
			}
		}
		finally
		{
			stream.close();
		}
	}
}

**Grand sorcier** · 13/11/2006, 13h17

Allez un peu d'épuration du code

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.Thread;
import java.lang.InterruptedException;
 
public class Tail
{
	public static void main (String... args)
	throws
		IOException,
		InterruptedException
	{
		if (args.length == 0)
		{
			System.out.println ("Need a file name");
			System.exit (1);
		}
 
		File file = new File (args[0]);
		tailForEver (file);
		System.exit (0);
	}
 
	public static void tailForEver (File file)
	throws
		IOException,
		InterruptedException
	{
		InputStream stream = new FileInputStream (file);
		try
		{
			byte[] buf = new byte[8192];
			byte[] input = new byte[128];
			int len;
 
			while (true)
			{
				len = System.in.available ();
				if (len > 0)
				{
					System.in.read (input);
					System.out.println ();
				}
 
				len = stream.available ();
				if (len > 0)
				{
					len = stream.read (buf);
					System.out.write (buf, 0, len);
				}
 
				Thread.sleep (100);
				continue;
			}
		}
		finally
		{
			stream.close();
		}
	}
}

Comment faire un "tail -f" en Java

Entrée/Sortie Java

Discussions similaires

Partager

Partager