Runtime exec y un editor RTF personalizado

Question

Tengo una clase que gestiona la creación de documentos RTF y un método en esa clase que llama al editor RTF con un archivo XML para mostrar.

Todos menos un usuario pueden acceder a este editor sin ningún problema. Este usuario se encuentra constantemente con un problema en el que su aplicación simplemente se bloquea. No hay errores en ningún registro. Normalmente este tipo de problema se identifica, reproduce y corrige fácilmente, sin embargo, no puedo reproducirlo durante toda la vida, por lo que mis intentos de depuración están fallando.

Básicamente, el código es el siguiente:

int exitVal = CUBSRTFEditor.runRTFEditor("c:\\tmp\\control"+ap_doc_id+".xml", xml,"I:\\AppealsLetters.exe /process \"c:\\tmp\\control"+ap_doc_id+".xml\"");

public static int runRTFEditor(String xmlLocation, String xmlContent, String executePath)
{
    int exitVal = 0;
    createLocalFile(xmlLocation, xmlContent);

    try
    {
        System.out.println("executePath must = "+executePath);
        Runtime rt = Runtime.getRuntime();
        Process proc = rt.exec(executePath);
        System.out.println("after executePath runs");

        //exhaust that stream before waiting for the process to exit
        InputStream inputstream = proc.getInputStream();
        InputStreamReader inputstreamreader = new InputStreamReader(inputstream);
        BufferedReader bufferedreader = new BufferedReader(inputstreamreader);
        // read the ls output
        String line;
        while ((line = bufferedreader.readLine())!= null)
        {
            System.out.println(line);
        }
        exitVal = proc.waitFor();
    }
    catch (Throwable t)
    {
        t.printStackTrace();
    }

    CUBSRTFEditor.deleteTempFile(xmlLocation);

    return exitVal;
}

La última salida es el primer System.out. Cuando tomo el archivo xml y lo ejecuto en cualquier otra PC, se ejecuta sin problemas. No veo información útil en proc.getErrorStream () o proc.getOutputStream ().

La documentación Javadoc del JDK sobre este problema (ejecución ejecutiva): Debido a que algunas plataformas nativas solo proporcionan un tamaño de búfer limitado para las secuencias de entrada y salida estándar, el hecho de no escribir rápidamente la secuencia de entrada o leer la secuencia de salida del subproceso puede causar que el subproceso se bloquee, e incluso un punto muerto.

Intento agotar esa secuencia antes de esperar a que salga el proceso y eso no parece ayudar ya que nunca parece llegar a ese punto (el segundo System.out no se muestra)

¿He implementado esto incorrectamente? ¿Me estoy perdiendo algo importante? Cualquier idea sobre cómo obtener más información del proceso sería genial.

Estoy atrapado ...

Answer 1

Runtime.exec () es un pequeño spud engañosamente desagradable para trabajar. Encontré este artículo (antiguo, pero sigue siendo relevante) para ser bastante útil. Siempre puede saltar a la página 4 para obtener un código de muestra altamente engorroso. :-)

De un vistazo, su código debe manejar tanto proc.getOutputStream () como proc.getErrorStream (), lo cual es una buena razón para manejar esas secuencias en subprocesos separados.

Answer 2

Quería actualizar esto porque el cambio entró en producción hoy y funcionó. Basado en las sugerencias de BlairHippo, lo hice funcionar con una clase interna anónima para crear un hilo separado para agotar las secuencias de Error y Entrada.

new Thread(new Runnable(){
    public void run()
    {
        try
        {
            BufferedReader br = new BufferedReader(new InputStreamReader(proc.getErrorStream()));
            String line;
            while ((line = br.readLine())!= null)
            {
                System.out.println(line);
            }
        }
        catch (Throwable t)
        {
            t.printStackTrace();
        }
    }
}).start();