How to prevent cancelling Futures in nested `select!` macros? - rust

Question

I am trying to make a struct in Rust using tokio::select! which allows me to send and receive message from different parties.
pub Destination {
Alice,
Bob
}
struct ConnectionsManager {
rx_from_alice: UnboundedReceiver<Message>,
tx_to_alice: UnboundedSender<Message>,
rx_from_bob: UnboundedReceiver<Message>,
tx_to_bob: UnboundedSender<Message>,
}
impl ConnectionsManager {
async fn listen(&mut self) -> Result<Message, anyhow::Error> {
select! {
received_message = self.rx_from_alice.next() => {
return self.process_received_message(received_message).await
}
received_message = self.rx_from_bob.next() => {
return self.process_received_message(received_message).await
}
}
}
async fn send(&mut self, message: Message, dest: Destination) -> Result<(), anyhow::Error> {
match message {
Destination::Alice => self.tx_to_alice.send(message).await,
Destination::Bob => self.tx_to_bob.send(message).await,
}
}
async fn process_received_message(&mut self, received_message: Option<Message>) -> Result<Message, anyhow::Error> {
// Some further processing of the message
}
}
The Stream implementation of mpsc channels guarantees that there will be no lost messages,so it looks fine so far.
The problem is I need to also use a select! in the code that calls the ConnectionsManager::listen():
async fn listen_to_a_lot_of_stuff(&mut self) -> Result<Message, anyhow::Error> {
let conections_manager = ConnectionsManager::new(/* setting up...*/);
loop {
select! {
processed_message = self.connections_manager.listen() => {
// .......
}
some_other_result = some_other_future => {
// .......
}
}
}
}
In that case, when some_other_future resolves while ConnectionsManager::listen() already received message from a channel and calls ConectionsManager::process_received_message()` on it, the message may be lost due to cancelling of the future.
Is there any pattern that allows to not lose any message in that case?
Some ideas that have failed so far:
Saving connections_manager.listen() future or making it a task does not work, because I need to use ConnectionsManager tx channels while it is not awaited by select!. Storing the listen() Future makes calling ConnectionsManager::send() not possible in that case.
Giving TX channels to Bob and Alice, and have just one RX channel in ConnectionsManager could work, but ConnectionsManager struct needs to know whether either Bob's or Alice's TX channel was closed, and it will not receive that information (as None in RX) when one of them closes the TX channel, but the other one is still open.