Discussion :

[Nalfeim]

Bonjour

J'ai un process "Slave" lancé via un runtime.exec() par mon application "Master". J'aimerai rediriger le slave.getErrorStream() sur (Master.)System.err

Après test, il est possible de faire un thread dédié à la réception puis au renvois des infos.
Ma question est donc jsute, est ce qu'il existe un moyen plus direct comme une fonction System.redirectToError(process.getErrorStream()) ou une classe du framework java chargé de ce boulot ?

[gifffftane]

Les applis java respectent les éventuelles redirections imposées par la ligne de commande.

(de toutes façons je crois qu'elles ne peuvent pas faire autrement).

Elles peuvent également rediriger à leur propre initiative leurs ports standards, par des méthodes de la classe System.

Par contre cette notion n'existe pas selon un thread ou autre ; elle existe uniquement par appli.

[Nalfeim]

Je connais les méthodes System.setIn / setOut / SetErr, mais je ne vois pas comment le process Slave pourrait avoir la visibilité nécessaire pour un appel genre

System.setErr ( Master.System.err )

Les applis java respectent les éventuelles redirections imposées par la ligne de commande.

Je ne suis pas sur d'avoir bien compris, tu fais référence à des paramètres passé via le Runtime ? Pourrais tu détailler s'il te plait ?

[gifffftane]

Si le processus Slave n'a pas la visibilité sur les flux standards, le processus lanceur peut l'avoir. Tout cela dépend de ton appli. Regarde tout ce qui tourne autour du ProcessBuilder. Il te permet, par un jeu de paramètres, d'orienter les flux de l'appli que tu veux lancer.

Concernant les redirections par la ligne de commande, chose que tu pourrais (qu'il faudra ? ) utiliser dans ton exec il s'agit d'une capacité à orienter les flux standards par ce biais.

C'est très dépendant de ton système d'exploitation, mais la notion existe sur tous, ou quasi.

En shell unix, par exemple, si je fais la commande ls (liste des fichiers), je la vois apparaître sur la console, tandis que si je fais ls > truc.txt, alors la liste n'apparaitra pas sur la console, mais sera imprimée dans un nouveau fichier nommé truc.txt : le signe > exprime une redirection du port de sortie standard. Ce truc est utilisable depuis java, à condition de bien connaître unix... et d'être en environnement unix bien sûr.

Tout cela est dépendant de ton système d'exploitation, aussi cela serait plus facile si tu nous disais lequel est-il ?

[Nalfeim]

Ok. L'OS actuel est windows mais je préfère éviter d'inclure des fonctionnalités qui porterait atteinte à l'interropérabilité java, ça pourrait servir.
Côté ProcessBuilder / Runtime / Pipe système, mon boulot n'a pas trop le temps à y consacrer mais le programmeur regardera peut être tout cela sur son temps libre. Voeux pieux


Concrètement, j'ai contourné le problème en assignant le p'tit thread que voici au boulot de perroquet :

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
/******************** ATTRIBUTES ********************/
 
	private InputStream input;
	private OutputStream output;
	private String mark;
	private static final Logger logger = Logger.getLogger(StreamRelay.class);
 
 
 
	/******************** CONSTRUCTORS ********************/
 
	/**
         * @param input Stream to be redirected
         * @param output Destination of the redirection
         * @param mark To be added before each line redirected
         */
	public StreamRelay(InputStream input, OutputStream output, String mark) {
		this.input = input;
		this.output = output;
		this.mark = mark;
		start();
	}
 
	/**
         * @param input Stream to be redirected
         * @param output Destination of the redirection
         */
	public StreamRelay(InputStream input, OutputStream output) {
		this(input, output, "");
	}
 
 
 
	/******************** FUNCTIONS ********************/
 
	public void run() {
		logger.trace("StreamRelay start.");
		String line = null;
		BufferedReader reader = new BufferedReader(new InputStreamReader(input));
		BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(output));
		try {
			while (((line = reader.readLine()) != null)) {
				line = mark + line;
				writer.write(line);
				writer.newLine();
				writer.flush();
			}
		} catch (IOException e) {
			logger.error("StreamRelay broken ! " + e.getMessage());
		}
 
	}

Ca a notamment l'avantage de pouvoir un peu reformater le flux d'erreur des processus ainsi écouté pour les distinguer du flux natif. En l'occurence je me contente de rajouter un marqueur, genre une tabulation, au début de chaque ligne et c'est direct plus clair.

Voilà, on peut dire problème résolu. Merci