12个版本

0.4.2	2022年7月27日
0.4.1	2021年4月18日
0.3.6	2021年3月30日
0.3.5	2021年1月30日
0.1.1	2021年1月17日

#1287 在 HTTP服务器

被gitpad使用

MIT许可证

25KB
425 代码行

卫星

该库扩展了http crate中的类型

扩展了http::request::Parts，增加了查询参数反序列化和cookie解析
扩展了http::response::Builder，增加了设置cookies和内容类型的函数

如果你使用Hyper并且想使用Serde反序列化请求数据，你可以启用以下功能标志

hyper_body提供了一个trait，用于扩展hyper::Body，添加一个into_form方法来解析从HTML表单提交的数据。
hyper_body_json额外提供了一个into_json方法

卫星不处理路由，因为即使复杂的路由也可以通过嵌套的match块轻松实现。如果你想使用更高级的路由器，可以查看路由器crate。

卫星鼓励你创建自己的错误枚举，并为每个错误类型实现From转换，以便使用?运算符进行短路。这可以通过thiserror轻松实现，因为卫星将错误类型限制在'static生命周期。

安全注意事项

通过将cookies的SameSite设置为Lax或Strict来保护你的应用程序免受CSRF攻击，并检查Origin头与你的域名匹配（特别是如果你有未认证的POST端点）。

Hyper示例

use hyper::http::request::Parts;
use hyper::http::response::Builder;
use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Method, Server, StatusCode};
use serde::Deserialize;
use sputnik::hyper_body::{FormError, SputnikBody};
use sputnik::{html_escape, mime, request::SputnikParts, response::SputnikBuilder};
use std::convert::Infallible;

type Response = hyper::Response<Body>;

#[derive(thiserror::Error, Debug)]
enum Error {
    #[error("page not found")]
    NotFound(String),
    #[error("{0}")]
    FormError(#[from] FormError),
}

fn render_error(err: Error) -> (StatusCode, String) {
    match err {
        Error::NotFound(msg) => (StatusCode::NOT_FOUND, msg),
        Error::FormError(err) => (StatusCode::BAD_REQUEST, err.to_string()),
    }
}

async fn route(req: &mut Parts, body: Body) -> Result<Response, Error> {
    match (&req.method, req.uri.path()) {
        (&Method::GET, "/form") => Ok(get_form(req)),
        (&Method::POST, "/form") => post_form(req, body).await,
        _ => return Err(Error::NotFound("page not found".to_owned())),
    }
}

fn get_form(_req: &mut Parts) -> Response {
    Builder::new()
        .content_type(mime::TEXT_HTML)
        .body("<form method=post><input name=text> <button>Submit</button></form>".into())
        .unwrap()
}

#[derive(Deserialize)]
struct FormData {
    text: String,
}

async fn post_form(_req: &mut Parts, body: Body) -> Result<Response, Error> {
    let FormData { text } = body.into_form().await?;
    Ok(Builder::new()
        .content_type(mime::TEXT_HTML)
        .body(format!("hello <em>{}</em>", html_escape(text)).into())
        .unwrap())
}

async fn service(
    req: hyper::Request<hyper::Body>,
) -> Result<hyper::Response<hyper::Body>, Infallible> {
    let (mut parts, body) = req.into_parts();
    match route(&mut parts, body).await {
        Ok(mut res) => {
            for (k, v) in parts.response_headers().iter() {
                res.headers_mut().append(k, v.clone());
            }
            Ok(res)
        }
        Err(err) => {
            let (code, message) = render_error(err);
            // you can easily wrap or log errors here
            Ok(hyper::Response::builder()
                .status(code)
                .body(message.into())
                .unwrap())
        }
    }
}

#[tokio::main]
async fn main() {
    let service = make_service_fn(move |_| async move {
        Ok::<_, hyper::Error>(service_fn(move |req| service(req)))
    });

    let addr = ([127, 0, 0, 1], 8000).into();
    let server = Server::bind(&addr).serve(service);
    println!("Listening on http://{}", addr);
    server.await;
}

依赖关系

~1–3MB
~60K SLoC