rust canteen

Kantine

Beschreibung

Kantine ist das erste Projekt, das ich in Rost implementiere. Es ist ein Klon aus Flask, mein bevorzugter Python -Web -Framework. Es gibt Code für eine Beispielimplementierung in der Kantinen-Impl-Repository.

Verwendung

Es ist keineswegs vollständig, aber ich arbeite daran und es ist jetzt auf Kisten erhältlich! Um es zu installieren und zu überprüfen, fügen Sie Folgendes zu Ihrer Fracht hinzu.

[ dependencies ]
canteen = " 0.5 "

Das Prinzip hinter der Kantine ist einfach - Handlerfunktionen sind als einfache Rostfunktionen definiert, die eine Request annehmen und eine Response zurückgeben. Handler werden dann an einen oder mehrere Routen und HTTP -Methoden/Verben angeschlossen. Routen werden unter Verwendung einer einfachen Syntax angegeben, mit der Sie in ihnen Variablen definieren können. Variablen, die dann extrahiert werden können, um verschiedene Operationen auszuführen. Derzeit können die folgenden variablen Typen verwendet werden:

• <str:name> stimmt mit etwas in einem Pfadsegment überein, gibt eine String zurück
• <int:name> Gibt eine signierte Ganzzahl ( i32 ) aus einem Pfadsegment zurück
  • Ex: cnt.add_route("/api/foo/<int:foo_id>", &[Method::Get], my_handler) stimmt "/api/foo/123" überein, aber nicht "/api/foo/123.34" oder "/api/foo/bar"
• <uint:name> Gibt eine nicht signierte Ganzzahl zurück ( u32 )
• <float:name> macht dasselbe wie die int parameter definition, passt aber mit nummern mit dezimalpunkten ab und gibt einen f32 zurück
• <path:name> nimmt gierig alle enthaltenen Pfaddaten, gibt eine String zurück
  • Ex: cnt.add_route("/static/<path:name>", &[Method::Get], utils::static_file) wird im /static/ Verzeichnis als Datei dienen

Nachdem die Handler an Routen angeschlossen sind, besteht der nächste Schritt darin, den Server einfach zu starten. Jedes Mal, wenn eine Anfrage empfangen wird, wird sie mit dem zugehörigen Handler an einen Threadpool -Arbeiter versandt. Der Arbeiter benachrichtigt den übergeordneten Prozess, wenn er fertig ist, und dann wird die Antwort an den Kunden übertragen. Ziemlich einfaches Zeug!

Beispiel

 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 ( ) ;
}