rust canteen

Cantine

Description

Canteen est le premier projet que j'impose à Rust. C'est un clone de Flask, mon framework Web Python préféré. Il existe du code pour un exemple d'implémentation dans le référentiel de cantine-implat.

Usage

Ce n'est en aucun cas complet, mais je travaille dessus, et il est maintenant disponible sur Crates.io! Pour l'installer et le vérifier, ajoutez ce qui suit à votre cargo.toml:

[ dependencies ]
canteen = " 0.5 "

Le principe derrière la cantine est simple - les fonctions de gestionnaire sont définies comme de simples fonctions de rouille qui prennent une Request et renvoient une Response . Les gestionnaires sont ensuite attachés à une ou plusieurs itinéraires et méthodes / verbes HTTP. Les routes sont spécifiées à l'aide d'une syntaxe simple qui vous permet de définir des variables en eux; variables qui peuvent ensuite être extraites pour effectuer diverses opérations. Actuellement, les types de variables suivants peuvent être utilisés:

• <str:name> correspondra à tout ce qui est dans un segment de chemin, renvoie une String
• <int:name> renverra un entier signé ( i32 ) à partir d'un segment de chemin
  • Ex: cnt.add_route("/api/foo/<int:foo_id>", &[Method::Get], my_handler) correspondra "/api/foo/123" mais pas "/api/foo/123.34" ou "/api/foo/bar"
• <uint:name> renvoie un entier non signé ( u32 )
• <float:name> fait la même chose que la définition du paramètre int , mais correspond aux nombres avec des décimaux et renvoie un f32
• <path:name> Je prendra avidement toutes les données de chemin contenues, renvoie une String
  • Ex: cnt.add_route("/static/<path:name>", &[Method::Get], utils::static_file) servira tout dans le /static/ répertoire en tant que fichier

Une fois les gestionnaires attachés aux itinéraires, l'étape suivante consiste à démarrer le serveur. Chaque fois qu'une demande est reçue, elle est envoyée avec le gestionnaire associé à un travailleur Threadpool. Le travailleur informe le processus parent lorsqu'il est terminé, puis la réponse est transmise au client. Des trucs assez simples!

Exemple

 extern crate canteen ;

use canteen :: * ;
use canteen :: utils ;

fn hello_handler ( req : & Request ) -> Response {
    let mut res = Response :: new ( ) ;

    res . set_status ( 200 ) ;
    res . set_content_type ( "text/plain" ) ;
    res . append ( "Hello, world!" ) ;

    res
}

fn double_handler ( req : & Request ) -> Response {
    let to_dbl : i32 = req . get ( "to_dbl" ) ;

    /* simpler response generation syntax */
    utils :: make_response ( format ! ( "{}" , to_dbl * 2 ) , "text/plain" , 200 )
}

fn main ( ) {
    let cnt = Canteen :: new ( ) ;

    // bind to the listening address
    cnt . bind ( ( "127.0.0.1" , 8080 ) ) ;

    // set the default route handler to show a 404 message
    cnt . set_default ( utils :: err_404 ) ;

    // respond to requests to / with "Hello, world!"
    cnt . add_route ( "/" , & [ Method :: Get ] , hello_handler ) ;

    // pull a variable from the path and do something with it
    cnt . add_route ( "/double/<int:to_dbl>" , & [ Method :: Get ] , double_handler ) ;

    // serve raw files from the /static/ directory
    cnt . add_route ( "/static/<path:path>" , & [ Method :: Get ] , utils :: static_file ) ;

    cnt . run ( ) ;
}