understanding oneshot doc example

[ibigbug]

https://docs.rs/tokio/latest/tokio/sync/oneshot/index.html

To use a oneshot channel in a tokio::select! loop, add &mut in front of the channel.

could you elaborate why?

[ibigbug]

further more, I wanted to understand why the rx is always dropped before the message could be sent from the tx, with the below code snipped:

 let (mut tx, rx) = tokio::sync::oneshot::channel::<Vec<Ipv4Addr>>();

    let mut rx = rx.fuse();

    let r = Arc::new(socket);
    let s = r.clone();

    let xid = msg.xid();
    tokio::spawn(async move {
        let mut buf = vec![0u8; 576];

        let get_response = async move {
            loop {
                let (n_read, _) = r
                    .recv_from(&mut buf)
                    .await
                    .expect("failed to receive DHCP offer");

                // fucking deep if-else hell
                if let Ok(reply) = dhcproto::v4::Message::from_bytes(&buf[..n_read]) {
                    if let Some(op) = reply.opts().get(dhcproto::v4::OptionCode::MessageType) {
                        match op {
                            dhcproto::v4::DhcpOption::MessageType(msg_type) => {
                                if msg_type == &dhcproto::v4::MessageType::Offer {
                                    if reply.xid() == xid {
                                        if let Some(op) = reply
                                            .opts()
                                            .get(dhcproto::v4::OptionCode::DomainNameServer)
                                        {
                                            match op {
                                                dhcproto::v4::DhcpOption::DomainNameServer(dns) => {
                                                    debug!("got NS servers {:?} from DHCP", dns);
                                                    return dns.clone();
                                                }
                                                _ => yield_now().await,
                                            }
                                        }
                                    }
                                    yield_now().await
                                }
                            }
                            _ => yield_now().await,
                        }
                    }
                }
            }
        };

        tokio::select! {
            _ = tx.closed() => {debug!("rx closed, quiting")},
            value = get_response => tx.send(value).expect("must send")
        }
    });

    s.send_to(&msg.to_vec().expect("must encode"), "255.255.255.255:67")
        .await?;

    debug!("waiting for DHCP reply");

    let mut interval = interval(Duration::from_millis(100));

    let result = tokio::select! {
        result = &mut rx => result.map_err(|x| io::Error::new(io::ErrorKind::Other, "channel error")),
        // _ = interval.tick() => { debug!("Another 100ms"); return Err(io::Error::new(io::ErrorKind::Other, "DHCP timeout")) },
        _ = tokio::time::sleep(Duration::from_secs(10)) => {
            debug!("DHCP timeout after 10 secs");
         return Err(io::Error::new(io::ErrorKind::Other, "dhcp timeout"));
            }

    };

    debug!("rx dropped here");

    result

the debug!("rx closed, quiting") is always executed, however,

the debug!("rx dropped here"); is never executed, what could cause the rx to close? I don't see it's dropped due to out of lifetime.

[ibigbug]

turns out it's nothing to do with the mut it's an outer select! cancelled the future.

so still good to know why mut is required in select!

[barafael]

I'm super late, but the reason you need a &mut is required is because the oneshot receiver will get moved in the loop iteration. To prevent this, select over a mutable reference to it.