Comment fonctionne le «scala.sys.process» de Scala 2.9?

Question

J'ai juste eu un coup d'oeil à la nouvelle - scala.sys et scala.sys.process forfaits pour voir si il y a quelque chose d'utile ici. Cependant, je suis à une perte complète.

Personne n'a eu un exemple sur la façon de démarrer un processus?

Et, ce qui est le plus intéressant pour moi: Pouvez-vous vous détacher de processus?

Un processus détaché de continuer à fonctionner lorsque le processus père se termine et est l'un des points faibles de l'Ant.

Mise à JOUR:

Il semble y avoir une certaine confusion à ce détacher. Avoir un vrai exemple de mon projet actuel. Une fois avec z-Shell et une fois avec TakeCommand:

Z-Shell:

if ! ztcp localhost 5554; then
    echo "[ZSH] Start emulator"
    emulator                        \
    -avd    Nexus-One               \
    -no-boot-anim                   \
    1>~/Library/Logs/${PROJECT_NAME}-${0:t:r}.out   \
    2>~/Library/Logs/${PROJECT_NAME}-${0:t:r}.err   &
    disown
else
    ztcp -c "${REPLY}"
fi;

Prenez-Commande:

IFF %@Connect[localhost 5554] lt 0 THEN
   ECHO [TCC] Start emulator
   DETACH emulator -avd Nexus-One -no-boot-anim
ENDIFF

Dans les deux cas, c'est le feu et oublier, l'émulateur est commencé et continuera à fonctionner même lorsque le script est terminé. Bien sûr, d'avoir à écrire les scripts deux fois, c'est un gaspillage. Donc, je regarde dans Scala maintenant pour unified process de manutention sans cygwin ou la syntaxe xml.

Answer 1

D'abord importer:

import scala.sys.process.Process

puis créer un ProcessBuilder

val pb = Process("""ipconfig.exe""")

Ensuite, vous avez deux options:

1. exécuter et bloquer jusqu'à ce que le processus s'arrête

   val exitCode = pb.!
   

2. lancer le processus en arrière-plan (détaché) et d'obtenir un Process exemple

   val p = pb.run
   

   Ensuite, vous pouvez obtenir le exitcode du processus (Si le processus est toujours en cours d'exécution, il bloque jusqu'à la sortie)

   val exitCode = p.exitValue
   

Si vous souhaitez gérer l'entrée et la sortie du processus, vous pouvez utiliser ProcessIO:

import scala.sys.process.ProcessIO
val pio = new ProcessIO(_ => (),
                        stdout => scala.io.Source.fromInputStream(stdout)
                          .getLines.foreach(println),
                        _ => ())
pb.run(pio)

Answer 2

Je suis sûr que les processus détachés fonctionnent parfaitement, étant donné que vous devez explicitement attendre sa sortie et que vous devez utiliser des threads pour surveiller les sorties standard et stderr. C'est assez basique, mais c'est ce que j'ai utilisé:

 /** Run a command, collecting the stdout, stderr and exit status */
def run(in: String): (List[String], List[String], Int) = {
  val qb = Process(in)
  var out = List[String]()
  var err = List[String]()

  val exit = qb ! ProcessLogger((s) => out ::= s, (s) => err ::= s)

  (out.reverse, err.reverse, exit)
}
 

Answer 3

Le processus a été importé de SBT. Voici un guide complet sur l'utilisation de la bibliothèque de processus telle qu'elle apparaît dans SBT .

https://github.com/harrah/xsbt/wiki/Process

Answer 4

Personne n'a eu un exemple sur la façon de en fait le début d'un processus?

import sys.process._ // Package object with implicits!
"ls"!

Et, ce qui est le plus intéressant pour moi: Pouvez vous détacher de processus?

"/path/to/script.sh".run()

La plupart de ce que vous allez faire est liée à l' sys.process.ProcessBuilder, le trait. Sais-tu que.

Il y a des implicites qui rendent l'utilisation de moins verbeux, et ils sont disponibles par le biais de l'objet de package sys.process. Importer son contenu, comme indiqué dans les exemples. Aussi, jetez un oeil à son scaladoc.

Answer 5

La fonction suivante permettra une utilisation facile s'il s'agit de documents:

 def #<<< (command: String) (hereDoc: String) =
{
    val process = Process (command)
    val io = new ProcessIO (
        in  => {in.write (hereDoc getBytes "UTF-8"); in.close},
        out => {scala.io.Source.fromInputStream(out).getLines.foreach(println)},
        err => {scala.io.Source.fromInputStream(err).getLines.foreach(println)})
    process run io
}
 

Malheureusement, je n’ai pas eu le temps de faire une opération infixe. La convention d’appel suggérée est donc:

 #<<< ("command") {"""
Here Document data
"""}
 

Ce serait call si quelqu'un pouvait me donner un indice sur la façon de rendre un shell plus semblable à call:

 "command" #<<< """
Here Document data
""" !