rust canteen

Cantina

Descripción

Canteen es el primer proyecto que estoy implementando en Rust. Es un clon de frasco, mi marco web de Python favorito. Hay código para una implementación de ejemplo en el repositorio de Canteen-Impl.

Uso

¡De ninguna manera está completo, pero estoy trabajando en ello, y ahora está disponible en cajas.io! Para instalarlo y verlo, agregue lo siguiente a su carga.toml:

[ dependencies ]
canteen = " 0.5 "

El principio detrás de la cantina es simple: las funciones de los controladores se definen como simples funciones de óxido que toman una Request y devuelven una Response . Los manejadores se unen a una o más rutas y métodos/verbos HTTP. Las rutas se especifican utilizando una sintaxis simple que le permite definir variables dentro de ellas; Variables que luego se pueden extraer para realizar varias operaciones. Actualmente, se pueden usar los siguientes tipos de variables:

• <str:name> coincidirá con cualquier cosa dentro de un segmento de ruta, devuelve una String
• <int:name> devolverá un entero firmado ( i32 ) desde un segmento de ruta
  • Ej: cnt.add_route("/api/foo/<int:foo_id>", &[Method::Get], my_handler) coincidirá con "/api/foo/123" pero no "/api/foo/123.34" o "/api/foo/bar"
• <uint:name> devolverá un entero sin firmar ( u32 )
• <float:name> hace lo mismo que la definición de parámetros int , pero coincide con los números con puntos decimales y devuelve un f32
• <path:name> tomará con codazo todos los datos de ruta contenidos, devuelve una String
  • Ej: cnt.add_route("/static/<path:name>", &[Method::Get], utils::static_file) servirá cualquier cosa en el /static/ directorio como un archivo

Después de que los manejadores están conectados a las rutas, el siguiente paso es simplemente iniciar el servidor. Cada vez que se recibe una solicitud, se envía con el controlador asociado a un trabajador de Threadpool. El trabajador notifica el proceso principal cuando está terminado, y luego la respuesta se transmite nuevamente al cliente. ¡Cosas bastante sencillas!

Ejemplo

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