rust canteen

Cantina

Descrição

A cantina é o primeiro projeto que estou implementando em ferrugem. É um clone de frasco, minha estrutura favorita da Web Python. Há código para um exemplo de implementação no repositório canteen-IMPL.

Uso

Não é de forma alguma completo, mas estou trabalhando nisso e agora está disponível no Crates.io! Para instalar e conferir, adicione o seguinte à sua carga.toml:

[ dependencies ]
canteen = " 0.5 "

O princípio por trás da cantina é simples - as funções do manipulador são definidas como funções simples de ferrugem que recebem uma Request e retornam uma Response . Os manipuladores são então conectados a uma ou mais métodos/verbos HTTP. As rotas são especificadas usando uma sintaxe simples que permite definir variáveis ​​dentro delas; variáveis ​​que podem ser extraídas para executar várias operações. Atualmente, os seguintes tipos de variáveis ​​podem ser usados:

• <str:name> combinará qualquer coisa dentro de um segmento de caminho, retorna uma String
• <int:name> retornará um número inteiro assinado ( i32 ) de um segmento de caminho
  • Ex: cnt.add_route("/api/foo/<int:foo_id>", &[Method::Get], my_handler) corresponderá "/api/foo/123" , mas não "/api/foo/123.34" ou "/api/foo/bar"
• <uint:name> retornará um número inteiro não assinado ( u32 )
• <float:name> faz a mesma coisa que a definição de parâmetros int , mas corresponde a números com pontos decimais e retorna um f32
• <path:name> vai aceitar avidamente todos os dados do caminho contidos, retorna uma String
  • Ex: cnt.add_route("/static/<path:name>", &[Method::Get], utils::static_file) servirá qualquer coisa no /static/ diretório como um arquivo

Depois que os manipuladores são anexados às rotas, a próxima etapa é simplesmente iniciar o servidor. Sempre que uma solicitação é recebida, ela é despachada com o manipulador associado a um trabalhador do Threadpool. O trabalhador notifica o processo pai quando terminar e a resposta é transmitida de volta ao cliente. Coisas muito simples!

Exemplo

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