[Process] recuperer entree et sortie d'un programme externe

Version imprimable

19/09/2005, 19h26
Gob4

[Process] recuperer entree et sortie d'un programme externe

bonjour,

je fais appelle au JDK's keytool dans mon programme avec:

Code:

Process proc = Runtime.getRuntime().exec("keytool -etc...");

Le probleme c'est que cet utilitaire demande de remplir des champs une fois lance.
J'aimerai donc recuperer l'entree et la sortie de ce programme pour les integrer dans mon IHM. Comment faire ?
19/09/2005, 19h40
adiGuba

Salut,

Tout est dans l'API de la classe Process...

a++
19/09/2005, 20h01
Gob4

Ok, donc si je comprend bien, la sortie de mon subProcess est reliee a ma sortie standard. mais je ne sais pas comment reliee cette sortie a un JTexteArea par exemple.
De plus, ca n'as pas l'air de marcher car lorsque je lance le subprocess je ne vois rien sur ma sortie standard.
20/09/2005, 09h55
jowo

Le plus simple est que tu nous montres ton code.

Ben en fait, je fais juste ca :

Code:

1
2
3
4
5
6
7
8
9
10
11
try {
   proc = Runtime.getRuntime().exec("C:\\j2sdk1.4.2_07\\bin\\keytool -genkey -alias alias -keyalg RSA -keypass password -keystore ./config/SampleKeystore");
   proc.waitFor();			
   proc.destroy();
} catch (IOException e1) {
   printError("secure error", e1 );
   throw new Exception();
} catch (InterruptedException e) {
   printError("secure error", e );
   throw new Exception();
}

Deja, si je pouvais recuperer la sortie du programme quelque part ca serait deja pas mal. Pour ecrire, je verrai plus tard.

20/09/2005, 18h17
adiGuba

Citation:

Envoyé par adiGuba

Tout est dans l'API de la classe Process...

As-tu regardé dans l'API ? La classe Process possèdent des méthodes pour accéder aux différents flux du processus : getInputStream(), getOutputStream() et getErrorStream().

a++
20/09/2005, 18h27
Gob4

Oui, merci j'ai bien vu ces trois methodes. Mais je ne comprend pas comment les utiliser.
Une fois que j'ai recupere mon inputStream et mon outputStream, je les branche ou ?
20/09/2005, 19h23
le y@m's

regarde tu coté des classes :
InputStreamReader
OutputStreamWriter
BufferedReader
BufferedWriter
PrintWriter
(le package java.io en somme)

Bon alors je fais ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Process proc = null;
try {
	proc = Runtime.getRuntime().exec("C:\\j2sdk1.4.2_07\\bin\\keytool -genkey -alias alias -keyalg RSA -keypass password -keystore ./config/SampleKeystore");
	BufferedInputStream in = new BufferedInputStream(proc.getInputStream());
	BufferedOutputStream out = new BufferedOutputStream(proc.getOutputStream());
	BufferedReader reader = new BufferedReader(new InputStreamReader(in));
	BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out));
 
	System.out.println(reader.readLine());
 
	proc.waitFor();			
	proc.destroy();
} catch (IOException e1) {
	printError("secure error", e1 );
	throw new Exception();
} catch (InterruptedException e) {
	printError("secure error", e );
	throw new Exception();
}

Mais le programme se bloc sur mon readLine() car je suppose qu'il ne trouve rien a lire. A mon avis, je m'emmelle les pedales avec les entrees qui passent sorties et vice-versa...

Quelques infos complementaires...

En fouillant un peu sur le forum, j'ai trouve un post de quelqu'un qui avait le probleme suivant :
Code:

1 2 3 4 5 6 Runtime envt = Runtime.getRuntime(); p = envt.exec("....fichier sql..."); p.getOutputStream().close(); p.waitFor(); p.getInputStream().close(); p.getErrorStream().close();
Lorsqu'il faisait ca, son programme ne se terminait jamais. Si j'ai bien compris, c'est parceque le waitFor() attendait la fin des entrees donc il s'en sortait pas.

J'ai donc essaye de faire ceci (juste pour voir) :
Code:

1 2 3 4 5 6 7 Process proc = Runtime.getRuntime().exec("keytool -genkey -alias merge -keyalg RSA -keypass password -keystore " + sampleKeystore); proc.getInputStream().close(); proc.getOutputStream().close(); proc.getErrorStream().close(); proc.waitFor();
Et effectivement, mon process ne se bloc plus dans le waitFor(). Mais vu que je ferme les flux, je vois mal comment il pourrait afficher quelque chose.

Le probleme c'est que je ne comprend pas bien comment fonctionne ces flux. Parceque ils m'empechent de ternminer convenablement mon process et je n'arrive pas a les lire. Alors qu'est ce que je dois en faire exactement ?

Il faut savoir qu'un subProcess doit être vu comme un thread. Donc il "tourne" presque indépendamment du thread qu'il a créé (créateur). Je dis presque car le subProcess est relié à son créateur par ses canaux standards d'entrée, de sortie et d'erreur. Ces canaux sont des tampons.

Le subProcess peut être bloqué en lisant son entrée (tampon vide) ou en écrivant dans les canaux de sortie (tampon plein). Ces tampons ont apparemment une petite taille.

On remarque qu'il est nécessaire que l'on fournisse des données au canal d'entrée et qu'on lit les canaux de sortie indépendamment l'une de l'autre. Pour arriver à ce but nous allons utiliser l'interface Thread.

Code:

1
2
3
4
5
 
     /* Il es préférable d'utiliser cette méthode pour passer les arguments.
         Le premier argument est le fichier à exécuter */
     String[] arguments = {"("C:\\j2sdk1.4.2_07\\bin\\keytool ", "-genkey ", "-alias alias ", "-keyalg RSA", "-keypass password", "-keystore ./config/SampleKeystore"};
     Process proc = Runtime.getRutime().exec(arguments);

Nous allons créer un thread qui lit la sortie standard des erreur du subProcess et l'écrit dans celle du créateur.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
    new Thread() {
        public void run() {
            try {
                BufferedInputStream errStream = 
                    new BufferedInputStream(proc.getErrorStream());
                byte[] buffer = new byte[128];
                int read;
 
                while ((read = errStream.read(buffer, 0, buffer.length)) != -1) {
                    System.err.write(buffer, 0, read);
                }
                errStream.close();
               }
               catch (IOException ioe) {
                  ioe.printStackTrace();
            }
        }
    }.start();

Le même principe pour la sortie standard

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
    new Thread() {
        public void run() {
            try {
                BufferedInputStream outStream = 
                    new BufferedInputStream(proc.getInputStream());
                byte[] buffer = new byte[128];
                int read;
 
                while ((read = outStream.read(buffer, 0, buffer.length)) != -1) {
                    System.out.write(buffer, 0, read);
                }
                outStream.close();
            }
            catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
    }.start();

De nouveau le même principe pour l'entrée. Il est nécessaire de lui fournir toutes le données sinon le suProcess va bloquer sur son entrée standard. C'est pour cette raison qu'il est préférable si possible de lui fournir les données via les arguments.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
    FileInputStream inpFile = new FileInputStream(new File("C:\\myData.txt"));
    final BufferedInputStream input = new BufferedInputStream(inpFile);
    new Thread() {
        public void run() {
            try {
                BufferedOutputStream inpStream = 
                    new BufferedOutputStream(proc.getOutputStream());
                byte[] buffer = new byte[256];
                int read;
 
                while ((read = input.read(buffer, 0, buffer.length)) != -1) {
                    inpStream.write(buffer, 0, read);
                }
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
    }.start();
 
    /* N'oublie pas de fermer input et inFile à la fin */

On attend que le subProcess termine et nous retourne son status code.

Code:

1
2
 
    int status = proc.waitFor();

L'appel à waitFor est bloquant alors je te conseille cette deuxième forme.

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
 
    Thread waitFor = new Thread() {
        public void run() {
            try {
                proc.waitFor();
            }
            catch(InterruptedException ie) {
                ie.printStackTrace();
            }
        }
    };
    waitFor.start();
 
    /* On attend jusqu'à 60 secondes que le subProcess se termine */
    int status = -1;
    try {
        waitFor.join(60000);
        status = process.exitValue();
    }
    catch (InterruptedException ie) {
        ie.printStackTrace();
    }
 
 
    input.close();
    inpFile.close();

Avant d'intégrer ce code dans ta IHM, je te conseille de le tester dans un sous-projet.

A toi d'améliorer certaines parties du code, principalement le traitement des exceptions.

Bon courage

22/09/2005, 18h18
Gob4

Wouha !

Merci beaucoup. C'est bien plus clair comme ca.
J'ai finalement pu eviter d'avoir a utiliser les entrees/sorties dans mon programme. Je n'ai pas le temps de tester ce code mais je pense que ca devrait marcher. Je le met dans un coin pour une prochaine fois.

Merci encore.