Pipe (Informatik)
Eine Pipe oder Pipeline (englisch Rohrleitung) ist ein Datenstrom zwischen zwei Prozessen durch einen Puffer mit dem Prinzip First In - First Out (FIFO). Das bedeutet vereinfacht, dass ein Ergebnis eines Computerprogramms als Eingabe eines weiteren Programms verwendet wird. Pipes wurden 1973 von Douglas McIlroy fur das Betriebssystem Unix erfunden.
Funktionsweise anhand eines Beispiels
[Bearbeiten | Quelltext bearbeiten]Das folgende Beispiel soll die Funktion einer Pipe erlautern:
ls -R ./Bilder | grep -ic '\.jpg$'Im Beispiel sind die zwei kleinen Programme ls und grep uber eine Pipe (Symbol |) verbunden. Entsprechend der Unix-Philosophie sind beides Programme, die eine einzelne Aufgabe erledigen, auf Textstromen basieren und zusammen arbeiten konnen.
- das Programm ls dient dazu, den Inhalt von Dateipfaden in Textform zu listen
- grep ist ein Programm, das Texte nach Zeichenketten durchsuchen kann
Im Beispiel wird ls angewiesen, das Verzeichnis Bilder einschliesslich der Unterverzeichnisse (Schalter R) zu listen. Das Ergebnis (einen Text) schickt ls in eine Pipe.
In der Pipe nimmt das Programm grep den Text in Empfang. Es wird angewiesen, den Text nach der Zeichenkette .jpg zu durchsuchen (der Punkt von ,,.jpg" wird mit einem Backslash maskiert, weil er fur grep zwei Bedeutungen hat). Dem Programm grep wurden noch die Schalter i und c mitgegeben. i bewirkt, dass bei der Zeichenkette Gross- und Kleinbuchstaben gleich behandelt werden (es wird also auch ,,JPG" gefunden); der Schalter c weist grep an, nicht die Fundstellen zu listen, sondern deren Anzahl auszugeben.
Das Ergebnis der Pipe ist also die Anzahl der JPG-Bilder unterhalb des Verzeichnisses ./Bilder.
Auf den ersten Blick erscheint es einfacher, wenn man das Programm ls mit mehr Funktionalitat ausstattet, um die umstandliche Schreibweise der Pipe zu umgehen (wie der Befehl dir bei DOS und dessen Nachfolger). Anhanger der Unix-Philosophie betonen aber, dass das Aufteilen eines grosseren Problems in Teilprobleme fur entsprechend spezialisierte Programme effektiver sei.
Erzeugen einer Pipe
[Bearbeiten | Quelltext bearbeiten]Unter den meisten Betriebssystemen und Programmiersprachen werden nach Anforderung einer Pipe durch den Systemaufruf pipe() vom Betriebssystem zwei Zugriffskennungen (engl.: handles) zuruckgeliefert, die zum Schreiben in die bzw. Lesen aus der Pipe benotigt werden. Auch Kindprozesse erben den Zugriff auf diese handles. Mit der Beendigung des letzten Prozesses, der Zugriff auf eine aktive Pipe hat, wird diese vom Betriebssystem beendet.
Pipe-Varianten
[Bearbeiten | Quelltext bearbeiten]Es gibt anonyme und benannte Pipes.
Anonyme Pipes unterliegen drei erheblichen Einschrankungen:
- Sie konnen nur in eine Richtung verwendet werden: ein Prozess schreibt, der andere liest.
- Sie konnen nur fur die Kommunikation zwischen eng verwandten Prozessen benutzt werden.
- Die maximale Datenmenge, die eine Pipe enthalten kann, ist relativ klein.
Benannte Pipes (Named Pipes) konnen dagegen auch zur Kommunikation zwischen Prozessen eingesetzt werden, die nicht miteinander verwandt sind und sich daruber hinaus auf unterschiedlichen Rechnern innerhalb eines Netzwerkes befinden durfen. Sie sind flexibler als anonyme Pipes und eignen sich fur sogenannte Client-Server-Anwendungen (es lassen sich auch RPCs realisieren). Benannte Pipes ermoglichen die gleichzeitige Kommunikation in beide Richtungen, das heisst, Daten konnen im Vollduplexbetrieb zwischen den Prozessen ausgetauscht werden.
Jeder Prozess, der den Namen einer benannten Pipe kennt, kann uber diesen Namen die Verbindung zur Pipe und damit zu anderen Prozessen herstellen.
Pipes in Betriebssystemen
[Bearbeiten | Quelltext bearbeiten]Pipes sind in verschiedenen Betriebssystemen realisiert, die meisten bieten sowohl anonyme als auch benannte Pipes.
Unix
[Bearbeiten | Quelltext bearbeiten]Anonyme Pipes
Pipes sind unter Unix und unixoiden Betriebssystemen eines der machtigsten Werkzeuge, um die sequentielle Abarbeitung von Befehlen auf einem bestimmten Datenbestand zu ermoglichen.
Bei einer anonymen Pipe ist die Kommunikation dabei auf mehrere Prozesse gleichen Ursprungs beschrankt. Diese (Ursprungs-)Beziehung entsteht meistens durch Forks. In der Shell wird eine anonyme Pipe zum Startzeitpunkt der Programme durch Eingabe eines ,,|"-Zeichens erzeugt. Die Shell ist dann der (gemeinsame) Elternprozess aller Prozesse und erledigt die Forks automatisch.
Beispiel:
grep '.sshd.*Invalid user' /var/log/messages | awk '{print $NF}' | sort -uHier wird die System-Logdatei nach dem Suchbegriff ,,sshd" durchsucht, dem in derselben Zeile der Text ,,Invalid user" folgt. Anschliessend wird das letzte Feld aus der Meldung herausgeschnitten (,,awk ..."), das hier die IP-Adresse des Rechners enthalt, von dem aus der ssh-Zugriff ausging. Zum Schluss werden diese IP-Adressen so sortiert, dass sie nicht mehrfach auftreten (,,sort --unique").
Die an einer solchen Pipe beteiligten Programme nehmen (bis auf das erste) Eingabedaten von ihrer Standardeingabe entgegen und stellen (bis auf das letzte) Ausgabedaten auf ihrer Standardausgabe bereit, siehe auch Filter (Software). Verlangt eine Anwendung die Angabe von Dateinamen fur die Ein- oder Ausgabe, so kann man oft durch die Angabe eines Minuszeichens als Dateiname erreichen, dass auf die Standardausgabe geschrieben bzw. von der Standardeingabe gelesen wird. Wenn sie diese Konvention implementiert haben, ist so das Schreiben in bzw. das Lesen aus einer Pipe auch mit solchen Anwendungen realisierbar.
Beispiel:
tar cf - /home/user/ogg/mycolouringbook | ssh -l user server "cd /var/ogg && tar xvf -"Hier wird der Inhalt eines Verzeichnisses mit tar zu einem Archiv zusammengepackt, uber eine SSH-Verbindung zu einem anderen Rechner verschickt und dort entpackt.
Named Pipe
Eine Named Pipe, auch FIFO (von first-in-first-out) genannt, ist eine Pipe, die von zwei Prozessen zur Laufzeit uber einen Dateinamen zum Lesen oder Schreiben geoffnet werden kann. Bei einer Named Pipe mussen die Prozesse keinen gemeinsamen Ursprung haben, die Prozesse mussen lediglich zum Zugriff auf die Pipe autorisiert sein und den Namen der Pipe kennen.
Beispiel:
mkfifo einefifocat /var/log/messages > einefifo &
grep sshd < einefifo
FIFOs uberdauern die sie verwendenden Prozesse, weil sie Bestandteil des Dateisystems sind. Allerdings kann eine FIFO keinen Inhalt haben, solange sie von keinem Prozess geoffnet ist. Das bedeutet, dass der gepufferte Inhalt verloren geht, wenn ein schreibender Prozess sein Ende der Pipe schliesst, ohne dass ein lesender Prozess das andere Ende geoffnet hat.
Verwendung einer unidirektionalen Unix-Pipe
Dieser Sourcecode bewirkt das gleiche wie die Shellanweisung who | sort
#include
#include
#include
int main(void){
// pipe_verbindung[0] zum Lesen und pipe_verbindung[1] zum Schreiben
int pipe_verbindung[2];
//Initialisierung durch die Funktion Pipe
pipe(pipe_verbindung);
//Kindprozess erzeugen
if (fork()==0){
// dup2 verbindet den Filedeskriptor der Pipe mit dem Filedeskriptor der Standardausgabe
dup2(pipe_verbindung[1],1);
// der Leseausgang muss geschlossen werden, da dieser Prozess nichts liest
close(pipe_verbindung[0]);
// Kommando ausfuhren, Standardausgabe des Kommandos ist mit der Pipe verbunden
execlp("who","who",NULL);
}
// dann zweiten Kindprozess erzeugen
else if (fork()==0){
dup2(pipe_verbindung[0],0);
close(pipe_verbindung[1]);
execlp("sort","sort",NULL);
}
}
Der schreibende Prozess (Prozess 1) hat zunachst auch lesenden Zugriff auf die Pipe (unidirektional). Deshalb muss er seinen Filedeskriptor(0) zum Lesen sperren. Genauso hat der lesende Prozess (Prozess 2) zunachst schreibenden Zugriff auf die Pipe. Deshalb muss er seinen Filedeskriptor(1) zum Schreiben sperren. Werden die nicht benotigten Deskriptoren nicht gesperrt, kommt es zu Komplikationen: Wenn zum Beispiel Prozess 1 keine Daten mehr zu versenden hat, terminiert er. Allerdings wird Prozess 2 nicht terminieren, da noch ein Filedeskriptor(1) zum Schreiben (sein eigener) fur weitere Eingaben auf die Pipe gesetzt ist. Er wartet, aber es kommen keine Daten. Ein anderes denkbares Szenario ist, dass Prozess 1 nicht terminieren kann, weil er Lesezugriff auf die Pipe hat und fur immer und ewig auf Daten des Gegenspielers wartet, aber niemals welche ankommen werden, da er erstens schon langst terminiert ist und zweitens auch niemals welche gesendet hat.
Windows
[Bearbeiten | Quelltext bearbeiten]Windows kennt anonyme und benannte Pipes. Benannte Pipes lassen sich uber das Pipe-API analog zu den SMB-Freigaben als \\ServerName\pipe\PipeName ansprechen.
Anonyme Pipes sind in der Windows-Eingabeaufforderung moglich, um z. B. mit dem find-Befehl in der Ausgabe eines dir-Befehls nur die Ausgaben zu erhalten, die bestimmte Zeichenketten im Pfad oder Dateinamen enthalten (was durch die dir-Syntax nicht immer vollstandig abgedeckt ist): So gibt folgende Befehlseingabe alle Unterverzeichnisse mit enthaltenen .java Dateien aus, in denen im Pfad das Wort Render enthalten ist, sowie die .java Dateien selbst, in dessen Dateiname Render enthalten ist:
OS/2
[Bearbeiten | Quelltext bearbeiten]OS/2 kennt anonyme und benannte Pipes. Benannte Pipes gehoren zu den leistungsfahigsten IPC-Methoden, die OS/2 zu bieten hat. Wenn ein Server-Prozess eine benannte Pipe erzeugt, so kann er mehrere Instanzen dieser Pipe generieren, die alle unter demselben Namen angesprochen werden: Eine named pipe kann auch im Multiplexbetrieb arbeiten, so dass ein einzelner Server-Prozess mehrere Clients gleichzeitig bedienen kann.
Verwendung einer unnamed Pipe (anonyme Pipe) in C
[Bearbeiten | Quelltext bearbeiten]Das Programm liest eine Benutzereingabe ein und nutzt dann eine Pipe, um die Daten einem Kindprozess mitzuteilen. Dieser wandelt alle Eingaben in Grossbuchstaben (toupper) um und gibt diese aus.
#include
#include
#include
#include
#include
#include
// Die maximale Laenge der Eingabe wird auf 2048 Bytes festgelegt.
#define MAX_ZEICHEN 2048
int main(void) {
int fd[2], n, i;
pid_t pid;
char zeile[MAX_ZEICHEN];
// Wir erstellen die Pipe. Tritt dabei ein Fehler auf, gibt die
// Funktion -1 zurueck, so dass wir schon hier moegliche Fehler
// abfangen und behandeln koennen.
if (pipe(fd) < 0)
fprintf(stderr, "Fehler beim Erstellen der pipe()");
// Ein Kindprozess wird erstellt.
if ((pid = fork()) > 0) {
// Im Elternprozess
close(fd[0]);
fprintf(stdout, "Eltern : ");
fgets(zeile, MAX_ZEICHEN, stdin);
write(fd[1], zeile, strlen(zeile));
if (waitpid(pid, NULL, 0) < 0)
fprintf(stderr, "Fehler bei waitpid()");
}
// In den else-Zweig gelangt nur der Kindprozess
else {
// Im Kindprozess
close(fd[1]);
n = read(fd[0], zeile, MAX_ZEICHEN);
for (i = 0; i < n; i++)
zeile[i] = toupper(zeile[i]);
fprintf(stderr, "Kind : ");
write(STDOUT_FILENO, zeile, n);
}
exit(0);
}
Geschichte
[Bearbeiten | Quelltext bearbeiten]Pipes wurden 1972/73 von Douglas McIlroy fur das Betriebssystem Unix erfunden. Bereits 1964 hatte er zu Beginn des Multics-Projekt (dem Vorlaufer von Unix) in einem Memo gefordert:
,,We should have some ways of coupling programs like garden hose--screw in another segment when it becomes [...] necessary to massage [sic] data in another way."
Siehe auch
[Bearbeiten | Quelltext bearbeiten]Weblinks
[Bearbeiten | Quelltext bearbeiten]- Dokumentation des Windows Pipe API Microsoft Developer Network [MSDN] (englisch)