Value doesn't live enough, but can't understand the reason - rust

Question

Good day!
I'm struggling with a rust program due to a lifetime problem which I can't understand why it happens...It's a tokio thread trying to pass some data to another one using a mpsc. The argument is a &[u8], it's a buffer fulfilled by converting a String into a MessagePack with rmp. I've actually tried to refactor the code a few times, but I can't understand where to move the buffer to avoid to drop it. I can't move it outside from that scope, because it's the only part where it's required the buffer to be sent. This is the actual piece of code:
type Router<'a> = Arc<Mutex<
HashMap<u64, tokio::sync::mpsc::Sender<&'a [u8]>
>>>; // <hash funzione>/<sender>
#[derive(Clone)]
struct Mux<'a> {
routes: Router<'a>,
}
#[allow(redundant_semicolons)]
#[allow(non_snake_case)]
pub async fn init() -> Result<(), ()> {
let CONFIG_TOPIC = env::var("CONFIG_TOPIC").unwrap_or("config".into());
// Init router
let routes : Router = Arc::new(Mutex::new(HashMap::new()));
let multiplexer = Mux { routes };
// Init client MQTT
let mut client = client_factory().await;
let stream = client.get_stream(4096);
// Loop richieste
loop {
// Check connessione
if !client.is_connected() {
break;
}
// Ricezione
let opt_message = stream.recv().await.unwrap();
if opt_message.is_none() {
println!("M:: None");
continue;
}
let message = opt_message.unwrap();
let dest_topic = message.topic().to_string();
// Estrazione contenuto
let payload = message.payload(); // it's a slice
let content = rmp::decode::read_str_from_slice(payload).unwrap().0.to_string();
// Lock del multiplexer
let mut routes = multiplexer.routes.lock().unwrap();
//
if dest_topic.eq(&CONFIG_TOPIC) {
// Configurazione di un nuovo topic
// Iscrizione
let _sub = client.subscribe(content.clone(), 0 as i32);
// creazione canale
let (mSender, iReceiver) = mpsc::channel::<&[u8]>(32);
// inserimento
let key = hash(&content.clone());
if !routes.contains_key(&key) {
routes.insert(key, mSender);
}
// spawn invoker
tokio::spawn(async move{
invoker::run(iReceiver, dest_topic).await;
});
// stampa stato
for (k, v) in routes.iter() {
println!("M:: |{:?}|{:?}|", k, v);
}
}else{
// Dispatching di una nuova richiesta
let key = hash(&dest_topic);
let sender = routes.get(&key).unwrap();
// preparazione MessagePack
let mut buffer = Vec::new();
rmp::encode::write_str(&mut buffer, &content.clone()).unwrap_or_else(|e|{
;
});
sender.send(&buffer);
}
}
Ok(())
}
// -- UTILS --
// Funzione per calcolo di hash
fn hash<T: Hash>(t: &T) -> u64 {
let mut s = DefaultHasher::new();
t.hash(&mut s);
s.finish()
}
And this is the actual output message from cargo build:
error[E0597]: `buffer` does not live long enough
--> src/multiplexer.rs:86:25
|
86 | sender.send(&buffer);
| ^^^^^^^ borrowed value does not live long enough
87 | }
| - `buffer` dropped here while still borrowed
88 | }
| - borrow might be used here, when `routes` is dropped and runs the `Drop` code for type `std::sync::MutexGuard`
|
= note: values in a scope are dropped in the opposite order they are defined

Answer 1

You're creating buffer which is a Vec in line 82 inside an else block. buffer is going to go out of scope at the end of that block in line 87 and will be dropped. When it gets dropped, references to it won't be valid anymore because they'd be pointing to nothing. Because Rust doesn't allow invalid references, you can't send it across the channel.
The solution is most likely to change your Router type to accept owned Vecs instead of slices.
type Router = Arc<Mutex<
HashMap<u64, tokio::sync::mpsc::Sender<Vec<u8>>
>>>;
And pass your buffer in as such
// ...
let mut buffer = Vec::new();
rmp::encode::write_str(&mut buffer, &content.clone()).unwrap_or_else(|e|{
// ...
});
sender.send(buffer);
// ---------^^^^^^
// pass it by value
// ...
If you have another caller where it does make sense to pass a reference across the channel, you can use a Cow to allow for either:
type Router<'a> = Arc<Mutex<
HashMap<u64, tokio::sync::mpsc::Sender<Cow<'a, [u8]>>
>>>;
In init:
// ...
let mut buffer = Vec::new();
rmp::encode::write_str(&mut buffer, &content.clone()).unwrap_or_else(|e|{
;
});
sender.send(Cow::Owned(buffer));
// ...
And somewhere else:
sender.send(Cow::Borrowed(&some_u8_slice_that_lives_long_enough))