Aller au contenu

Concept : Moteur Central (core-engine)

Navigation : Documentation > Moteur Central
Spécification technique détaillée : 07. Architecture Interne du Moteur

Sommaire

  1. Rôle et Philosophie du Moteur
  2. Arborescence Physique sur le Poste Client (~/.erable/)
  3. Le Principe de Livraison Sans État (Stateless Delivery)
  4. Cycle d'Installation Pas-à-Pas
  5. Commandes de Gestion du Moteur
  6. Les Installeurs Autonomes Directs
  7. Liens et Références Associées

1. Rôle et Philosophie du Moteur

Le composant core d'Érable est le moteur d'exécution universel déployé sur le poste client. Écrit en Nushell (engine/erable.nu), il a été conçu pour éliminer la lourdeur des gestionnaires traditionnels :

  • Flux de données typés natifs : Manipulation d'objets structurés (tables, dictionnaires) sans dépendre de parseurs JSON ou regex complexes.
  • Zéro dépendance d'exécution : Les installeurs téléchargent un binaire Nushell autonome dans l'environnement local de l'utilisateur. Aucune installation système globale (comme Node.js, Python ou Ruby) n'est requise.
  • Exécution réactive : Démarrage quasi-instantané, sans surcharge d'interpréteurs lourds.

2. Arborescence Physique sur le Poste Client (~/.erable/)

L'intégralité du fonctionnement d'Érable est isolée dans l'espace utilisateur ($HOME/.erable sous Linux/macOS ou $USERPROFILE\.erable sous Windows) :

~/.erable/
├── bin/                    # Répertoire exposé dans le PATH système
│   ├── erable (.exe)       # Trampoline vers le moteur Érable
│   ├── erable (.exe.target)# Pointeur vers engine/erable.nu
│   ├── rg (.exe)           # Trampoline d'application (ex: ripgrep)
│   └── rg (.exe.target)    # Pointeur vers packages/ripgrep/current/rg.exe
├── core/                   # Fichiers du moteur
│   └── engine/             # Moteur modulaire L0-L4 en Nushell
│       ├── erable.nu       # L0 : Point d'entrée CLI et bootstrap
│       ├── pipelines.nu    # L1 : Pipelines d'exécution et formatage terminal
│       ├── interfaces.nu   # L2 : Sas étanche de validation des manifestes
│       ├── orchestrators.nu# L3 : Orchestration métier et DAG anti-cycle
│       ├── tasks.nu        # L4 : Tâches atomiques pures (7z, MSI, CoW, hooks)
│       └── errors.nu       # Contrats d'erreurs structurées et typées
├── tools/                  # Binaires et dépendances internes
│   ├── trampoline (.exe)   # Binaire Trampoline Rust de référence unique
│   ├── trampoline.hash     # Empreinte SHA-256 du code source du trampoline
│   └── nu/                 # Binaire autonome de Nushell (nu / nu.exe)
├── cache/                  # Archives et binaires bruts téléchargés
├── buckets/                # Dépôts de manifestes (main, gui, community...)
└── packages/               # Logiciels installés et partitionnés par version
    └── ripgrep/
        ├── 14.1.0/         # Store immuable de la version 14.1.0
        │   └── rg.exe
        └── current/        # Copie active pointée par le trampoline
            └── rg.exe

3. Le Principe de Livraison Sans État (Stateless Delivery)

Érable applique le principe fondamental de découplage strict entre les binaires applicatifs et l'état utilisateur :

  1. Immutabilité des versions : Chaque version est extraite dans un sous-dossier figé packages/<logiciel>/<version>/.
  2. Atomicité des mises à jour : Le passage à une nouvelle version met à jour le répertoire current/ de manière atomique, sans casser les sessions en cours.
  3. Persistance standardisée : Les configurations et données applicatives continuent de respecter les standards de l'OS (~/.config ou ~/.local/share sous Linux/macOS, %APPDATA% sous Windows), empêchant toute perte de données en cas de réinstallation d'un paquet.

4. Cycle d'Installation Pas-à-Pas

Lors de la commande erable install <paquet>, le moteur exécute les 8 étapes suivantes :

sequenceDiagram
    participant User as Utilisateur
    participant Engine as Moteur (erable.nu)
    participant Bucket as Bucket Local
    participant CDN as CDN Distant
    participant Disk as Disque Local

    User->>Engine: erable install ripgrep
    Engine->>Bucket: Résolution dans parts/*.toml
    Engine->>Engine: Contrôle compatibilité OS / architecture
    Engine->>CDN: Téléchargement archive dans cache/
    Engine->>Engine: Contrôle cryptographique SHA-256
    Engine->>Disk: Extraction dans packages/ripgrep/<version>/
    Engine->>Disk: Synchronisation vers packages/ripgrep/current/
    Engine->>Disk: Duplication du Trampoline Rust dans bin/
    Engine->>Disk: Écriture atomique du fichier pointeur .target
    Engine-->>User: Logiciel opérationnel !
  1. Recherche dans les buckets actifs : Découverte du paquet et chargement des manifestes parts/package.toml et parts/targets.toml.
  2. Validation de plateforme : Vérification que l'OS hôte ($nu.os-info) correspond à l'une des architectures cibles supportées.
  3. Mise en cache : Téléchargement du binaire ou de l'archive dans ~/.erable/cache/.
  4. Vérification d'intégrité : Calcul du hash SHA-256 et comparaison stricte avec l'empreinte déclarée dans le manifeste.
  5. Extraction sécurisée : Décompression propre dans packages/<nom>/<version>/.
  6. Mise à jour de current : Déploiement de la version active.
  7. Routage par Trampoline : Copie du trampoline de référence Rust dans bin/<alias> et génération du pointeur <alias>.target.
  8. Disponibilité immédiate : La commande est accessible dans le shell courant sans redémarrage de session.

5. Commandes de Gestion du Moteur

Pour la référence exhaustive de la CLI, consultez le Guide Complet des Commandes CLI (docs/commands/index.md).

Commande Action
erable install <pkg> Installe un paquet depuis les buckets actifs. (détails)
erable uninstall <pkg> Désinstalle un paquet et supprime ses trampolines dans bin/. (détails)
erable prune [pkg] Purge les anciennes versions installées avec rétention --keep. (détails)
erable list Liste l'ensemble des paquets installés sur le poste. (détails)
erable search [motif] Recherche un paquet dans les index des buckets locaux. (détails)
erable update Synchronise tous les buckets Git déclarés. (détails)
erable update-trampolines Met à jour tous les trampolines existants vers la dernière version compilée. (détails)
erable apply <config.toml> Réconcilie déclarativement les paquets du système. (détails)
erable version Affiche la version d'Érable et la plateforme détectée. (détails)

6. Les Installeurs Autonomes Directs

L'installation initiale du moteur s'effectue en une commande via deux scripts autonomes légers et autosuffisants hébergés à la racine du dépôt officiel Érable :

6.1 Installeur Windows (PowerShell)

Le script install.ps1 configure l'environnement utilisateur sous Windows sans nécessiter de privilèges administrateur :

irm https://gitlab.com/cortexa/native-application-ai/erable/core/-/raw/main/install.ps1 | iex

Actions exécutées automatiquement :

  1. Détection de l'architecture : Identification du processeur hôte (x86_64 ou aarch64).
  2. Bootstrap de Nushell (nu.exe) : Téléchargement et extraction locale de la version certifiée de Nushell dans ~/.erable/nu/.
  3. Mise en place du Trampoline Rust : Rapatriement du binaire trampoline natif (trampoline-x86_64-windows.exe ou trampoline-aarch64-windows.exe).
  4. Configuration du PATH utilisateur : Injection persistante du répertoire ~/.erable/bin dans la variable d'environnement PATH du profil utilisateur (zéro altération du registre système machine).
  5. Initialisation de la configuration : Création de ~/.erable/config.toml avec les buckets officiels actifs.

6.2 Installeur Linux & macOS (Bash / Zsh)

Le script install.sh prend en charge l'ensemble des distributions Linux et les systèmes macOS :

curl -sSL https://gitlab.com/cortexa/native-application-ai/erable/core/-/raw/main/install.sh | sh

Actions exécutées automatiquement :

  1. Détection de la plateforme et de l'architecture :
  2. Linux : x86_64 ou aarch64 (ARM64).
  3. macOS : Apple Silicon (arm64) ou Intel (x86_64).
  4. Installation locale du moteur Nushell : Mise en place autonome dans ~/.erable/nu/ conforme aux standards XDG Base Directory.
  5. Permission d'exécution & Trampoline natif : Configuration des droits d'exécution chmod +x sur les trampolines Musl / Mach-O.
  6. Intégration Shell transparente : Détection du shell actif (bash ou zsh) et enregistrement non intrusif de ~/.erable/bin dans ~/.bashrc ou ~/.zshrc.
  7. Validation immédiate : Vérification de la disponibilité de la commande erable dans le terminal sans redémarrage de session.

7. Liens et Références Associées