Newsgroup: it.comp.java
Titolo: waitFor() si pianta su una macchina Windows 2000

Salve a tutti,
come da oggetto ho un problema non di poco conto.
Nel mio applicativo devo lanciare un processo su una macchina Windows
2000 (che chiamo A).
Per fare questo mi creo un Process che mi deve lanciare un rsh su
un'altra macchina Windows 2003 (che chiamo B): tramite rsh infatti
eseguo
SERVER
-l
USERNAME
PATH_COMPLETO_DEL_COMANDO/
COMANDO_CON_PARAMETRO
PARAMETRO //è un file che viene scritto
(spero sia comprensibile).
Dopodichè nel codice ho
/*begin codice*/
Runtime rt = Runtime.getRuntime();
Process child = rt.exec(commands);
StreamGobbler errorGobbler = new StreamGobbler(child.getErrorStream(),
"ERROR");
StreamGobbler outputGobbler = new
StreamGobbler(child.getInputStream(), "OUTPUT");
errorGobbler.start();
outputGobbler.start();//ho output ed errore
int exitVal = child.waitFor();///SI PIANTA E NON RESTITUISCE NULLA
return exitVal;
/*end codice*/
E qua il problema: il waitFor() non restituisce nulla (è come se
rimane in append).
La cosa strana è che se lancio il tutto su un'altra macchina Windows
2000 (che chiamo C ed è speculare a B) funziona, in localhost
funziona: su B si pianat.
Il processo crea un file e lancia una procedura PL/SQL
Altri processi che leggono/scrivono il medesimo file non ci sono.
Io ho cercato in rete ma il waitFor() non ha comportamenti particolari
con alcuni sistemi operativi.
Ho visto che c'era un post precedente ma non mi pare faccia al caso
mio.
A parte l'ipotesi che le macchine non siano speculari e visto che sono
un newbie sull'argomento qualcuno mi può dare, se non una soluzione,
almeno qualche altra ipotesi prima di dire "il problema è sicuro della
configurazione della macchina"?
Grazie per ogni feed-back
Alessandro Puzielli

 rimane in append).
Questo è il comportamento normale di waitFor(). Attende finche il 
processo non termina, quando il processo termina restituisce l'exit code 
con cui il processo è terminato il processo.
Il tuo problema sta nel fatto che il processo non termina. Devi scoprire 
perché. Questi sono i casi piu' comuni:
  - il processo attende dell'input, per esempio se avvii passwd questo 
rimane appeso finché non gli scrivi la password e invio
  - il processo rimane in attesa perché nessuno consuma il suo standard 
output.
Il problema lo devi cercare nel comportamento del processo, non nella 
waitFor, sono sicuro che se, solo per esempio, al posto del processo che 
ti serve usi qualsiasi altro programma che non richiede input e non 
scrive output funziona.
-- 
Andrea Francia
alias rm='trash' #use trash command instead of removing
rm -Rfv file     #put the file in the KDE trashcan
http://www.andreafrancia.it/trash

 alepuziowrote:


 le macchine
No. Potrebbe essere che in un server il comando scrive abbastanza output 
da riempire il buffer e sull'altro no.
Molte volte crediamo che due computer siano uguali in tutto ma poi 
quando andiamo a vedere il problema scopriamo che non hanno esattamente 
la stessa configurazione. Anche perché è improbabile che due computer 
siano uguali in tutto. Magari ti può sembrare, poi scopri che in 
computer la variabile PATH è diversa oppure un programma su un computer 
è alla versione 3.0.1 e sull'altro alla 3.0.2. Non puoi partire dal 
presupposto che le configurazioni sono le stesse, i fatti ti dicono che 
è il contrario.


 alepuziowrote:

ok, quindi - se ho ben capito - tu dici che devo mettere nel processo
che lancio una istruzione return QUALCHE_VALORE in modo da forzare la
restituzione dell'exit, giusto?
Il processo per ora mi da l'output che è un file dopo l'esecuzione di
stored procedure: probabilmente è come se finisse di scrivere il file
ma non eseguisse il flush() e close() (mi riferisco a metodi Java per
capire il senso). Giusto?
grazie per la dritta sulla falsa uguaglianza di configurazione tra
server

 restituzione dell'exit, giusto?
No. Quello che devi fare è che il processo che avvii faccia le seguenti 
cose:
  - non richieda l'input dall'utente
  - termini prima o poi
Per farlo devi eseguire il comando a mano dalla shell.
Assicurati di avviare il comando dalla stessa working dir che usa Java e 
con gli stessi parametri.
Per essere sicuro di usare i parametri corretti metti un
	System.err.println("commands:" + commmands);
Appena prima di
	Process child = rt.exec(commands);
Altro dubbio: sei sicuro del funzionamento dei due StreamGobbler?
Se hai dei dubbi puoi usare il codice descritto qui che scarta tutto il 
quello letto dai due Stream:
http://www.andreafrancia.it/articoli/avviare-un-processo-in-java.html
Per curiosità qual'e' il processo che avvii, un programma che hai 
scritto tu o cos'altro?
-- 
Andrea Francia
http://www.andreafrancia.it/

 scritto tu o cos'altro?
il programma di un mio collega: esegue stored procedure in Oracle e
crea un file dal contenuto di una cartella.
In localhost il file è creato comunque, anche sul server incriminato,
per cui in effetti il programma restituisce un output.
In effetti il programma non è mio ma di altri colleghi che ora stanno
incasinati su questa cosa molto poco simpatica.
Penso che mi convenga leggere il tuo documento: grazie per i feed-back