在检查 body 时将 body 和 headers 从超 HTTP 请求复制到新请求

Question

我想使用 hyper 创建一个小型 Rust HTTP 代理，它接受请求、转发请求并转储请求 + body。

基于this example，代理部分工作正常。

但是，我无法简单地复制和打印请求 body。我的主要问题是请求 body 不能简单地复制到 Vec<u8> 之类的东西中。我无法 deconstruct 请求读取 body 然后稍后创建它，因为无法将解构的 headers 添加到新请求中。

以下代码显示了我的最小 HTTP 代理示例：

extern crate futures;
extern crate hyper;
extern crate tokio_core;

use futures::{Future, Stream};

use hyper::{Body, Client, StatusCode};
use hyper::client::HttpConnector;
use hyper::header::{ContentLength, ContentType};
use hyper::server::{Http, Request, Response, Service};

use tokio_core::reactor::Core;

type HTTPClient = Client<HttpConnector, Body>;

struct Server {
    client: HTTPClient,
}

impl Server {
    pub fn new(client: HTTPClient) -> Server {
        Server { client: client }
    }
}

impl Service for Server {
    type Request = Request;
    type Response = Response;
    type Error = hyper::Error;
    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;

    fn call(&self, mut req: Request) -> Self::Future {
        let req_uri_str = {
            let uri = req.uri();
            format!(
                "http://localhost{}?{}",
                uri.path(),
                uri.query().unwrap_or_default()
            )
        };
        req.set_uri(req_uri_str.parse().unwrap());

        // Try to create a copy of the new request
        /*
        let (method, uri, version, headers, body) = req.deconstruct();
        let mut req_copy: Request<hyper::Body> = Request::new(method, uri);

        // Main problem: How can the request body be copied?
        // >>> let body_bytes: Vec<u8> = ...

        req_copy.set_body(body);
        req_copy.set_version(version);

        // Try to copy the headers
        for header in headers.iter() {
            req_copy.headers_mut().set(header.value().unwrap());
        }
        */

        // This works if the request is not deconstructed
        let work = self.client
            .request(req)
            .and_then(|res| futures::future::ok(res))
            .or_else(|err| {
                let body = format!("{}\n", err);
                futures::future::ok(
                    Response::new()
                        .with_status(StatusCode::BadRequest)
                        .with_header(ContentType::plaintext())
                        .with_header(ContentLength(body.len() as u64))
                        .with_body(body),
                )
            });

        Box::new(work)
    }
}

fn main() {
    // Create HTTP client core + handles
    let mut core = Core::new().unwrap();
    let handle = core.handle();
    let handle_clone = handle.clone();

    // Create HTTP server
    let server_addr = "127.0.0.1:9999".parse().unwrap();
    let server = Http::new()
        .serve_addr_handle(&server_addr, &handle, move || {
            Ok(Server::new(Client::new(&handle_clone)))
        })
        .unwrap();

    // Connect HTTP client with server
    let handle_clone2 = handle.clone();
    handle.spawn(
        server
            .for_each(move |conn| {
                handle_clone2.spawn(conn.map(|_| ()).map_err(|err| println!("Error: {:?}", err)));
                Ok(())
            })
            .map_err(|_| ()),
    );

    core.run(futures::future::empty::<(), ()>()).unwrap();
}

运行这工作正常，如果您在端口 80 上有任何 HTTP 服务运行，用浏览器连接到端口 9999 将完美转发任何响应和请求。

但是，如果您 re-enable 有关构建新的复制请求的行，我的方法将失败，因为我不明白如何复制 headers。（此外，这在复制请求时并没有真正帮助我body）

我知道这里有类似的问题，但是 none 符合我对 re-use 请求 body 的要求（或者没有）完全没有答案）。

Answer 1

the request body can't be simply copied into something like an Vec<u8>

当然可以。在 Rust 标准库中，值得记住 Iterator 特征的功能。和期货打交道，也要记住Future and Stream.

的能力

例如hyper的Body implements Stream. This means you can use the Stream::concat2方法：

Concatenate all results of a stream into a single extendable destination, returning a future representing the end result.

这将创建一个大的 Chunk，可以将其转换为 Vec:

extern crate hyper; // 0.11.22
extern crate futures; // 0.1.18

use futures::{Future, Stream};

fn example(req: hyper::Request) {
    req.body().concat2().map(|chunk| {
        let body = chunk.to_vec(); 
        println!("{:?}", body);
        ()
    });
    // Use this future somehow!
}

同样，Vec<u8> 可以转换回 Body。

since the deconstructed headers can't be added to a new request.

req_copy.headers_mut().extend(headers.iter());

总计：

fn create_localhost_request(req: Request) -> (Request, Body) {
    let (method, uri, version, headers, body) = req.deconstruct();

    let req_uri_str = {
        format!(
            "http://localhost{}?{}",
            uri.path(),
            uri.query().unwrap_or_default()
        )
    };
    let uri = req_uri_str.parse().unwrap();

    let mut req_copy = Request::new(method, uri);
    req_copy.set_version(version);
    req_copy.headers_mut().extend(headers.iter());

    (req_copy, body)
}

fn perform_proxy_request(
    client: HttpClient,
    req: Request,
) -> Box<Future<Item = Response, Error = hyper::Error>> {
    Box::new(client.request(req).or_else(|err| {
        let body = format!("{}\n", err);
        Ok(Response::new()
            .with_status(StatusCode::BadRequest)
            .with_header(ContentType::plaintext())
            .with_header(ContentLength(body.len() as u64))
            .with_body(body))
    }))
}

impl Service for Server {
    type Request = Request;
    type Response = Response;
    type Error = hyper::Error;
    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;

    fn call(&self, req: Request) -> Self::Future {
        let (mut req, body) = create_localhost_request(req);
        let client = self.client.clone();

        let work = body
            .concat2()
            .map(|chunk| chunk.to_vec())
            // Do whatever we need with the body here, but be careful
            // about doing any synchronous work.
            .map(move |body| {
                req.set_body(body);
                req
            })
            .and_then(|req| perform_proxy_request(client, req));

        Box::new(work)
    }
}

在检查 body 时将 body 和 headers 从超 HTTP 请求复制到新请求

Copy body and headers from hyper HTTP request to a new request while inspecting the body

rust

hyper