parametri a Runtime.getRuntime()

[Josten]

Salve a tutti!

ho l'esigenza di avviare un jar passando a

Runtime.getRuntime().exec(new String[]{"java","-jar",miofile.jar});

i parametri -debug e -nogui

se avvio il jar con questo

Runtime.getRuntime().exec(new String[]{"java","-jar",miofile.jar});

funziona perfettamente, se eseguo da terminale tutto ok
se provo a mettere anche solo ...{"java","-jar",miofile.jar,"-debug"} non funziona completamente..

ho provato anche col process builder ma invano...

mi potete aiutare? ho cercato come un pazzo ma niente di niente...
grazie a tutti in anticipo

[LeleFT]

Che vuol dire "non funziona completamente"?
Posta anche il codice corretto... tutte le righe di codice che hai postato sono errate, in quanto il nome del jar da avviare dev'essere racchiuso in una stringa, cosa che non hai fatto.


Ciao.

[Josten]

si scusa l'ho fatto per abbreviare ovviamente io li ho una variabile che prende l'intero percorso esistente del file... dico esistente poichè faccio una verifica e se non esiste "installo" i vari jar che mi servono

per completamente intendo che non da errori e si comporta come se il percorso fosse sbagliato.. viceversa se metto solo

Runtime.getRuntime().exec(new String[]{"java","-jar",installPathfile});

dove installPathfile è un percorso assoluto dell'utente seguito da +System.getProperty("file.separator")+"myapp.jar") ;

il programma si avvia correttamente ma senza i parametri

[LeleFT]

Vedendo i parametri che vuoi passare credo che tu ti aspetti qualcosa che accade, ma che non vedi accadere.

Perchè non ha alcun senso che l'applicazione non si avvii se aggiungi quei parametri (parlo per esperienza diretta, ho anche effettuato delle prove specifiche e garantisco che i parametri vengono correttamente passati).

Prova a verificare l'output del processo:

Process p = Runtime.getRuntime().exec(new String[]{"java","-jar",installPathfile, "-debug", "-nogui"});

InputStream is = p.getInputStream();
BufferedReader br = new BufferedReader( new InputStreamReader(is) );
String linea = null;
while((linea = br.readLine()) != null) {
   System.out.println( linea );
}

In questo modo catturi l'output del processo (quindi, qualunque eccezione eventualmente sollevata dal programma che stai avviando e a cui stai passando i parametri) e lo stampi nella console che ha avviato il main.


Ciao.

[Josten]

ciao, grazie del consiglio ma la cosa è più complicata.. per essere sicuro sul fatto che non "leggesse"i paramentri ho provato a cambiare il costruttore del metodo main chiamato con

public static void main(String[] args) {         
   ClientFrame f;                       
     if(args.length >0)        
      {
         if(args[0].equals("-debug")){            
            System.out.println(args[0]);            
             System.out.println("avvio modalita' debug"); 
           }                       
             else if(args[0].equals("-username"))            
                 f= new  ClientFrame(args[1]);                     
          }          
       else{            f= new ClientFrame();           }     
}

l'unica cosa che dovrebbe fare con il codice scritto qui sopra è solamente scrivere modalita' debug
invece avvia la gui, quindi utilizza il costruttore
ClientFrame() <------ ovvero quello senza paramentri
da qui nasce la mia complessità sul fatto che non legga i paramentri che gli do

[LeleFT]

Io ho effettuato questo test.

Il JAR da invocare (ClasseChiamata.jar) contiene solamente la seguente classe

package classechiamata;
import java.io.*;

public class ClasseChiamata {
   public static void main(String[] args) {
      FileWriter fw = null;
      PrintWriter pw = null;
      try {
         fw = new FileWriter("pippo.log");
         pw = new PrintWriter( fw );
         for(String s : args) {
            pw.println("Parametro: " + s);
         }
         pw.flush();
      } catch (Exception e) {
         e.printStackTrace();
      } finally {
         if (pw != null) {
            try { pw.close(); } catch (Exception e) { }
         } else {
            if (fw != null) {
               try { fw.close(); } catch (Exception e) { }
            }
         }
      }
   }
}

La classe che deve invocarlo, è così composta:

public class ClasseChiamante {
   public static void main(String[] args) throws Exception {
      Runtime.getRuntime().exec(
         new String[] {"java",
                            "-jar",
                            "ClasseChiamata.jar",
                            "-pippo",
                            "-pluto",
                            "-debug",
                            "-fd"}
      );
   }
}

Questo è il file generato dalla chiamata al programma "ClasseChiamante":

Parametro: -pippo
Parametro: -pluto
Parametro: -debug
Parametro: -fd

Quindi, il lavoro viene svolto correttamente e i parametri vengono passati tutti, in modo corretto e nell'ordine esatto in cui sono elencati.

Come già detto... prendi il Process generato dalla chiamata a exec(), ottieni l'InputStream e verifica cosa accade... può essere che venga sollevata un'eccezione, ma non la potrai mai vedere altrimenti.

Ciao.

[Josten]

ok.. il tuo esempio è stato chiarissimo (sicuramente lo utilizzerò per controllare il programma) tuttavia il mio output è esattamente quello del programma lanciato senza paramentri.. è questo che voglio capire..

sarà mica impazzito l'ide (?!)

io ho esplicitamente scritto che se il main viene lanciato con più di un paramentro non deve essere avviato il programma ma venga fatta solo una stampa di debug

quello che accade è invece: non entra nell'if (args.length > 0)

e avvia il ClientFrame() che sarebbe lo stesso metodo chiamato dal main quando viene esegito la prima volta.. ho usato il costrutto che mi hai postato (quello che stampa con il ciclo gli output e ho modifi
cato System.Out con System.err per vedere in rosso le scritte ed effettivamente è l'output del programma manciato senza parametri)

ho fatto questa prova

String[] args= new String[4];
args[0]="java";
args[1]="-jar";
args[2]=installPathfile;
args[3]="debug";

Process p = Runtime.getRuntime().exec(args);
... il resto di roba per stampare ...

e l'output anzichè essere semplicente

avvio modalità debug

è tutto il normale output del programma avviato da terminale


edit:

ho provato a dare sul terminale

java -jar /Users/josten/NetBeansProjects/ClientSide/store/myncraft.jar -debug

e il mio output è quello desiderato ovvero solo la scritta avvio modalità debug.. quindi il problema non non credo sia nel codice ma nella visibilità di quel maledetto jar..
sicuramente se creo una classe main di prova che avvia il mio progetto con i parametri voluti, sicuramente funziona..

ora il problema da capire è perchè sia sull'ide che come programma compilato i paramentri passati vengono ignorati?
Problemi di visibilità (?!?!)

[LeleFT]

L'IDE lavora con una sua configurazione, probabilmetne con un suo classpath, una sua working directory e non so cos'altro.

Io non uso MAI (sottolineato, in grassetto e corsivo) l'IDE per avviare i miei programmi. Li avvio sempre e solo come vanno avviati in produzione, ovvero a mano all'esterno. Se necessario, creo un ambiente ad hoc esterno all'IDE, ma mi metto sempre nella condizione di essere l'utente, quindi l'IDE mi serve solo per compilare.

Lo so, lo dico sempre, sono ripetitivo... ma a me i programmi funzionano sempre perchè non faccio fare nulla all'IDE che non sia la mera compilazione.

Non a caso, l'esempio che ho postato funziona senza alcun problema (tra l'altro, scritto tutto con il blocco note e compilato a mano).

Il mio consiglio è quello di provare ad avviare il programma fuori dall'IDE. E di perdere fin da subito l'abitudine a premere il pulsante RUN (maledicendo chi ha avuto l'orrenda idea di mettercelo), facendo sempre i soliti passi: compilazione, copia del prodotto compilato da un'altra parte, avvio del prodotto dal prompt/doppio clic FUORI dall'IDE.

Lo dico perchè stai perdendo un sacco di tempo cercando di far funzionare del codice che, da quel che posso intuire, è già corretto (a meno di altri dettagli trascurati).


Ciao.

[Josten]

già ... hai perfettamente ragione

cmq per adesso faccio un altro centinaio di prove... vi terrò informati se riesco a risolvere... sei stato veramente gentile grazie di tutto

ciauu

ora a noi dannato programma

[Josten]

ho risolto creando un altro jar separato con solo il client e la parte interessata da eseguire..
da oggi in poi andrò di esecuzione e compilazione su terminale :P

grazie davvero tanto ^^

un salutoo