So erstellen Sie Ihre eigene Shell mit Python (Teil 1)

Ich würde gerne wissen, wie eine Shell (wie Bash, CSH usw.) intern funktioniert. Um meine Neugier zu befriedigen, habe ich Python verwendet, um eine Shell namens yosh (Ihre eigene Shell) zu implementieren. Die in diesem Artikel vorgestellten Konzepte können auch auf andere Programmiersprachen angewendet werden.

(Tipp: Den in diesem Blogbeitrag verwendeten Quellcode finden Sie hier, der Code steht unter der MIT-Lizenz. Unter Mac OS X 10.11.5 habe ich mit Python 2.7.10 und 3.4.3 getestet . Es sollte auf anderen Unix-ähnlichen Umgebungen funktionieren, wie z. B. Cygwin unter Linux und Windows)

Lass uns beginnen.

Schritt 0: Projektstruktur

Für dieses Projekt habe ich die folgende Projektstruktur verwendet.

yosh_project
|-- yosh
   |-- __init__.py
   |-- shell.py

yosh_project ist das Stammverzeichnis des Projekts (Sie können es auch einfach yosh nennen).

yosh ist das Paketverzeichnis und __init__.py kann daraus ein Paket mit demselben Verzeichnisnamen wie das Paket machen (wenn Sie nicht in Python schreiben, können Sie es ignorieren.)

shell.py ist unsere Hauptskriptdatei.

Schritt 1: Shell-Schleife

Wenn Sie eine Shell starten, zeigt sie eine Eingabeaufforderung an und wartet auf Ihre Befehlseingabe. Nachdem Sie den eingegebenen Befehl empfangen und ausgeführt haben (wird später im Artikel ausführlich erläutert), kehrt Ihre Shell hierher zurück und wartet in einer Schleife auf die nächste Anweisung.

In shell.py beginnen wir mit einer einfachen Hauptfunktion, die die Funktion shell_loop() wie folgt aufruft:

def shell_loop():
    # Start the loop here
def main():
    shell_loop()
if __name__ == "__main__":
    main()

Dann in shell_loop(), Um anzugeben, ob Die Schleife wird fortgesetzt oder gestoppt. Wir verwenden ein Statusflag. Zu Beginn der Schleife zeigt unsere Shell eine Eingabeaufforderung an und wartet darauf, dass die Befehlseingabe gelesen wird. Nach

import sys
SHELL_STATUS_RUN = 1
SHELL_STATUS_STOP = 0
def shell_loop():
    status = SHELL_STATUS_RUN
    while status == SHELL_STATUS_RUN:
        ### 显示命令提示符
        sys.stdout.write('> ')
        sys.stdout.flush()
        ### 读取命令输入
        cmd = sys.stdin.readline()

segmentieren wir die Befehlseingabe (Tokenisierung) und führen sie aus (wir sind dabei, die Funktionen tokenize und execute zu implementieren).

Unsere shell_loop() sieht also so aus:

import sys
SHELL_STATUS_RUN = 1
SHELL_STATUS_STOP = 0
def shell_loop():
    status = SHELL_STATUS_RUN
    while status == SHELL_STATUS_RUN:
        ### 显示命令提示符
        sys.stdout.write('> ')
        sys.stdout.flush()
        ### 读取命令输入
        cmd = sys.stdin.readline()
        ### 切分命令输入
        cmd_tokens = tokenize(cmd)
        ### 执行该命令并获取新的状态
        status = execute(cmd_tokens)

Dies ist unsere gesamte Shell-Schleife. Wenn wir unsere Shell mit python shell.py starten, wird die Eingabeaufforderung angezeigt. Wenn wir jedoch den Befehl eingeben und die Eingabetaste drücken, wird ein Fehler ausgegeben, da wir die Funktion tokenize noch nicht definiert haben.

Um die Shell zu verlassen, versuchen Sie, Strg-C einzugeben. Später werde ich erklären, wie man die Shell ordnungsgemäß verlässt.

Schritt 2: Befehls-Tokenisierung

Wenn der Benutzer einen Befehl in unsere Shell eingibt und die Eingabetaste drückt, ist der Befehl ein langes Zeichen, das den Befehlsnamen und seine Parameter enthält. Daher müssen wir den String teilen (einen String in mehrere Tupel aufteilen).

Es scheint auf den ersten Blick einfach. Möglicherweise können wir cmd.split() verwenden, um die Eingabe durch Leerzeichen zu trennen. Es funktioniert für Befehle wie ls -a my_folder, da es den Befehl in eine Liste ['ls', '-a', 'my_folder'] aufteilt, damit wir sie problemlos verarbeiten können.

Es gibt jedoch auch Situationen wie echo "<span class="wp_keywordlink">Hello World</span>" oder echo 'Hello World', in denen Parameter in einfache oder doppelte Anführungszeichen gesetzt werden. Wenn wir cmd.spilt verwenden, erhalten wir eine Liste mit 3 Tags ['echo', '"Hello', 'World"'] anstelle einer Liste mit 2 Tags ['echo', 'Hello World'].

Glücklicherweise stellt Python eine Bibliothek namens shlex zur Verfügung, die uns dabei helfen kann, Befehle wie von Zauberhand aufzuteilen. (Tipp: Wir können auch reguläre Ausdrücke verwenden, aber das ist nicht der Schwerpunkt dieses Artikels.)

import sys
import shlex
...
def tokenize(string):
    return shlex.split(string)
...

Wir senden diese Tupel dann an den ausführenden Prozess.

Schritt 3: Ausführen

Dies ist ein zentraler und interessanter Teil der Shell. Was genau passiert, wenn die Shell mkdir test_dir ausführt? (Tipp: mkdir ist ein ausführbares Programm mit test_dir-Parametern, das zum Erstellen eines Verzeichnisses mit dem Namen test_dir verwendet wird.)

execvp ist die erste Funktion, die für diesen Schritt erforderlich ist. Bevor wir erklären, was execvp tut, sehen wir es uns in Aktion an.

import os
...
def execute(cmd_tokens):
    ### 执行命令
    os.execvp(cmd_tokens[0], cmd_tokens)
    ### 返回状态以告知在 shell_loop 中等待下一个命令
    return SHELL_STATUS_RUN
...

Versuchen Sie erneut, unsere Shell auszuführen, geben Sie den Befehl mkdir test_dir ein und drücken Sie die Eingabetaste.

Nachdem wir die Eingabetaste gedrückt haben, besteht das Problem darin, dass unsere Shell direkt beendet wird, anstatt auf den nächsten Befehl zu warten. Das Verzeichnis wird jedoch korrekt erstellt.

Also, was macht execvp eigentlich?

execvp 是系统调用 exec 的一个变体。第一个参数是程序名字。v 表示第二个参数是一个程序参数列表（参数数量可变）。p 表示将会使用环境变量 PATH 搜索给定的程序名字。在我们上一次的尝试中，它将会基于我们的 PATH 环境变量查找mkdir 程序。

（还有其他 exec 变体，比如 execv、execvpe、execl、execlp、execlpe；你可以 google 它们获取更多的信息。）

exec 会用即将运行的新进程替换调用进程的当前内存。在我们的例子中，我们的 shell 进程内存会被替换为 mkdir 程序。接着，mkdir 成为主进程并创建 test_dir 目录。最后该进程退出。

这里的重点在于我们的 shell 进程已经被 mkdir 进程所替换。这就是我们的 shell 消失且不会等待下一条命令的原因。

因此，我们需要其他的系统调用来解决问题：fork。

fork 会分配新的内存并拷贝当前进程到一个新的进程。我们称这个新的进程为子进程，调用者进程为父进程。然后，子进程内存会被替换为被执行的程序。因此，我们的 shell，也就是父进程，可以免受内存替换的危险。

让我们看看修改的代码。

...
def execute(cmd_tokens):
    ### 分叉一个子 shell 进程
    ### 如果当前进程是子进程，其 `pid` 被设置为 `0`
    ### 否则当前进程是父进程的话，`pid` 的值
    ### 是其子进程的进程 ID。
    pid = os.fork()
    if pid == 0:
    ### 子进程
        ### 用被 exec 调用的程序替换该子进程
        os.execvp(cmd_tokens[0], cmd_tokens)
    elif pid > 0:
    ### 父进程
        while True:
            ### 等待其子进程的响应状态（以进程 ID 来查找）
            wpid, status = os.waitpid(pid, 0)
            ### 当其子进程正常退出时
            ### 或者其被信号中断时，结束等待状态
            if os.WIFEXITED(status) or os.WIFSIGNALED(status):
                break
    ### 返回状态以告知在 shell_loop 中等待下一个命令
    return SHELL_STATUS_RUN
...

当我们的父进程调用 os.fork() 时，你可以想象所有的源代码被拷贝到了新的子进程。此时此刻，父进程和子进程看到的是相同的代码，且并行运行着。

如果运行的代码属于子进程，pid 将为 0。否则，如果运行的代码属于父进程，pid 将会是子进程的进程 id。

当 os.execvp 在子进程中被调用时，你可以想象子进程的所有源代码被替换为正被调用程序的代码。然而父进程的代码不会被改变。

当父进程完成等待子进程退出或终止时，它会返回一个状态，指示继续 shell 循环。

运行

现在，你可以尝试运行我们的 shell 并输入 mkdir test_dir2。它应该可以正确执行。我们的主 shell 进程仍然存在并等待下一条命令。尝试执行 ls，你可以看到已创建的目录。

但是，这里仍有一些问题。

第一，尝试执行 cd test_dir2，接着执行 ls。它应该会进入到一个空的 test_dir2 目录。然而，你将会看到目录并没有变为 test_dir2。

第二，我们仍然没有办法优雅地退出我们的 shell。

我们将会在下篇解决诸如此类的问题。

Das obige ist der detaillierte Inhalt vonSo erstellen Sie Ihre eigene Shell mit Python (Teil 1). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!