How to set a lifetime to a value captured in a closure? - rust

Question

I wrote what I think is simple code:
#![feature(plugin)]
#![plugin(rocket_codegen)]
extern crate rocket;
extern crate statsd;
use rocket::{Data, Request};
use rocket::fairing::AdHoc;
use statsd::Client;
#[get("/")]
fn index() -> &'static str {
"Hello, World"
}
fn main() {
let mut client = Client::new("127.0.0.1:9125", "miniserver-rs").unwrap();
rocket::ignite()
.attach(AdHoc::on_request(|request, data|{
client.incr("http.requests");
println!("Request URI: {}", request.uri());
}))
.mount("/", routes![index])
.launch();
client.incr("server.bootstrap");
}
I try to send some metrics on each request, but I get the following compiler error:
Compiling miniserver-rs v0.1.0 (main.rs)
error[E0373]: closure may outlive the current function, but it borrows `client`, which is owned by the current function
--> src\main.rs:19:33
|
19 | .attach(AdHoc::on_request(|request, _data|{
| ^^^^^^^^^^^^^^^^ may outlive borrowed value `client`
20 | client.incr("http.requests");
| ------ `client` is borrowed here help: to force the closure to take ownership of `client` (and any other referenced variables), use the `move` keyword
|
19 | .attach(AdHoc::on_request(move |request, _data|{
| ^^^^^^^^^^^^^^^^^^^^^
error[E0387]: cannot borrow data mutably in a captured outer variable in an `Fn` closure
--> src\main.rs:20:11
|
20 | client.incr("http.requests");
| ^^^^^^
|
help: consider changing this closure to take self by mutable reference
--> src\main.rs:19:33
|
19 | .attach(AdHoc::on_request(|request, _data|{
| _________________________________^
20 | | client.incr("http.requests");
21 | | println!("Request URI: {}", request.uri());
22 | | }))
| |_______^
I understand that client is captured in a closure and owned by another function (main) that could live less than the closure. I cannot move it because Client doesn't implement Copy, so the reference could not be used afterwards.
I also understand that I cannot borrow mutable data in a closure (Client is mutable). After a lot of search, I can conclude I need to use Arc/Rc in combination with Mutex/RwLock/RefCell, but before going further, I want to be sure it is required.

Answer 1

Let's look at the requirements. You want to call statsd::Client::incr(&mut client, metric) from inside the closure, so you need mutable access to client. This is a variable you close over with ||.
Now AdHoc::on_request<F>(f: F) requires F: Fn(...) + Send + Sync + 'static. Fn means you only have immutable access to your capture via &self. The 'static bound means the capture cannot be a reference itself, so it requires move ||. Finally Sync means you can't use Cell or RefCell to get a mutable reference from &self.client, since Rocket will share it between threads.
Just like you suspected, the canonical solution to have shared mutable access through a Send + Sync value is to use Arc<Mutex<_>>. This also solves the problem of "losing access by moving". Your code would look like the following (untested):
fn main() {
let client = Arc::new(Mutex::new(
Client::new("127.0.0.1:9125", "miniserver-rs").unwrap()));
// shallow-clone the Arc to move it into closure
let rocket_client = client.clone();
rocket::ignite()
.attach(AdHoc::on_request(move |request, data|{
rocket_client.lock()
.unwrap()
.incr("http.requests");
println!("Request URI: {}", request.uri());
}))
.mount("/", routes![index])
.launch();
client.lock()
.unwrap()
.incr("server.bootstrap");
}