majorsilence-reporting

Installation

Le crate n'est pas encore publié sur crates.io. Ajoutez-le comme dépendance locale (path) :

# Cargo.toml
[dependencies]
majorsilence-reporting = { path = "/path/to/reporting-rust" }

# Une fois publié sur crates.io :
# majorsilence-reporting = "1.0"

La seule dépendance en runtime est libloading = "0.8". Édition Rust 2021, Rust 1.65 minimum.

Démarrage rapide

use majorsilence_reporting::RdlLibrary;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Charger la bibliothèque native une fois par processus.
    let lib = RdlLibrary::load("/path/to/rdlnative/librdlnative.so")?;

    // Construire une configuration de rapport.
    let mut rpt = lib.report("/path/to/report.rdl");
    rpt.set_connection_string("Data Source=/path/to/northwindEF.db")
       .set_parameter("Country", "Germany");

    // Exporter vers un fichier.
    rpt.export("pdf", "/tmp/output.pdf")?;

    // Ou exporter en mémoire — aucun fichier temporaire écrit.
    let pdf_bytes: Vec<u8> = rpt.export_to_memory("pdf")?;
    println!("{} octets obtenus", pdf_bytes.len());

    Ok(())
}

Chargement de la bibliothèque

RdlLibrary::load effectue toute la configuration nécessaire : il définit RDLNATIVE_LIB_DIR, précharge les fichiers .so / .dylib associés avec RTLD_GLOBAL afin que le résolveur P/Invoke .NET puisse les trouver, résout tous les symboles FFI, et appelle rdl_init().

use majorsilence_reporting::RdlLibrary;

// À appeler une fois au démarrage du processus. RdlLibrary est adossé à Arc — clonage peu coûteux et Send + Sync.
let lib = RdlLibrary::load("/path/to/librdlnative.so")?;

// Le cloner entre threads (par ex. dans un état Axum ou une Data Actix)
let lib2 = lib.clone();
std::thread::spawn(move || {
    let mut rpt = lib2.report("/path/to/report.rdl");
    rpt.export("pdf", "/tmp/thread.pdf").unwrap();
});

API principale

Les méthodes de construction renvoient &mut Self pour permettre le chaînage. Un nouveau handle de rapport natif est ouvert puis fermé à chaque appel à export ou export_to_memory, si bien qu'une valeur Report peut être réutilisée pour plusieurs rendus.

Jeux de données en mémoire

Transmettez des données structurées directement au rapport sans base de données. Chaque ligne est un HashMap<String, String> dont les clés sont les noms de colonnes et les valeurs les champs encodés en chaînes.

use std::collections::HashMap;
use majorsilence_reporting::RdlLibrary;

let lib = RdlLibrary::load("/path/to/librdlnative.so")?;
let mut rpt = lib.report("/path/to/report.rdl");

let rows: Vec<HashMap<String, String>> = vec![
    [("Product", "PDF Library Pro"), ("Revenue", "1200.00"), ("Units", "3")]
        .iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
    [("Product", "Report Designer"),  ("Revenue", "250.00"),  ("Units", "1")]
        .iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
];

rpt.add_data("SalesData", rows);
let pdf = rpt.export_to_memory("pdf")?;

Export en mémoire

export_to_memory appelle la fonction FFI native rdl_report_render_buffer, qui remplit un tampon alloué côté natif et renvoie un pointeur et une longueur. Le wrapper Rust copie les octets dans un Vec<u8> et appelle rdl_free. Aucun fichier temporaire n'est écrit à aucun moment — utile pour les corps de réponse HTTP ou l'intégration dans un pipeline.

// Exemple de handler Axum
async fn report_handler(State(lib): State<RdlLibrary>) -> impl IntoResponse {
    let mut rpt = lib.report("/reports/sales.rdl");
    rpt.set_connection_string("Data Source=/data/northwindEF.db");

    match rpt.export_to_memory("pdf") {
        Ok(bytes) => (
            StatusCode::OK,
            [("content-type", "application/pdf")],
            bytes,
        ).into_response(),
        Err(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response(),
    }
}

Gestion des erreurs

Toutes les opérations faillibles renvoient Result<T, majorsilence_reporting::Error>. Error implémente std::error::Error et encapsule le message renvoyé par la fonction native rdl_last_error().

match rpt.export_to_memory("pdf") {
    Ok(bytes) => { /* utiliser bytes */ }
    Err(e)    => eprintln!("échec du rendu : {e}"),
}

// Ou propager avec ?
let bytes = rpt.export_to_memory("pdf")?;

Formats d'export

Les dix formats sont pris en charge. Contrairement aux modes sous-processus de Python/PHP/Ruby, tous les formats sont disponibles dans le wrapper Rust car il utilise toujours le chemin FFI natif.