Simple Rust TCP server and client do not receive messages and never terminates

I am trying to spawn a server and connect to it on a different thread. I know Rust has blocking I/O, but I feel like I should be able to connect a server in a different thread. I do not have a lot of knowledge in threads. The end game is to connect to this server across a network. That is what I am simulating with the player_stream TCPStream. The player_stream will wait until there is something in its buffer. Once something has been written there, it will respond back to the server. As is, the program will not terminate.

use std::net::{TcpListener, TcpStream};
use std::io::{BufReader,BufWriter};
use std::io::Write;
use std::io::Read;
use std::thread;

fn main() {
    thread::spawn(move || {
        start_server();
    });
    let player_stream = TcpStream::connect("127.0.0.1:8000").expect("Couldn't connect");
    let mut reader = BufReader::new(&player_stream);
    let mut response = String::new();
    reader.read_to_string(&mut response);
    println!("Player received {}", response);
    let mut writer = BufWriter::new(&player_stream);
    writer.write_all("NAME".as_bytes());
}

fn start_server() {
    let listener = TcpListener::bind("127.0.0.1:8000").unwrap();

    fn handle_client(stream: TcpStream) {
        println!("Client connected");
        let mut writer = BufWriter::new(&stream);
        writer.write_all("Red".as_bytes());
        let mut reader = BufReader::new(&stream);
        let mut response = String::new();
        reader.read_to_string(&mut response);
        println!("Server received {}", response);

    }

// accept connections
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                handle_client(stream);
            }
            Err(e) => { panic!("{}",e) }
        }
    }
}

Solution

First off, don't ignore warnings. You have 4 errors of the type warning: unused result which must be used. Every single one of those could be cases where your code is failing and you wouldn't even know it. Use expect liberally!

Second, you have an open client read socket and you ask to "read all the data until the end into a string". What determines the end? In this case, it's when the socket is closed; so when is that?

Trick question!

The client's read socket closes when the server's write socket closes.
The server's write socket closes when the server's read socket closes.
The server's read socket closes when the the client's write socket closes.

So when does that happen? Because there's no code that does it specifically, it will close when the socket is dropped, so:

The client's write socket closes when the the client ends.

Thus the deadlock. The issue could be fixed by explicitly closing the write half of the socket:

stream.shutdown(std::net::Shutdown::Write).expect("could not shutdown");

Third, you are writing into a BufWriter. Review the documentation for it:

A BufWriter keeps an in-memory buffer of data and writes it to an underlying writer in large, infrequent batches.

The buffer will be written out when the writer is dropped.

The BufWriter is dropped at the end of the scope, after you've tried to read the response. That's another deadlock.

In the end, you need to establish a protocol for how to delimit messages sent back and forth. A simple but very limited solution is to have a line-oriented protocol: every message fits on one line ending with a newline character.

If you choose that, you can use read_to_line instead. I've also used BufWriter::flush to force the data to be sent down the wire; you could have also encapsulated writer in a block so it is dropped earlier or explicitly call drop(writer).

use std::net::{TcpListener, TcpStream};
use std::io::{BufReader, BufWriter, Write, BufRead};
use std::thread;

fn main() {
    thread::spawn(start_server);

    let player_stream = TcpStream::connect("127.0.0.1:8000").expect("Couldn't connect");

    let mut reader = BufReader::new(&player_stream);
    let mut response = String::new();
    reader.read_line(&mut response).expect("Could not read");
    println!("Player received >{}<", response.trim());

    let mut writer = BufWriter::new(&player_stream);
    writer.write_all("NAME\n".as_bytes()).expect("Could not write");
}

fn start_server() {
    let listener = TcpListener::bind("127.0.0.1:8000").unwrap();

    fn handle_client(stream: TcpStream) {
        println!("Client connected");

        let mut writer = BufWriter::new(&stream);
        writer.write_all("Red\n".as_bytes()).expect("could not write");
        writer.flush().expect("could not flush");

        let mut reader = BufReader::new(&stream);
        let mut response = String::new();
        reader.read_line(&mut response).expect("could not read");
        println!("Server received {}", response);
    }

    for stream in listener.incoming() {
        let stream = stream.expect("Unable to accept");
        handle_client(stream);
    }
}

You'll note that the program doesn't always print out the server's response. That's because the main thread exiting exits the program.

You mentioned that your real case uses XML, which can have newlines embedded in it, making a line-oriented protocol unsuitable. Another common protocol is to send a length before sending the data itself. There are many possible implementations for this. At a previous job, we sent XML in this fashion. We started with an ASCII-encoded newline-terminated string of the length before the data itself. In that case, having the readability of the length as a string was a benefit. You could also choose to send a number of bytes that can be interpreted according to some endianness as a 2's compliment number.