Architekturübersicht

Gitrust ist eine selbst gehostete Git-Hosting-Plattform, die auf dem rustwarden-core-Framework basiert. Die Anwendung stellt zwei Netzwerkeinstiegspunkte (HTTP + SSH) bereit und speichert ihre Daten in PostgreSQL.

Überblick

graph TB
    subgraph Clients
        Browser["Navigateur Web"]
        GitCLI["Git CLI (ssh/https)"]
    end

    subgraph "Gitrust Binary (src/main.rs)"
        Main["main()"]
    end

    subgraph "Crates Gitrust"
        Web["gitrust-web
Routes HTTP, templates,
handlers Axum"]
        SSH["gitrust-ssh
Serveur SSH (russh),
auth par clé, sessions"]
        SshGuard["gitrust-ssh-guard
SecureListener, détecteurs,
BanManager, AuthTracker"]
        Hooks["gitrust-hooks
impl RustwardenHooks
(on_user_registered, ...)"]
        Core["gitrust-core
Models, services, migrations,
rôles, types, DTOs"]
        Git["gitrust-git
Bare repos, tree browser,
pack protocol (git2)"]
    end

    subgraph "Framework"
        RW["rustwarden-core
Auth, users, JWT, sessions,
ResourceService, i18n"]
    end

    subgraph "Stockage"
        PG[(PostgreSQL)]
        FS[("Système de fichiers
bare repos .git")]
    end

    subgraph "CI/CD (optionnel)"
        CiWorker["CiWorker
tokio::spawn, mpsc,
sous-processus Dagger"]
        Dagger["Dagger Engine
Containers isolés,
cache, exécution"]
        CiEngine["ci-engine
Module Dagger Python
(Easy Mode)"]
        Syft["Syft (optionnel)
Génération SBOM
CycloneDX"]
        DTrack["Dependency-Track
(optionnel)
Analyse vulnérabilités"]
    end

    Browser -->|HTTP :4000| Web
    GitCLI -->|SSH :2222| SshGuard
    SshGuard -->|"AcceptOutcome::Accepted"| SSH
    GitCLI -->|HTTPS :4000| Web

    Main --> Web
    Main --> SSH
    Main --> SshGuard
    Main --> Hooks
    Main -.->|"si CI_ENABLED"| CiWorker

    Web --> Core
    Web --> Git
    Web -.->|"admin ACL/ban"| SshGuard
    SSH --> Core
    SSH --> Git
    SSH --> SshGuard
    SshGuard --> Core
    Hooks --> Core

    Core --> RW
    Core --> PG
    Git --> FS

    CiWorker --> Core
    CiWorker -->|"dagger call"| Dagger
    Dagger -->|"Easy Mode"| CiEngine
    Dagger -->|"Power Mode"| FS
    CiWorker -.->|"si CI_SBOM_ENABLED"| Syft
    Syft -.->|"si CI_DTRACK_ENABLED"| DTrack

Starten der Anwendung

Das folgende Diagramm beschreibt detailliert die Initialisierungssequenz von „main()“ bis zum Starten der HTTP- und SSH-Server.

sequenceDiagram
    participant Main as main()
    participant Builder as RustwardenBuilder
    participant App as RustwardenApp
    participant Mig as AppMigrator
    participant DB as PostgreSQL
    participant SMTP as Serveur SMTP

    Main->>Main: GitrustConfig::from_env()
    Main->>Main: Arc (hooks FS)

    Main->>Builder: builder().from_env()
    Note over Builder: Charge .env, init tracing
    Main->>Builder: .headless().auto_migrate(false)
    Main->>Builder: .merge_routes(app_routes(hooks))
    Note over Builder: Routes = framework API
+ pages SSR gitrust
+ Extension(hooks)
    Main->>Builder: .build().await
    Builder->>DB: Connexion pool
    Builder->>DB: Migrations rustwarden-core
    Builder->>SMTP: EmailQueueProcessor.start()
    Note over SMTP: Worker de fond : dépile
email_queue toutes les 30s
    Builder-->>Main: RustwardenApp

    Main->>Mig: run_migrations(app.database())
    Mig->>DB: core_migrations() + gitrust_migrations()
    Note over DB: Tables: users, resources,
repositories, ssh_keys,
teams, team_members,
team_repository_access
    Mig-->>Main: Ok

    Main->>Main: tokio::spawn(SSH server :2222)

    alt CI_ENABLED=true
        Main->>Main: CiWorker::start(config.ci)
        Note over Main: Vérifie dagger dans PATH
Si CI_SBOM_ENABLED: vérifie syft
Si CI_DTRACK_ENABLED: vérifie API DT
        Main->>Main: tokio::spawn(CiWorker loop)
        Note over Main: Écoute mpsc channel
pour les jobs CI
    end

    Main->>App: app.run().await
    Note over App: HTTP :4000 démarre

Gestaltungsprinzipien

Framework/Geschäftstrennung Gitrust

Gitrust basiert auf Rustwarden-Core, einem Rust-Authentifizierungs- und Benutzerverwaltungs-Framework. Diese Trennung ist beabsichtigt:

  • rustwarden-core verwaltet: JWT-Authentifizierung, Sitzungen, Benutzer, generische Rollen, i18n, SMTP, OAuth, generisches Audit-Protokoll.
  • gitrust-core verwaltet: alles Spezifische für Git Forge – Repositorys, SSH-Schlüssel, Teams, 4-stufige RBAC-Berechtigungen, CI, Repository-Import.

Die Grundregel: Verändern Sie niemals „crates/rustwarden-core/“. Jede Erweiterung durchläuft Wrapper, Hooks („RustwardenHooks“) oder Funktionen, die auf der Gitrust-Seite implementiert werden.

Headless-Modus

gitrust-web arbeitet im „headless()“-Modus: Die standardmäßigen Rustwarden-UI-Seiten (Anmeldung, Registrierung, Einstellungen) werden deaktiviert und vollständig in „gitrust-web/templates/“ neu implementiert. Dies ermöglicht ein kohärentes Design (Git-Sidebar, DaisyUI), ohne Kompromisse bei der generischen Benutzeroberfläche des Frameworks einzugehen.

SSR + HTMX, kein CDN

Die Schnittstelle wird serverseitig über Askama (kompilierte Rust-Vorlagen) gerendert. HTMX verwaltet dynamische Interaktionen (teilweise Seitenaktualisierungen, SSE für Benachrichtigungen und CI-Protokolle). Keine externen Assets: Das gesamte CSS/JS wird von „static/“ bereitgestellt – vorgeschrieben durch die Inhaltssicherheitsrichtlinie des Frameworks.

Bloßer Rest im Dateisystem

gitrust-git ist von der Datenbank entkoppelt. Git-Operationen (Baumnavigation, Blob-Lesen, Packprotokoll) funktionieren direkt auf Bare-Repos ({GIT_REPOS_BASE_PATH}/{owner}/{slug}.git/) über libgit2. Die Datenbank speichert nur Metadaten (Name, Beschreibung, Sichtbarkeit, Eigentümer). Durch diese Entkopplung kann gitrust-git unabhängig ersetzt oder getestet werden.

Hybrid CI: Dagger als Ausführungsabstraktion

Anstatt einen CI-Runner von Grund auf zu implementieren, delegiert Gitrust die Ausführung an Dagger, was Isolation (Container), Reproduzierbarkeit (Cache) und Portabilität (lokaler oder Remote-Runner über SSH+rsync) garantiert. Der „CiWorker“ ist eine Tokio-Aufgabe im Hauptprozess – kein separater Daemon – was die Bereitstellung vereinfacht (eine einzelne Binärdatei).

Um weiter zu gehen