CODEWITHSUNDEEP
asynchronousrustmovespawnrust-tokio
Daniel Schaadt
Daniel Schaadt

Reputation: 109

How to borrow/avoid a move of a socket in tokio::spawn(async

I am trying to write an udp client in rust which establishes a socket connection to a remote server, should listen for incoming messages(and then process the data), while also be able to send messages and then disconnects after a given time. I would like to use the new async/await syntax in tokio and spawn a task that takes care of reading incoming/processing the incoming messages, while keeping the socket in the main task to send messages in parallel, especially at the end the protocol to close the connection. How can I avoid moving the socket into the spawned task? Is there a way to borrow it in that task maybe trough a reference. I looked through answers to similar questions but could not understand it as they apply to the version of tokio without the new syntax and as I am an absolute beginner in rust.

I can move the socket into the spawned function, but then it is of course no longer available to the code outside, which needs to send messages in parallel.

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let remote_addr: SocketAddr = "...:xxxx".parse()?;

        let local_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0,0,0,0)), 0);
        let mut socket = UdpSocket::bind(&local_addr)?;
                socket.connect(&remote_addr)?;
// do some protocol work with the socket to establish a connection
    tokio::spawn(async move {
      let mut buf = [0; 1024];

      loop {
        let l = match socket.recv(&mut buf).await {
            // socket closed
            Ok(l) if l == 0 => {
              println!("socket closed");
              return;
            },
            Ok(l) => l,
            Err(e) => {
                println!("failed to read from socket; err = {:?}", e);
                return;
            }
        };
        let data = buf[..l].to_vec();
        println!("Received {} bytes:\n{:#x?}", l, data);
      }
    });

// here I would like to use the socket again to send messages and to do the disconnect protocol, i.e.
let len = socket.recv(.....

When I use the socket afterwards, I get the error that the variable moved due to use in generator and gets dropped at the end of the spawn task (which it should not). Later use of socket says value borrowed after move, which is clear, but how can I avoid it? I would appreciate if somebody could help me with this beginner question, especially in the context of the new async/await syntax of tokio. Thanks!

Upvotes: 1

Views: 1723

Answers (1)

Daniel Schaadt
Daniel Schaadt

Reputation: 109

Well, I solved the problem in a different way. Tokio's UdpSocket can be split into a receiving and a sending part. I run both of them in separate task and then use multiple tokio::mpsc::channel to communicate between the two task and the main task.

Upvotes: 0

Related Questions