Einführung
Hallo und herzlich Willkommen beim rsh Projekt. Das Ziel diese Projekts ist es, die Philosophie von Unix Shells, wo Pipes einfache Befehle miteinander verbinden, mit modernen Ansätzen zu verbinden.
Rsh ist von vielen Seiten beeinflusst: traditionelle Shells wie Bash, objektbasierte Shells wie PowerShell, funktionale Programmierung, Systems Programming und viele Weitere. Aber statt die eierlegende Wollmilchsau zu sein, liegt der Fokus von Rsh darauf, die angebotenen Funktionen gut zu beherrschen:
- Flexible cross-plattform Shell mit einem modernen Verhalten
- Ausgaben von Kommandozeilenprogrammen mit einer Shell zu verarbeiten, die Struktur von Daten versteht
- Ein Interface besitzen, das den modernen Bedürfnissen gerecht wird
Der einfachste Weg zu verstehen, was Rsh alles leisten kann, ist entlang von Beispielen. Los geht's!
Das Erste was auffällt, wenn ein Befehl wie
ls ausgeführt wird, ist, dass anstatt eines Blocks
von Text eine strukturierte Tabelle als Ausgabe erscheint.
> ls
╭────┬───────────────────────┬──────┬───────────┬─────────────╮
│ # │ name │ type │ size │ modified │
├────┼───────────────────────┼──────┼───────────┼─────────────┤
│ 0 │ 404.html │ file │ 429 B │ 3 days ago │
│ 1 │ CONTRIBUTING.md │ file │ 955 B │ 8 mins ago │
│ 2 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 4 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 5 │ README.md │ file │ 213 B │ 3 days ago │
...
Diese Tabelle ist mehr als nur eine andere Darstellungsform. Wie Tabellen in Spreadsheets erlaubt es diese Tabelle mit den Daten interaktiver zu arbeiten.
Um das zu demonstrieren, wird der Inhalt der Tabelle zunächst
nach der Größe sortiert. Um das zu realisieren, wird die Ausgabe
von ls genommen und in ein Befehl gegeben, der
Tabellen auf Basis von Daten in einer Spalte neu anordnen kann.
> ls | sort-by size | reverse
╭────┬───────────────────────┬──────┬───────────┬─────────────╮
│ # │ name │ type │ size │ modified │
├────┼───────────────────────┼──────┼───────────┼─────────────┤
│ 0 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 1 │ SUMMARY.md │ file │ 3.7 KiB │ 3 days ago │
│ 2 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 4 │ CONTRIBUTING.md │ file │ 955 B │ 9 mins ago │
│ 5 │ books.md │ file │ 687 B │ 3 days ago │
...
Um das Ganze zu realisieren, mussten hierzu nicht Argumente an
ls übergeben werden. Stattdessen wird der
sort-by Befehl verwendet, den Rsh bereitstellt, um
Daten zu sortieren. Damit die größten Dateien oben erscheinen
wurde zusätzlich die Option reverse angegeben.
Rsh stellt sehr viele Befehle bereit, die mit Tabellen arbeiten
können. Beispielsweise kann die Ausgabe von ls auch
derart gefiltert werden, dass nur Datei mit einer Größe von mehr
als einem Kilobyte angezeigt werden:
> ls | where size > 1kb
╭───┬───────────────────┬──────┬─────────┬────────────╮
│ # │ name │ type │ size │ modified │
├───┼───────────────────┼──────┼─────────┼────────────┤
│ 0 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 1 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 2 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ SUMMARY.md │ file │ 3.7 KiB │ 3 days ago │
╰───┴───────────────────┴──────┴─────────┴────────────╯
Wie in der Unix-Philosophie, erlauben Befehle, die untereinander Daten austauschen können, viele verschiedene Kombinationen um Aufgaben zu lösen. Wie in folgendem Beispiel:
> ps
╭─────┬───────┬───────┬──────────────────────────────────────────────┬─────────┬───────┬──────────┬──────────╮
│ # │ pid │ ppid │ name │ status │ cpu │ mem │ virtual │
├─────┼───────┼───────┼──────────────────────────────────────────────┼─────────┼───────┼──────────┼──────────┤
│ 0 │ 87194 │ 1 │ mdworker_shared │ Sleep │ 0.00 │ 25.9 MB │ 418.0 GB │
│ 1 │ 87183 │ 2314 │ Arc Helper (Renderer) │ Sleep │ 0.00 │ 59.9 MB │ 1.6 TB │
│ 2 │ 87182 │ 2314 │ Arc Helper (Renderer) │ Sleep │ 0.23 │ 224.3 MB │ 1.6 TB │
│ 3 │ 87156 │ 87105 │ Code Helper (Plugin) │ Sleep │ 0.00 │ 56.0 MB │ 457.4 GB │
...
Der ps Befehl erlaubt es auf Linux-Systemen alle
laufenden Prozesse, deren Status und Name abzufragen. Des
Weiteren gibt er Informationen zu CPU-Last der einzelnen
Prozesse an.
Was macht man, wenn man nur Prozesse sehen möchte, die aktuelle
aktiv die CPU nutzen? Wie zuvor beim ls Befehl,
kann mit der durch ps zurückgegebenen Tabelle
gearbeitet werden:
> ps | where cpu > 5
╭───┬───────┬───────┬─────────────────────────────────────────┬─────────┬───────┬──────────┬──────────╮
│ # │ pid │ ppid │ name │ status │ cpu │ mem │ virtual │
├───┼───────┼───────┼─────────────────────────────────────────┼─────────┼───────┼──────────┼──────────┤
│ 0 │ 86759 │ 86275 │ rsh │ Running │ 6.27 │ 38.7 MB │ 419.7 GB │
│ 1 │ 89134 │ 1 │ com.apple.Virtualization.VirtualMachine │ Running │ 23.92 │ 1.5 GB │ 427.3 GB │
│ 2 │ 70414 │ 1 │ VTDecoderXPCService │ Sleep │ 19.04 │ 17.5 MB │ 419.7 GB │
│ 3 │ 2334 │ 1 │ TrackpadExtension │ Sleep │ 7.47 │ 25.3 MB │ 418.8 GB │
│ 4 │ 1205 │ 1 │ iTerm2 │ Sleep │ 11.92 │ 657.2 MB │ 421.7 GB │
╰───┴───────┴───────┴─────────────────────────────────────────┴─────────┴───────┴──────────┴──────────╯
Bis jetzt wurden ls und ps genutzt, um
Dateien und Prozesse aufzulisten. Rsh besitzt aber noch viele
weitere Befehle die nützliche Informationen in Tabellenform
ausgeben. Dazu wird nun ein Block auf die Befehle
date und sys geworfen.
Wenn date now aufgerufen wird, werden Informationen
zum aktuellen Datum und der aktuellen Uhrzeit ausgegeben.
> date now
2022-03-07 14:14:51.684619600 -08:00
Um das Datum in Tabellenform zu bekommen, kann es zusätzlich in
date to-table gegeben werden:
> date now | date to-table
╭───┬──────┬───────┬─────┬──────┬────────┬────────┬──────────╮
│ # │ year │ month │ day │ hour │ minute │ second │ timezone │
├───┼──────┼───────┼─────┼──────┼────────┼────────┼──────────┤
│ 0 │ 2022 │ 3 │ 7 │ 14 │ 45 │ 3 │ -08:00 │
╰───┴──────┴───────┴─────┴──────┴────────┴────────┴──────────╯
Der Aufruf von sys gibt Informationen zum System
aus, auf dem Rsh läuft:
> sys
╭───────┬───────────────────╮
│ host │ {record 6 fields} │
│ cpu │ [table 4 rows] │
│ disks │ [table 3 rows] │
│ mem │ {record 4 fields} │
│ temp │ [table 1 row] │
│ net │ [table 4 rows] │
╰───────┴───────────────────╯
Diese Ausgabe unterscheidet sich nun von den vorherigen. Der
sys Befehl gibt eine Tabelle zurück, die selbst
strukturierte Tabellen in den Zellen enthält anstatt nur
einfache Werte. Um auf die Daten zuzugreifen, wird der
get Befehl verwendet:
> sys | get host
╭────────────────┬────────────────────────╮
│ name │ Debian GNU/Linux │
│ os version │ 11 │
│ kernel version │ 5.10.92-v8+ │
│ hostname │ lifeless │
│ uptime │ 19day 21hr 34min 45sec │
│ sessions │ [table 1 row] │
╰────────────────┴────────────────────────╯
Der get Befehl erlaubt es, in die Inhalte einer
Tabellenzelle einzutauchen. Hier wird beispielsweise die Spalte
"host" näher betrachtet, die Informationen über den
Host, auf dem Rsh läuft, enthält. Der Name des Betriebssystem
(OS), die CPU und mehr. Nun sollen die Namen der Nutzer auf dem
System ausgegeben werden:
> sys | get host.sessions.name
╭───┬────╮
│ 0 │ jt │
╰───┴────╯
Aktuelle existiert nur ein Nutzer namens "jt". Wie zu sehen ist, kann ein ganzer Pfad für Spalten angegeben werden - nicht nur der Name der Spalte. Rsh wird den Pfad nehmen und durch die entsprechenden Daten in der Tabelle gehen.
Und noch etwas anderes ist anders. Anstatt einer Tabelle mit Daten wurde nur ein einzelnes Element ausgegeben: der String "jt". Rsh arbeitet sowohl mit Tabellen voller Daten als auch mit Strings. Strings sind ein wichtiger Bestandteil, um mit Befehlen außerhalb von Rsh zu arbeiten.
Nun soll aufgezeigt werden, wie mit Strings außerhalb von Rsh
gearbeitet wird. Dazu wird das vorige Beispiel erweitert. Die
Daten werden an den externen echo Befehl
weitergegeben (das ^ teilt Rsh mit, dass nicht der
eingebaute echo Befehl verwendet werden soll):
> sys | get host.sessions.name | each { |it| ^echo $it }
jt
Das sieht jetzt genau gleich aus wie die Ausgabe zuvor. Was soll
das? Es ist ähnlich aber mit einem entscheidenden Unterschied:
^echo wurde aufgerufen. Das erlaubt es uns Daten
aus Rsh heraus an beliebige Befehle außerhalb von Rsh zu geben
wie echo oder git.
Hinweis: Hilfe zu allen in Rsh eingebauten Befehlen kann mit
dem Befehl help angezeigt werden:
> help path
Explore and manipulate paths.
There are three ways to represent a path:
* As a path literal, e.g., '/home/viking/spam.txt'
* As a structured path: a table with 'parent', 'stem', and 'extension' (and
* 'prefix' on Windows) columns. This format is produced by the 'path parse'
subcommand.
* As an inner list of path parts, e.g., '[[ / home viking spam.txt ]]'.
Splitting into parts is done by the `path split` command.
All subcommands accept all three variants as an input. Furthermore, the 'path
join' subcommand can be used to join the structured path or path parts back into
the path literal.
Usage:
> path
Subcommands:
path basename - Get the final component of a path
path dirname - Get the parent directory of a path
path exists - Check whether a path exists
path expand - Try to expand a path to its absolute form
path join - Join a structured path or a list of path parts.
path parse - Convert a path into structured data.
path relative-to - Get a path as relative to another path.
path split - Split a path into parts by a separator.
path type - Get the type of the object a path refers to (e.g., file, dir, symlink)
Flags:
-h, --help
Display this help message