Marcel est un nouveau shell. C’est similaire à coquilles traditionnelles à bien des égards, mais il fait certaines choses différemment:

• Tuyauterie: Tous les shells utilisent des tubes pour envoyer un texte de la sortie d’une commande à l’entrée d’une autre. Marcel envoie des données structurées au lieu de chaînes.
• Python: Marcel est implémenté en Python et expose Python de plusieurs manières. Si vous avez besoin d’un peu de logique dans vos commandes, marcel vous permet de l’exprimer en Python.
• Scripting: Marcel adopte une approche inhabituelle du scénario. Vous pouvez, bien sûr, simplement écrire une séquence de commandes marcel dans un fichier texte et les exécuter. Mais Marcel fournit également une API sous la forme d’un module Python. Vous pouvez importer ce module pour faire des scripts Python d’une manière beaucoup plus pratique que ce n’est possible avec Python ordinaire.

Marcel est sous licence GPLv3.

Installation de Marcel Modern Shell sous Linux

Marcel demande Python 3.6 ou plus tard. Il a été développé et testé sous Linux, et fonctionne principalement sur macOS. (Si vous souhaitez aider à porter les fenêtres, ou pour corriger le macOS carences, contactez-nous.)

À installer Marcel pour votre propre usage:

# python3 -m pip install marcel

Ou si vous souhaitez installer pour tous les utilisateurs (par exemple, pour /usr/local):

$ sudo python3 -m pip install --prefix /usr/local marcel

Une fois que vous avez installé Marcel, vérifiez que cela fonctionne en exécutant la commande Marcel, puis au Marcel invite, exécutez le version commander:

$ marcel

Personnalisation de Marcel Shell

Vous pouvez personnaliser Marcel dans le fichier ~/.marcel.py, qui est lu au démarrage, (et relu lorsqu’il est modifié). Comme vous pouvez le voir d’après le nom du fichier, la personnalisation de marcel se fait en Python.

Une chose que vous voudrez probablement faire est de personnaliser l’invite. Pour ce faire, vous attribuez une liste au RAPIDE variable. Par exemple, si vous voulez que votre invite soit le répertoire courant, imprimé en vert, suivi de > imprimé en bleu:

PROMPT = [
    Color(0, 4, 0),
    lambda: PWD,
    Color(0, 2, 5),
    '> '
]

L’invite résultante ressemble à ceci:

Cela remplace l’impénétrable PS1 configuration que vous auriez besoin de faire dans bash. Couleur (0, 4, 0) spécifie vert, (les arguments sont RVB valeurs, dans la plage 0-5). PWD est la variable d’environnement représentant votre répertoire actuel et préfixant cette variable avec lambda: génère une fonction, évaluée à chaque fois que l’invite est affichée.

le ~/.marcel.py peut également importer des modules Python. Par exemple, si vous souhaitez utiliser les fonctions du module mathématique dans vos commandes marcel:

from math import *

Une fois que vous avez fait cela, vous pouvez vous référer aux symboles de ce module, par exemple pi:

Notez que pi est entre parenthèses. En général, Marcel utilise des parenthèses pour délimiter les expressions Python. Alors (pi) évalue l’expression Python qui récupère la valeur de la variable pi. Vous pouvez également accéder aux variables d’environnement traditionnelles de cette manière, par exemple (UTILISATEUR) et (ACCUEIL), ou toute expression Python valide reposant sur des symboles dans l’espace de noms de marcel.

Et vous pouvez, bien sûr, définir vos propres symboles. Par exemple, si vous mettez cette définition de fonction dans ~/.marcel.py:

def factorial(n):
    f = 1
    for i in range(1, n + 1):
        f *= i
    return f

alors vous pouvez utiliser la fonction factorielle sur la ligne de commande, par exemple

Exemples de Marcel Shell

Ici, nous allons apprendre quelques exemples de commandes dans le shell marcel.

Rechercher les tailles de fichiers par extension

Explorez le répertoire courant de manière récursive, regroupez les fichiers par leur extension (par exemple .txt, .py et ainsi de suite), et calculez la taille totale du fichier pour chaque groupe.

Vous pouvez le faire dans marcel comme suit:

le Opérateur ls produit un flux d’objets File, (-fr signifie visiter les répertoires de manière récursive et ne renvoyer que les fichiers).

le Fichier les objets sont redirigés vers la commande suivante, map. le carte spécifie une fonction Python, dans les parenthèses les plus à l’extérieur, qui mappe chaque fichier à un tuple contenant l’extension du fichier et sa taille. (Marcel autorise l’omission du mot-clé lambda.)

le rouge (réduire) opérateur, groupe par la première partie du tuple (extension), puis résumez les tailles au sein de chaque groupe. Le résultat est trié par extension.

Les exécutables de l’hôte et le pipeline Marcel

Pipelines peut contenir un mélange d’opérateurs marcel et d’exécutables hôtes. Les opérateurs canalisent les objets, mais aux limites opérateur / exécutable, marcel canalisent les chaînes à la place.

Par exemple, cette commande combine des opérateurs et des exécutables et répertorie les noms d’utilisateur des utilisateurs dont le shell est /bin/bash.

$ cat /etc/passwd 
| map (line: line.split(':')) 
| select (*line: line[-1] == '/bin/bash') 
| map (*line: line[0]) 
| xargs echo

chat est un exécutable Linux. Ça lit / etc / passwd, et marcel redirige son contenu vers la carte d’opérateur marcel.

L’argument entre parenthèses à mapper est une fonction Python qui divise les lignes en : séparateurs, produisant 7 tuples. UNE sélectionner est un opérateur marcel dont l’argument est une fonction Python identifiant les tuples dans lesquels le dernier champ est / bin / bash.

L’opérateur suivant, une autre carte conserve le champ de nom d’utilisateur de chaque tuple d’entrée. Finalement, écho xargs combine les noms d’utilisateur entrants en une seule ligne, qui est imprimée sur stdout.

Scénario dans Marcel Shell

Tandis que Python est parfois considéré comme un langage de script, il ne fonctionne pas vraiment bien dans ce but. Le problème est que l’exécution de commandes shell et d’autres exécutables à partir de Python est fastidieuse. Vous pouvez utiliser os.system(), ce qui est simple mais souvent insuffisant pour traiter stdin, stdout et stderr. subprocess.Popen() est plus puissant mais plus complexe à utiliser.

L’approche de Marcel est de fournir un module qui intègre les opérateurs marcel avec les fonctionnalités du langage Python. Pour revenir sur un exemple précédent, voici le code Python permettant de calculer la somme des tailles de fichiers par extension:

from marcel.api import *

for ext, size in (ls(file=True, recursive=True)
                  | map(lambda f: (f.suffix, f.size))
                  | red('.', '+')):
    print(f'{ext}: {size})

Les commandes shell sont les mêmes que précédemment, à l’exception des conventions syntaxiques. Alors ls -fr se transforme en ls (fichier = Vrai, récursif = Vrai). La map et les opérateurs rouges sont là aussi, connectés avec des tuyaux, comme dans la version shell. La commande shell entière (ls… rouge) renvoie un itérateur Python afin que la commande puisse être utilisée avec Python pour une boucle.

Accès à la base de données avec Marcel Shell

Vous pouvez intégrer l’accès à la base de données avec les pipelines marcel. Tout d’abord, vous devez configurer l’accès à la base de données dans le fichier de configuration, ~/.marcel.py, par exemple

define_db(name="jao",
          driver="psycopg2",
          dbname="acme",
          user="jao")

DB_DEFAULT = 'jao'

Cela configure l’accès à un Postgres base de données nommée acmé, en utilisant le psycopg2 chauffeur. Les connexions depuis marcel se feront à l’aide du jao utilisateur, et le profil de base de données est nommé jao. (DB_DEFAULT spécifie le jao profil de base de données comme celui à utiliser si aucun profil n’est spécifié.) Une fois cette configuration terminée, la base de données peut maintenant être interrogée à l’aide de l’opérateur sql, par exemple

sql 'select part_name, quantity from part where quantity < 10' 
| out --csv –-file ~/reorder.csv

Cette commande interroge une table nommée partieet vide le résultat de la requête dans le fichier ~/reorder.csv, au format CSV.

Accès à distance avec Marcel Shell

Comme pour l’accès à la base de données, l’accès à distance peut être configuré dans ~/.marcel.py. Par exemple, cela configure un cluster à 4 nœuds:

define_remote(name="lab",
              user="frankenstein",
              identity='/home/frankenstein/.ssh/id_rsa',
              host=['10.0.0.100', 
                    '10.0.0.101',
                    '10.0.0.102',
                    '10.0.0.103'])

Le cluster peut être identifié comme un laboratoire dans les commandes marcel. Les paramètres d’utilisateur et d’identité spécifient les informations de connexion, et le hôte Le paramètre spécifie les adresses IP des nœuds sur le cluster.

Une fois le cluster configuré, tous les nœuds peuvent être utilisés en même temps. Par exemple, pour obtenir une liste de processus pids et lignes de commande à travers le cluster:

@lab [ps | map (proc: (proc.pid, proc.commandline))]

Cela renvoie un flux de tuples (adresse IP, PID, ligne de commande).

Pour plus d’informations, visitez: https://www.marceltheshell.org/

Marcel est assez nouveau et en cours de développement actif. Contactez-nous si vous souhaitez aider.