Rust: Running Terminal Commands
Zusammenfassung
Kurz
Der Artikel erklärt, wie Rust mit `Command` Systembefehle synchron oder über `spawn()` asynchron startet, Argumente und Umgebung setzt und Ausgaben oder Exit-Status abruft. Er betont, dass keine Shell-Syntax ausgewertet wird und dass gestartete Kindprozesse ausdrücklich abgewartet oder beendet werden müssen.
Mittel
Der Artikel zeigt anhand von `ls`, wie Rust mit `std::process::Command` Systembefehle startet. `output()` wartet auf den Kindprozess und sammelt `stdout` und `stderr`; `status()` liefert nur den Exit-Status. Standardmäßig übernimmt der Aufruf Arbeitsverzeichnis und Umgebung des Elternprozesses, während `output()` die Ausgabe in Pipes auffängt. Der Text weist auf mögliche Unterschiede bei der Programmsuche über `PATH` hin, darunter Einschränkungen unter Windows und Fälle, in denen ein vollständiger Programmpfad nötig ist.
Argumente werden einzeln mit `arg()` oder `args()` übergeben. Da keine Shell verwendet wird, haben Shell-Syntax wie Globs oder Variablenersetzung keine Wirkung. Arbeitsverzeichnis und Umgebung können gezielt geändert oder geleert werden. Für asynchrone Ausführung dient `spawn()`: `wait_with_output()` sammelt Ausgabe, `wait()` liefert nur den Status und `try_wait()` prüft nicht blockierend, ob der Prozess schon beendet ist. Einzelne Streams lassen sich über `take()` lesen. Der Artikel betont, dass ein gestarteter Kindprozess nicht automatisch endet, wenn sein `Child`-Handle verworfen wird; sein Ende muss abgewartet oder er mit `kill()` beendet werden.
Ausführlich lesen
Der Artikel erläutert, wie sich Betriebssystembefehle aus Rust mit `std::process::Command` starten und kontrollieren lassen. Als Beispiel dient `ls`; die beschriebenen Methoden gelten dem Text zufolge für Befehle, die als Kindprozess ausgeführt werden.
Für einen einfachen Aufruf wird der Programmname oder -pfad an `Command::new` übergeben und anschließend `output()` aufgerufen. Diese Methode wartet laut Artikel auf das Ende des Kindprozesses und sammelt dessen Ausgabe. Dabei werden `stdout` und `stderr` standardmäßig aufgezeichnet; `stdin` wird nicht vom Elternprozess übernommen, sodass ein Kindprozess, der Eingaben erwartet, unmittelbar ein geschlossenes Eingabestream vorfindet. Wer nur den Rückgabestatus benötigt, kann stattdessen `status()` verwenden. Ein einmal erzeugtes `Command`-Objekt lasse sich für mehrere Prozesse erneut verwenden.
Ohne weitere Einstellungen werden keine Argumente übergeben und das Arbeitsverzeichnis sowie die Umgebung des Elternprozesses übernommen. Bei einem Programmpfad ohne absoluten Pfad wird laut Artikel das betriebssystemabhängige `PATH` durchsucht; die Suche könne durch eine gesetzte `PATH`-Variable beeinflusst werden, allerdings mit Implementierungseinschränkungen unter Windows. Der Autor weist zudem anhand seiner Umgebung darauf hin, dass für manche Programme der vollständige Pfad nötig sein kann. In `Command::new` gehört nur der Programmpfad, nicht der Befehl samt Argumenten.
Argumente werden einzeln mit `arg()` oder als mehrere getrennte Elemente mit `args()` hinzugefügt. Da Rust sie direkt an das Programm übergibt und keine Shell dazwischengeschaltet wird, wirken Shell-Funktionen wie Wortaufteilung, Anführungszeichen, Glob-Muster, Variablenersetzung oder Escape-Auswertung laut Artikel nicht. Für ein anderes Arbeitsverzeichnis dient `current_dir()`; `get_current_dir()` gibt den gesetzten Pfad zurück und liefert `None`, wenn keiner gesetzt wurde. Auch ein gesetzter Pfad wird laut Text zurückgegeben, wenn er auf dasselbe Verzeichnis wie zuvor verweist. Umgebungsvariablen lassen sich mit `env()` oder `envs()` setzen, mit `env_remove()` einzeln entfernen oder mit `env_clear()` insgesamt leeren. Letzteres verhindert dem Artikel zufolge auch die Vererbung der Elternumgebung.
Für asynchrone Ausführung beschreibt der Artikel `spawn()`, das ein `Child`-Handle zurückgibt. Mit `Stdio::piped()` können Ausgabekanäle als Pipes eingerichtet und etwa mit `wait_with_output()` gesammelt werden. Diese Methode wartet auf das Prozessende und schließt laut Text ein vorhandenes `stdin` vor dem Warten, um ein gegenseitiges Blockieren zu vermeiden. `wait()` wartet ebenfalls, liefert aber nur den Status. `try_wait()` prüft nicht blockierend, ob ein Status bereits verfügbar ist: Das Ergebnis ist laut Artikel entweder ein Status, `None` bei noch laufendem Kindprozess oder ein Fehler. Anders als die beiden Wartemethoden schließt `try_wait()` `stdin` nicht. Über `take()` können einzelne Ausgabekanäle aus dem Handle entnommen und separat gelesen werden; anschließend ist der entnommene Kanal im späteren Ergebnis nicht mehr enthalten. Da laut Artikel beim `Child` kein `Drop`-Verhalten das Kind beendet, muss der aufrufende Code dessen Ende mit `wait()` oder `wait_with_output()` abwarten oder den Prozess mit `kill()` beenden.
Gegengeprüft von Claude Haiku 5.5: kleine Mängel
Es wurden keine Sammelfragen oder Teilfragen angegeben, daher ist die Einordnung leer. Die Zusammenfassung von Luna gibt den Bericht im Kern treu wieder und enthält keine erfundenen Angaben; es fehlen lediglich einige Detailpunkte zu Wiederverwendung und stdin-Verhalten.
Im Bericht, aber nicht in der Zusammenfassung
- Ein Command-Objekt kann mehrfach verwendet werden
- stdin wird bei output() nicht vererbt, und Lesevorgänge des Kindprozesses auf stdin schlagen sofort fehl
- Die Standardwerte für stdin, stdout und stderr bei spawn() und status() gegenüber output()
Wie die Modelle den Bericht einordnen
Ansicht
Filter
Kein Modell sieht bei diesem Bericht einen Bezug zu einer der 44 Sammelfragen.