Comment créer votre propre Shell avec Python (Partie 1)

J'aimerais savoir comment un shell (comme bash, csh, etc.) fonctionne en interne. Alors afin de satisfaire ma curiosité, j'ai utilisé Python pour implémenter un Shell appelé yosh (Your Own Shell). Les concepts introduits dans cet article peuvent également être appliqués à d’autres langages de programmation.

(Astuce : Vous pouvez retrouver le code source utilisé dans cet article de blog ici, le code est publié sous licence MIT. Sur Mac OS X 10.11.5, j'ai testé avec Python 2.7.10 et 3.4.3 . Il devrait fonctionner sur d'autres environnements de type Unix, tels que Cygwin sous Linux et Windows)

Commençons.

Étape 0 : Structure du projet

Pour ce projet, j'ai utilisé la structure de projet suivante.

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

yosh_project est le répertoire racine du projet (vous pouvez aussi simplement le nommer yosh).

yosh est le répertoire du package, et __init__.py peut en faire un package avec le même nom de répertoire que le package (si vous n'écrivez pas en Python, vous pouvez l'ignorer.)

shell.py est notre fichier de script principal.

Étape 1 : Boucle Shell

Lorsque vous démarrez un shell, il affiche une invite de commande et attend votre entrée de commande. Après avoir reçu la commande saisie et l'avoir exécutée (expliquée en détail plus loin dans l'article), votre shell reviendra ici et bouclera en attendant l'instruction suivante.

Dans shell.py, nous commencerons par une simple fonction main, qui appelle la fonction shell_loop(), comme suit :

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

Puis, dans shell_loop(), Pour indiquer si la boucle continue ou s'arrête, nous utilisons un indicateur d'état. Au début de la boucle, notre shell affichera une invite de commande et attendra que l'entrée de la commande soit lue. Après

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()

, nous segmentons l'entrée de la commande (tokenize) et l'exécutons (nous sommes sur le point d'implémenter les fonctions tokenize et execute).

Donc, notre shell_loop() ressemblera à ceci :

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)

C'est toute notre boucle shell. Si nous démarrons notre shell en utilisant python shell.py, il affichera l'invite de commande. Cependant, si nous tapons la commande et appuyons sur Entrée, cela générera une erreur car nous n'avons pas encore défini la fonction tokenize.

Pour quitter le shell, essayez de taper ctrl-c. Plus tard, j'expliquerai comment quitter le shell avec élégance.

Étape 2 : tokenisation de la commande

Lorsque l'utilisateur entre une commande dans notre shell et appuie sur la touche Entrée, la commande sera un caractère long contenant le nom de la commande et sa chaîne de paramètres. Par conséquent, nous devons fragmenter la chaîne (diviser une chaîne en plusieurs tuples).

Cela semble simple à première vue. Nous pourrons peut-être utiliser cmd.split() pour séparer l'entrée par des espaces. Cela fonctionne pour les commandes comme ls -a my_folder car il divise la commande en une liste ['ls', '-a', 'my_folder'] afin que nous puissions les traiter facilement.

Cependant, il existe également des situations comme echo "<span class="wp_keywordlink">Hello World</span>" ou echo 'Hello World' où les paramètres sont cités entre guillemets simples ou doubles. Si nous utilisons cmd.spilt, nous obtiendrons une liste de 3 balises ['echo', '"Hello', 'World"'] au lieu d'une liste de 2 balises ['echo', 'Hello World'].

Heureusement, Python fournit une bibliothèque appelée shlex qui peut nous aider à diviser les commandes comme par magie. (Astuce : nous pouvons également utiliser des expressions régulières, mais ce n'est pas le sujet de cet article.)

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

Nous envoyons ensuite ces tuples au processus d'exécution.

Étape 3 : Exécuter

Il s'agit d'une partie centrale et intéressante du shell. Que se passe-t-il exactement lorsque le shell exécute mkdir test_dir ? (Astuce : mkdir est un programme exécutable avec des paramètres test_dir, utilisé pour créer un répertoire nommé test_dir.)

execvp est la première fonction requise pour cette étape. Avant d'expliquer ce que fait execvp, voyons-le en action.

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

Essayez d'exécuter à nouveau notre shell, entrez la commande mkdir test_dir et appuyez sur Entrée.

Après avoir appuyé sur la touche Entrée, le problème est que notre shell se fermera directement au lieu d'attendre la commande suivante. Cependant, le répertoire est créé correctement.

Alors, que fait execvp réellement ?

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。

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!