Exemples d'implémentation en Rust¶

use thiserror::Error;

/// Erreurs metier de l'application
#[derive(Error, Debug)]
pub enum ErreurApp {
    #[error("Item introuvable : id={0}")]
    NonTrouve(i64),

    #[error("Donnees invalides : {0}")]
    Invalide(String),

    #[error("Erreur base de donnees : {0}")]
    BDD(#[from] sqlx::Error),
}

// Conversion vers une reponse HTTP Axum
use axum::{http::StatusCode, response::{IntoResponse, Response}, Json};
use serde_json::json;

impl IntoResponse for ErreurApp {
    fn into_response(self) -> Response {
        let (statut, message) = match &self {
            ErreurApp::NonTrouve(_) => (StatusCode::NOT_FOUND, self.to_string()),
            ErreurApp::Invalide(_) => (StatusCode::BAD_REQUEST, self.to_string()),
            ErreurApp::BDD(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Erreur interne".into()),
        };
        (statut, Json(json!({ "erreur": message }))).into_response()
    }
}

use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::Json,
};
use serde::{Deserialize, Serialize};
use sqlx::SqlitePool;

use crate::erreur::ErreurApp;

#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct Item {
    pub id: i64,
    pub nom: String,
    pub valeur: f64,
}

/// Payload de creation / mise a jour (sans id)
#[derive(Debug, Deserialize)]
pub struct ItemPayload {
    pub nom: String,
    pub valeur: f64,
}

/// Validation du payload
fn valider(p: &ItemPayload) -> Result<(), ErreurApp> {
    if p.nom.trim().is_empty() {
        return Err(ErreurApp::Invalide("Le nom ne peut pas etre vide".into()));
    }
    if p.valeur < 0.0 {
        return Err(ErreurApp::Invalide("La valeur doit etre positive".into()));
    }
    Ok(())
}

// GET /items
pub async fn lister(State(pool): State<SqlitePool>) -> Result<Json<Vec<Item>>, ErreurApp> {
    let items = sqlx::query_as!(Item, "SELECT id, nom, valeur FROM items ORDER BY id")
        .fetch_all(&pool)
        .await?;
    Ok(Json(items))
}

// GET /items/:id
pub async fn obtenir(
    Path(id): Path<i64>,
    State(pool): State<SqlitePool>,
) -> Result<Json<Item>, ErreurApp> {
    sqlx::query_as!(Item, "SELECT id, nom, valeur FROM items WHERE id = ?", id)
        .fetch_optional(&pool)
        .await?
        .map(Json)
        .ok_or(ErreurApp::NonTrouve(id))
}

// POST /items
pub async fn creer(
    State(pool): State<SqlitePool>,
    Json(payload): Json<ItemPayload>,
) -> Result<(StatusCode, Json<Item>), ErreurApp> {
    valider(&payload)?;
    let id = sqlx::query!(
        "INSERT INTO items (nom, valeur) VALUES (?, ?) RETURNING id",
        payload.nom,
        payload.valeur,
    )
    .fetch_one(&pool)
    .await?
    .id;

    let item = sqlx::query_as!(Item, "SELECT id, nom, valeur FROM items WHERE id = ?", id)
        .fetch_one(&pool)
        .await?;
    Ok((StatusCode::CREATED, Json(item)))
}

// PUT /items/:id
pub async fn modifier(
    Path(id): Path<i64>,
    State(pool): State<SqlitePool>,
    Json(payload): Json<ItemPayload>,
) -> Result<Json<Item>, ErreurApp> {
    valider(&payload)?;
    let nb = sqlx::query!(
        "UPDATE items SET nom = ?, valeur = ? WHERE id = ?",
        payload.nom, payload.valeur, id
    )
    .execute(&pool)
    .await?
    .rows_affected();

    if nb == 0 {
        return Err(ErreurApp::NonTrouve(id));
    }
    obtenir(Path(id), State(pool)).await
}

// DELETE /items/:id
pub async fn supprimer(
    Path(id): Path<i64>,
    State(pool): State<SqlitePool>,
) -> Result<StatusCode, ErreurApp> {
    let nb = sqlx::query!("DELETE FROM items WHERE id = ?", id)
        .execute(&pool)
        .await?
        .rows_affected();

    if nb == 0 {
        return Err(ErreurApp::NonTrouve(id));
    }
    Ok(StatusCode::NO_CONTENT)
}

mod erreur;
mod item;

use axum::routing::{delete, get, post, put};
use axum::Router;
use sqlx::sqlite::SqlitePoolOptions;
use tracing_subscriber::EnvFilter;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Initialisation des traces
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .init();

    // Connexion SQLite avec pool
    let pool = SqlitePoolOptions::new()
        .max_connections(5)
        .connect("sqlite://items.db?mode=rwc")
        .await?;

    // Migration automatique
    sqlx::migrate!("./migrations").run(&pool).await?;

    let app = Router::new()
        .route("/items", get(item::lister).post(item::creer))
        .route("/items/:id", get(item::obtenir).put(item::modifier).delete(item::supprimer))
        .with_state(pool);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await?;
    tracing::info!("Serveur demarre sur http://0.0.0.0:3000");
    axum::serve(listener, app).await?;
    Ok(())
}

use regex::Regex;
use serde::{Deserialize, Serialize};
use std::sync::OnceLock;
use thiserror::Error;

// OnceLock compile la regex une seule fois au premier appel
static REGEX_ACCESS: OnceLock<Regex> = OnceLock::new();

fn regex_access() -> &'static Regex {
    REGEX_ACCESS.get_or_init(|| {
        // Format Combined Log Format (Apache/Nginx)
        Regex::new(
            r#"^(\S+) \S+ \S+ \[([^\]]+)\] "(\S+) (\S+) \S+" (\d{3}) (\d+|-)"#
        ).expect("Regex invalide — erreur statique")
    })
}

#[derive(Error, Debug)]
pub enum ErreurParse {
    #[error("Ligne non reconnue : {0}")]
    FormatInconnu(String),
}

/// Entree de log parsee et structuree
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct EntreeLog {
    pub ip: String,
    pub date: String,
    pub methode: String,
    pub chemin: String,
    pub statut: u16,
    pub taille: Option<u64>,
}

/// Tente de parser une ligne de log au format Combined Log Format
pub fn parser_ligne(ligne: &str) -> Result<EntreeLog, ErreurParse> {
    let caps = regex_access()
        .captures(ligne)
        .ok_or_else(|| ErreurParse::FormatInconnu(ligne.to_owned()))?;

    let taille = caps[6].parse::<u64>().ok(); // "-" devient None

    Ok(EntreeLog {
        ip:      caps[1].to_owned(),
        date:    caps[2].to_owned(),
        methode: caps[3].to_owned(),
        chemin:  caps[4].to_owned(),
        statut:  caps[5].parse().unwrap_or(0),
        taille,
    })
}

/// Parse un fichier entier et retourne les entrees valides avec le compte d'erreurs
pub fn parser_fichier(contenu: &str) -> (Vec<EntreeLog>, usize) {
    let mut entrees = Vec::new();
    let mut nb_erreurs = 0;

    for ligne in contenu.lines() {
        let ligne = ligne.trim();
        if ligne.is_empty() { continue; }

        match parser_ligne(ligne) {
            Ok(entree) => entrees.push(entree),
            Err(_) => nb_erreurs += 1,
        }
    }
    (entrees, nb_erreurs)
}

/// Point d'entree WASM — expose au JavaScript via wasm-bindgen
#[cfg(target_arch = "wasm32")]
use wasm_bindgen::prelude::*;

#[cfg(target_arch = "wasm32")]
#[wasm_bindgen]
pub fn analyser_logs(contenu: &str) -> String {
    let (entrees, nb_erreurs) = parser_fichier(contenu);
    serde_json::json!({
        "entrees": entrees,
        "nb_lignes": entrees.len() + nb_erreurs,
        "nb_erreurs": nb_erreurs,
    })
    .to_string()
}

use std::{env, fs, process};
use log_parser::parser_fichier;

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() < 2 {
        eprintln!("Usage : log-parser <fichier.log>");
        process::exit(1);
    }

    let contenu = fs::read_to_string(&args[1]).unwrap_or_else(|e| {
        eprintln!("Impossible de lire {} : {}", args[1], e);
        process::exit(1);
    });

    let (entrees, nb_erreurs) = parser_fichier(&contenu);

    let sortie = serde_json::json!({
        "entrees": entrees,
        "nb_lignes": entrees.len() + nb_erreurs,
        "nb_erreurs": nb_erreurs,
    });

    // Serialisation JSON compacte vers stdout
    println!("{}", serde_json::to_string_pretty(&sortie).unwrap());
}