Bonjour,

Voilà je suis un fan de Transport Tycoon et je mets souvent un serveur à disposition chez moi. Le problème c'est qu'il tourne dans une console et c'est pas évident de l'administrer ! C'est pourquoi j'ai voulu développer une petite interface graphique pour celui-ci lors de mes après-midi de perdues ...

Jusque là tout va bien, dans un premier temps j'aimerais mettre en place la communication avec le servuer en créant une console ou je peux envoyer des commandes et récupérer leurs résultats via des streams.

Premièrement j'ai remarqué que les messages normaux s'envoyaient via le "errorStream" et les retours des commande via le stream normal. Le problème est que je peux envoyer des commandes, cela fonctionne mais le résultat de celles-ci s'affichent que lorsque j'arrête le serveur (j'envoie la commande exit).

J'ai regardé en vitesse la doc mais cela ne m'a pas beaucoup aidé ...

J'aimerais savoir si il est possible d'écouter en même temps indépendemment les deux streams ?

Normalement j'imagine que oui je vois pas trop ou est le problème, pourtant j'ai crée des threads ... Enfin peut-être que j'ai fai une erreure dans le code ... ??!! Mais d'après les message que j'ai mis pour débuger, celà à l'air de jouer....

Je sais que c'est pénible à regarder, y'à pas mal d'objets mais je mets quand même mon code à disposition, y'à toujours des motivés qui arrivent exécuter du code "de cerveau" et qui trouvent l'erreur ;-)

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
public class ServerManager{
 
	private String openTTDFolder;
	private ServerProcess serveurProcess;
	private InterfaceControleur controleur;
 
	/*
	 * Lance l'exécutable d'openTTD
	 */
	public void startServer(String commande) throws IOException{
		// Lance le processus
		serveurProcess = new ServerProcess(controleur);
		serveurProcess.startProcess(commande);
	}
 
        /*
	 * Envoie une commande vers le serveur.
	 */	
	public void sendCmd(String cmd) throws IOException{
		serveurProcess.sendCmd(cmd);
	}
        ... ... ... ... 
}
 
public class ServerProcess implements Runnable{
 
	private InterfaceControleur controleur;
	private Process serveurProcess;
	private ServerCmdInterpreter cmdInterpreter;
 
	public ServerProcess(InterfaceControleur controleur){
		this.controleur = controleur;		
	}
 
	/*
	 * Démarre le processus du serveur
	 */
	public void startProcess(String commande) throws IOException{
		serveurProcess = Runtime.getRuntime().exec(commande + " -D");
		// Lance le thread d'écoute
		Thread th = new Thread(this);
		th.start();
		// Lance l'interpreteur de commandes
		cmdInterpreter = new ServerCmdInterpreter(controleur,
				serveurProcess);
		cmdInterpreter.listen();
	}
 
	/*
	 * Ecoute les messages du serveur
	 */
	public void run(){
		try{
			BufferedReader reader = new BufferedReader(
					new InputStreamReader(
						serveurProcess.getErrorStream()));
			String message;
			while((message = reader.readLine()) != null) {
				controleur.messageFromServeur("process : " + message);			
			}
		}
		catch(IOException ioe){
			controleur.serverErrorOccured(ioe);
		}
		controleur.stopServeur();
		controleur.messageFromServeur("Server Stopped");		
	}
 
	/*
	 * Envoie une commande vers le serveur.
	 */	
	public void sendCmd(String cmd) throws IOException{
		cmdInterpreter.sendCmd(cmd);
	}
        ... ... ... ... 
}
 
public class ServerCmdInterpreter implements Runnable{
 
	private InterfaceControleur controleur;
	private Process serveurProcess;
	private PrintWriter printer;
 
	public ServerCmdInterpreter(InterfaceControleur controleur,
			Process serveurProcess){
		this.controleur = controleur;
		this.serveurProcess = serveurProcess;		
	}
 
	/*
	 * Démarre l'écoute
	 */
	public void listen(){
		Thread th = new Thread(this);
		th.start();
		printer = new PrintWriter(
				new PrintStream(
						serveurProcess.getOutputStream())); 
	}
 
	/*
	 * Ecoute en permanence les résultats d'une commande
	 */
	public void run(){
		BufferedReader reader = new BufferedReader(
				new InputStreamReader(
						serveurProcess.getInputStream()));		
		try{
			String message;
			System.out.println("Ecoute les resultats des commandes");
			while((message = reader.readLine()) != null){
				controleur.messageFromServeur("interpreter : " + message);
			}
		}
		catch (IOException ioe){
			controleur.serverErrorOccured(ioe);
		}
 
		System.out.println("End Interpreter");
	}
 
	/*
	 * Envoie une commande vers le serveur.
	 */	
	public void sendCmd(String cmd) throws IOException{
		System.out.println("Commande : " + cmd);
		printer.println(cmd);
		printer.flush();
	}
}
En démarrant mon application et en tapant ceci dans ma console "home made" :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
 
list_cmds
exit
Voici ce que j'ai dans la console java
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
Ecoute les resultats des commandes
Commande : list_cmds
Commande : exit
End Interpreter
et cela s'affiche en "direct", les threads on l'air d'être bien lancés, alors que le résultat de la commande "list_cmds" s'affiche dans ma console "home made" qu'après l'arrêt du serveur (commande exit terminée).

Ai-je été assez clair ? ... ?? .. ! Peut-être pas mais si vous répondez à la question en gras, peut-être que j'aurai un indice ...

Merci pour votre patience ;-)