Haskell: Ejecutar comandos externos en secuencia estricta

Question

Si estoy en una situación en la que necesito ejecutar comandos externos en secuencia, ¿cuál es la mejor solución?

Por ejemplo, tengo dos comandos "make snapshot" y "backup snapshot" El segundo no puede comenzar hasta que se complete el primero. Si guardo ordenadamente esos dos comandos en una sintaxis do, ¿se ejecutarán uno después de otro o debo verificarlos manualmente y asegurarme de que el primero está completo?

Para la comprobación de la terminación manual, es suficiente con usar "sistema" o rawSystem" y examinar su código de salida?

No entiendo plenamente la diferencia entre el 'sistema' y 'funciones' runcommand. Puede alguien me aclara esto. Solo puedo ver que devuelven diferentes valores: código de salida vs proceso handle. ¿Alguna otra diferencia?

¿Prefiero usar "runCommand" para que la secuencia anterior funcione? espere en el mango del proceso?

Gracias.

Answer 1

Entiendo que está utilizando el módulo System.Process para ejecutar los comandos externos. Esto es bueno.

El módulo contiene acciones de E/S tanto de bloqueo como de no bloqueo. Los que no bloquean (como createProcess, runCommand) crean un proceso y devuelven su identificador de inmediato, mientras todavía se está ejecutando. Los bloqueadores (como readProcess, system) no devuelven ningún identificador, sino que devuelven el resultado de ejecutar el proceso una vez que termina.

Para asegurarse de que el proceso ha finalizado, debe usar acciones de bloqueo o usar waitForProcess, que bloquea hasta que el proceso con el controlador dado muere.

es lo suficiente como para usar "sistema" o rawSystem" y examinar su código de salida?

Sí.

la diferencia entre el "sistema" y "funciones runcommand"

La principal diferencia es system es el bloqueo, mientras que runCommand no lo es.

¿Prefiero usar "runCommand" para que funcione la secuencia anterior?

No, las llamadas de bloqueo deberían ser suficientes en su caso.

¿Debo llamar en espera al proceso de control?

Solo si decide utilizar llamadas no bloqueantes.

Ejemplo de uso:

import System.Process 
main = do 
    ExitSuccess <- system "make snapshot" 
    ExitSuccess <- system "backup snapshot" 
    return()