Cómo comprobar la existencia de un programa en el camino

Question

Estoy escribiendo un programa en el que llaman Scala:.

Runtime.getRuntime().exec("svn ...") 

Quiero comprobar si "SVN" está disponible desde la línea de comandos (es decir, es alcanzable en el camino). ¿Cómo puedo hacer esto?

PS: Mi programa está diseñado para ejecutarse en Windows

Answer 1

No soy un programador Scala, pero lo que haría en cualquier idioma, es ejecutar algo así como 'svn help' sólo para comprobar el código de retorno (0 o 1) del método exec ... si falla el sVN no está en el camino: P

Runtime rt = Runtime.getRuntime(); 
Process proc = rt.exec("svn help"); 
int exitVal = proc.exitValue(); 

Por convención, el valor 0 indica la terminación normal.

Answer 2

cuanto a la pregunta original que también haría el ingreso por la existencia como lo sugiere la FMF.

También me gustaría señalar que vas a tener que manejar al menos la salida del proceso, la lectura de los datos disponibles hasta las corrientes no se llenaron hasta arriba. Esto causaría que el proceso se bloquee, de lo contrario.

Para ello, recuperar los InputStreams del proceso utilizando proc.getInputStream() (por System.out) y proc.getErrorStream() (para System.err) y leer los datos disponibles en diferentes hilos.

te acabo de decir, porque esto es un error común y SVN potencialmente crear un poco de salida por lo que no Downvote para offtopicness;)

Answer 3

Si ha instalado cygwin se podría llamar primero ", que SVN ", que devolverá la ruta absoluta al svn si está en la ruta ejecutable, o de lo contrario 'que: no sVN (...)'. La llamada a "que" devolverá un exitValue de 1 si no lo encuentra, o 0 si se encuentra. Puede verificar este código de error de la manera en que FMF detalla.

Answer 4

Tal vez alguien estaría interesado en la solución de Java 8:

String exec = <executable name>; 
boolean existsInPath = Stream.of(System.getenv("PATH").split(Pattern.quote(File.pathSeparator))) 
     .map(Paths::get) 
     .anyMatch(path -> Files.exists(path.resolve(exec))); 

Por cierto, se puede reemplazar con anyMatch(...)filter(...).findFirst() - de manera que obtendrá la ruta ejecutable exacta.

Answer 5

selenio tiene lo que parece ser una aplicación bastante completa para Windows/Linux/Mac en la clase org.openqa.selenium.os.ExecutableFinder, con acceso desde public Selenio 3.1 (anteriormente sólo se puede acceder a través del método en desuso org.openqa.selenium.os.CommandLine#find). Sin embargo, es ASL 2.0.

Tenga en cuenta que ExecutableFinder no entiende PATHEXT en Windows - sólo tiene un conjunto codificado de extensiones de archivos ejecutables (.exe, .com, .bat).

Answer 6

este código usa el comando "where" en Windows, y el comando "which" en otros sistemas, para verificar si el sistema conoce el programa deseado en PATH. Si se encuentra, la función devuelve un java.nio.file.Path para el programa, y ​​null de lo contrario.

Lo probé con Java 8 en Windows 7 y Linux Mint 17.3.

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.nio.file.Path; 
import java.nio.file.Paths; 
import java.util.logging.Logger; 


public class SimulationUtils 
{ 
    private final static Logger LOGGER = Logger.getLogger(SimulationUtils.class.getName()); 

    public static Path lookForProgramInPath(String desiredProgram) { 
     ProcessBuilder pb = new ProcessBuilder(isWindows() ? "where" : "which", desiredProgram); 
     Path foundProgram = null; 
     try { 
      Process proc = pb.start(); 
      int errCode = proc.waitFor(); 
      if (errCode == 0) { 
       try (BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream()))) { 
        foundProgram = Paths.get(reader.readLine()); 
       } 
       LOGGER.info(desiredProgram + " has been found at : " + foundProgram); 
      } else { 
       LOGGER.warning(desiredProgram + " not in PATH"); 
      } 
     } catch (IOException | InterruptedException ex) { 
      LOGGER.warning("Something went wrong while searching for " + desiredProgram); 
     } 
     return foundProgram; 
    } 

    private static boolean isWindows() { 
     return System.getProperty("os.name").toLowerCase().contains("windows"); 
    } 
} 

Para usarlo:

System.out.println(SimulationUtils.lookForProgramInPath("notepad")); 

En mi sistema Windows 7, se muestra:

C: \ Windows \ System32 \ notepad.exe

Y en linux:

System.out.println(SimulationUtils.lookForProgramInPath("psql")); 

/usr/bin/psql

La ventaja de este método es que debería funcionar en cualquier plataforma y no hay necesidad de analizar la variable de entorno PATH o mirar en el registro. El programa deseado nunca se llama, incluso si se encuentra. Finalmente, no hay necesidad de saber la extensión del programa. gnuplot.exe bajo Windows y en Linux sería gnuplot tanto ser encontrado por el mismo código:

SimulationUtils.lookForProgramInPath("gnuplot") 

Las sugerencias para mejorar son bienvenidos!

Answer 7

En mi experiencia, es imposible saber sobre los distintos sistemas a través de simplemente llamar a un comando con el ProcessBuilder si sale o no (ni Exceptions ni devolver valores parecen coherentes)

Así que aquí es una solución Java7 que atraviesa la variable de entorno PATH y busca una herramienta de coincidencia. Verificará todos los archivos si el directorio. El matchesExecutable debe ser el nombre de la herramienta que ignora la extensión y el estuche.

public static File checkAndGetFromPATHEnvVar(final String matchesExecutable) { 
    String[] pathParts = System.getenv("PATH").split(File.pathSeparator); 
    for (String pathPart : pathParts) { 
     File pathFile = new File(pathPart); 

     if (pathFile.isFile() && pathFile.getName().toLowerCase().contains(matchesExecutable)) { 
      return pathFile; 
     } else if (pathFile.isDirectory()) { 
      File[] matchedFiles = pathFile.listFiles(new FileFilter() { 
       @Override 
       public boolean accept(File pathname) { 
        return FileUtil.getFileNameWithoutExtension(pathname).toLowerCase().equals(matchesExecutable); 
       } 
      }); 

      if (matchedFiles != null) { 
       for (File matchedFile : matchedFiles) { 
        if (FileUtil.canRunCmd(new String[]{matchedFile.getAbsolutePath()})) { 
         return matchedFile; 
        } 
       } 
      } 
     } 
    } 
    return null; 
} 

Éstos son el ayudante:

public static String getFileNameWithoutExtension(File file) { 
     String fileName = file.getName(); 
     int pos = fileName.lastIndexOf("."); 
     if (pos > 0) { 
      fileName = fileName.substring(0, pos); 
     } 
     return fileName; 
} 

public static boolean canRunCmd(String[] cmd) { 
     try { 
      ProcessBuilder pb = new ProcessBuilder(cmd); 
      pb.redirectErrorStream(true); 
      Process process = pb.start(); 
      try (BufferedReader inStreamReader = new BufferedReader(new InputStreamReader(process.getInputStream()))) { 
       while ((inStreamReader.readLine()) != null) { 
       } 
      } 
      process.waitFor(); 
     } catch (Exception e) { 
      return false; 
     } 
     return true; 
}