need help with client + server in single threaded runtime

[JimitSoni18]

I have a test that goes like this:

	#[test]
	fn test_read_and_write() {
		let fx_msg = String::from("Hi, this is sample text");

		tokio::runtime::Builder::new_multi_thread()
			.enable_all()
			.build()
			.unwrap()
			.block_on(async {
				let client_join = async {
					let config = ServerConfig::builder()
						.with_bind_default(4433)
						.with_identity(
							&Identity::load_pemfiles(
								"certs/cert.pem",
								"certs/key.pem",
							)
							.await
							.unwrap(),
						)
						.build();

					let server = Endpoint::server(config).unwrap();

					let connection = server
						.accept()
						.await
						.await
						.unwrap()
						.accept()
						.await
						.unwrap();
					let (mut send, _) = connection.accept_bi().await.unwrap();
					send.write_message(fx_msg).await.unwrap();
				};

				let server_join = async {
					let client =
						Endpoint::client(ClientConfig::default()).unwrap();
					let connection =
						client.connect("https://localhost:4433").await.unwrap();
					let (_, mut recv) =
						connection.open_bi().await.unwrap().await.unwrap();
					let msg = recv.read_message().await.unwrap();
					let s = std::str::from_utf8(&msg).unwrap();
					println!("msg: {s}");
				};

				tokio::join!(client_join, server_join);
			})
	}

this test builds a multi threaded runtime in tokio, creates a server future and a client future, joins the futures, sends a message from the client, reads in the server, asserts and exits.
this test runs without issues.

but when i use a single threaded runtime using new_current_thread instead of new_multi_thread or by annotating the test with tokio::test (which uses the current_thread runtime) and removing the runtime builder code, and then run the test, the test starts failing.
i try to spawn the async blocks using tokio::spawn both server and client, and joining the returned JoinHandles, instead of directly joining, the test still fails.

The error is as follows:

running 1 test
thread 'framing::tests::test_read_and_write' panicked at src/framing/mod.rs:247:49:
called `Result::unwrap()` on an `Err` value: TransportError(Read(NotConnected))
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
test framing::tests::test_read_and_write ... FAILED

failures:

failures:
    framing::tests::test_read_and_write

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 1.03s

error: test failed, to rerun pass `--lib`

which means that either the server or the client drops the connection before the message is sent.

i add printlns at the end and start of the client and server async blocks and here is the output:

running 1 test
=====>> client started
=====>> server started
=====>> client ended
thread 'framing::tests::test_read_and_write' panicked at src/framing/mod.rs:250:49:
called `Result::unwrap()` on an `Err` value: TransportError(Read(NotConnected))
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
test framing::tests::test_read_and_write ... FAILED

This shows that the client writes the message and exits dropping the connection, and the server calls unwrap without reading the message.

but if this is the case, then it should not work in multi threaded runtime as well, - as the client should drop the connection as soon as it writes the message, so i switch to multi threaded, with the print statements in place, and run it.
Here is the output:

running 1 test
client started
server started
client ended
msg: Hi, this is sample text
server ended
test framing::tests::test_read_and_write ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 1.03s

   Doc-tests transport_io

Similar to the current thread runtime, the client writes and then exits, but the server is still able to read the message after the client has exited.
This makes me wonder - What goes wrong in the current_thread runtime?

Note: The functions read_message and write_message are implemented in this repository, in the MessageReader and MessageWriter traits.

[BiagioFesta]

Thank you for bringing this. I was able to reproduce it.

From network analysis, it seems there is a difference in the I/O driver between single and multi-thread runtime.
It seems in the single thread version, the server does not send the packet.

I did not have time yet to look deep into this.

I will do it asap

[JimitSoni18]

Thanks!