Panoramica dell'architettura

Gitrust è una piattaforma di hosting Git self-hosted basata sul framework rustwarden-core. L'applicazione espone due punti di ingresso di rete (HTTP + SSH) e rende persistenti i propri dati in PostgreSQL.

Panoramica

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

Avvio dell'applicazione

Il diagramma seguente descrive in dettaglio la sequenza di inizializzazione da main() all'avvio dei server HTTP e SSH.

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

Principi di progettazione

Gitrust quadro/separazione aziendale

Gitrust è costruito sulla base di Rustwarden-core, un framework di autenticazione e gestione degli utenti Rust. Questa separazione è intenzionale:

  • rustwarden-core gestisce: autenticazione JWT, sessioni, utenti, ruoli generici, i18n, SMTP, OAuth, registro di controllo generico.
  • gitrust-core gestisce: tutto ciò che è specifico per Git Forge: repository, chiavi SSH, team, autorizzazioni RBAC a 4 livelli, CI, importazione di repository.

La regola fondamentale: non modificare mai crates/rustwarden-core/. Qualsiasi estensione passa attraverso wrapper, hook ("RustwardenHooks") o funzionalità implementate dal lato gitrust.

Modalità senza testa

gitrust-web opera in modalità headless(): le pagine standard dell'interfaccia utente di Rustwarden (login, registrazione, impostazioni) sono disattivate e reimplementate interamente in gitrust-web/templates/. Ciò consente un design coerente (barra laterale Git, DaisyUI) senza compromettere l'interfaccia utente generica del framework.

SSR + HTMX, zero CDN

L'interfaccia viene resa lato server tramite Askama (modelli Rust compilati). HTMX gestisce le interazioni dinamiche (aggiornamenti parziali della pagina, SSE per notifiche e registri CI). Nessuna risorsa esterna: tutti i CSS/JS sono serviti da "statico/" — imposto dalla politica di sicurezza dei contenuti del framework.

Riposo nudo sul file system

gitrust-git è disaccoppiato dal database. Le operazioni Git (navigazione ad albero, lettura blob, protocollo pack) funzionano direttamente sui repository bare ({GIT_REPOS_BASE_PATH}/{owner}/{slug}.git/) tramite libgit2. Il database memorizza solo metadati (nome, descrizione, visibilità, proprietà). Questo disaccoppiamento consente di sostituire o testare gitrust-git in modo indipendente.

CI ibrida: Dagger come astrazione dell'esecuzione

Invece di implementare un CI runner da zero, gitrust delega l'esecuzione a Dagger, che garantisce isolamento (contenitori), riproducibilità (cache) e portabilità (runner locale o remoto tramite SSH+rsync). "CiWorker" è un'attività Tokio nel processo principale - non un demone separato - che semplifica la distribuzione (un singolo binario).

Per andare oltre