Rust 将可变弧引用传递给超级服务\u fn处理程序的问题_Rust_Future_Smart Pointers_Rust Tokio_Hyper

Rust 将可变弧引用传递给超级服务\u fn处理程序的问题

rust

Rust 将可变弧引用传递给超级服务\u fn处理程序的问题,rust,future,smart-pointers,rust-tokio,hyper,Rust,Future,Smart Pointers,Rust Tokio,Hyper,我一直在尝试以下方法所示为相关进口和代码 use std::sync::{Arc, Mutex}; use std::thread; use hyper::rt::{self, Future, Stream}; use hyper::service::service_fn; use hyper::{Body, Request, Response, Server, StatusCode}; pub struct ChallengeState; pub struct ChallengeRespo

我一直在尝试以下方法

所示为相关进口和代码

use std::sync::{Arc, Mutex};
use std::thread;
use hyper::rt::{self, Future, Stream};
use hyper::service::service_fn;
use hyper::{Body, Request, Response, Server, StatusCode};

pub struct ChallengeState;
pub struct ChallengeResponse;

type BoxFut<'a> = Box<Future<Item = Response<Body>, Error = hyper::Error> + Send + 'a>;

fn handle_challengeproof<'a>(
    req: Request<Body>,
    challenge: &Arc<Mutex<ChallengeState>>,
) -> BoxFut<'a> {
    let resp = req.into_body().concat2().map(move |body| {
        let challenge_lock = challenge.lock().unwrap();
        Response::builder()
        .status(StatusCode::OK)
        .body(Body::from("test"))
        .unwrap()
    });
    Box::new(resp)
}

fn handle<'a>(
    req: Request<Body>,
    challenge: &Arc<Mutex<ChallengeState>>,
) -> BoxFut<'a> {
    handle_challengeproof(req, challenge)
}

pub fn run_listener(
    challenge: Arc<Mutex<ChallengeState>>,
) -> thread::JoinHandle<()> {
    let addr = ([127, 0, 0, 1], 9999).into();

    let listener_service = move || {
        let challenge = Arc::clone(&challenge);
        service_fn(move |req: Request<Body>| {
            handle(req, &challenge)
        })
    };

    let server = Server::bind(&addr)
        .serve(listener_service)
        .map_err(|_| () );

    thread::spawn(move || {
        rt::run(server);
    })
}

使用std:：sync:：{Arc，Mutex}；
使用std：：线程；
使用hyper:：rt:：{self，Future，Stream}；
使用hyper:：service:：service\u fn；
使用hyper:：{Body，Request，Response，Server，StatusCode}；
挑战地产酒店；
pub-struct-ChallengeResponse；
BoxFut型；
fn手柄防挑战{
让resp=req.into_body（）.concat2（）.map（移动| body |{
让challenge_lock=challenge.lock（）.unwrap（）；
响应：：生成器（）
.状态（状态代码：：OK）
.body（body:：from（“test”））
.unwrap（）
});
方框：：新建（resp）
}
fn手柄{
handle_challengeproof（请求、质询）
}
pub fn run_侦听器(
挑战：Arc，
)->thread:：JoinHandle{
让addr=（[127,0,0,1]，9999）.into（）；
让侦听器_service=move ||{
let challenge=Arc:：克隆（&challenge）；
服务（移动请求：请求）{
句柄（请求和质询）
})
};
让server=server:：bind（&addr）
.serve（侦听器服务）
.map|err（| |（））；
线程：：生成（移动| |{
rt：：运行（服务器）；
})
}

我一直试图通过传递对handle方法的引用来避免额外的Arc克隆，但似乎无法回避这个问题。避免handle（）上的生存期会在请求静态生存期时出现不同的错误

代码只更新了相关的内容。@

一个

弧的关键在于它计算有多少引用，这在克隆时发生。将引用传递给弧
会破坏该点
传递弧
本身，而不是传递引用。因此，handle
的签名变成：
fn handle<'a>(
    req: Request<Body>,
    challenge: Arc<Mutex<ChallengeState>>,
) -> BoxFut<'a>

对弧的引用在IMHO中没有多大意义。如果要对其执行某些操作，您可以传递&ChallengeState
，或者在需要存储它时传递Arc
。此Arc与其他线程共享。我正在考虑一个参考，以避免每次服务调用时都必须进行克隆。我只更新了相关问题的代码。这会产生一个不同的问题：“此闭包实现fn一次
，而不是fn
”。挑战需要每次移动，而不是一次。@hellow抱歉，这主要是单元测试。无论如何，这个问题似乎很简单。我正在传递一个对弧的引用，编译器无法计算出原始弧的生存期，以检查它的生存期是否与我所理解的相匹配。@NikosKostoulas你会这么说还是你的问题？是的，对于&'a Arc，@NikosKostoulas，那么这就是你要寻找的修复方法吗？
let listener_service = move || {
    service_fn(move |req: Request<Body>| handle(req, challenge))
};