refactor(eventloop): rename the thread

src/core/eventloop.rs

@@ -1,4 +1,5 @@
 use super::client::Client;
+use anyhow::{anyhow, Result};
 use libstardustxr::server;
 use mio::net::UnixListener;
 use mio::unix::pipe;
@@ -8,8 +9,6 @@ use slab::Slab;
 use std::io::Write;
 use std::thread::{self, JoinHandle};
 
-use anyhow::Result;
-
 pub struct EventLoop {
 	pub socket_path: String,
 	join_handle: Option<JoinHandle<Result<()>>>,
@@ -22,63 +21,66 @@ impl EventLoop {
 			.ok_or_else(|| std::io::Error::from(std::io::ErrorKind::Other))?;
 		let mut socket = UnixListener::bind(socket_path.clone())?;
 		let (sender, mut receiver) = pipe::new()?;
-		let join_handle = Some(thread::spawn(move || -> Result<()> {
+		let join_handle = thread::Builder::new()
-			let mut clients: Slab<Option<RcCell<Client>>> = Slab::new();
+			.name("event_loop".to_owned())
-			let mut poll = Poll::new()?;
+			.spawn(move || -> Result<()> {
-			let mut events = Events::with_capacity(1024);
+				let mut clients: Slab<Option<RcCell<Client>>> = Slab::new();
-			const LISTENER: Token = Token(usize::MAX - 1);
+				let mut poll = Poll::new()?;
-			poll.registry()
+				let mut events = Events::with_capacity(1024);
-				.register(&mut socket, LISTENER, Interest::READABLE)?;
+				const LISTENER: Token = Token(usize::MAX - 1);
-			const STOP: Token = Token(usize::MAX);
+				poll.registry()
-			poll.registry()
+					.register(&mut socket, LISTENER, Interest::READABLE)?;
-				.register(&mut receiver, STOP, Interest::READABLE)?;
+				const STOP: Token = Token(usize::MAX);
-			loop {
+				poll.registry()
-				poll.poll(&mut events, timeout)?;
+					.register(&mut receiver, STOP, Interest::READABLE)?;
-				for event in &events {
+				loop {
-					match event.token() {
+					poll.poll(&mut events, timeout)?;
-						LISTENER => loop {
+					for event in &events {
-							match socket.accept() {
+						match event.token() {
-								Ok((mut socket, _)) => {
+							LISTENER => loop {
-									let client_number = clients.insert(None);
+								match socket.accept() {
-									poll.registry().register(
+									Ok((mut socket, _)) => {
-										&mut socket,
+										let client_number = clients.insert(None);
-										Token(client_number),
+										poll.registry().register(
-										Interest::READABLE,
+											&mut socket,
-									)?;
+											Token(client_number),
-									let client = Client::from_connection(socket);
+											Interest::READABLE,
-									*clients.get_mut(client_number).unwrap() = Some(client);
+										)?;
-								}
+										let client = Client::from_connection(socket);
-								Err(e) => {
+										*clients.get_mut(client_number).unwrap() = Some(client);
-									if e.kind() == std::io::ErrorKind::WouldBlock {
-										break;
 									}
-									return Err(e.into());
+									Err(e) => {
-								}
+										if e.kind() == std::io::ErrorKind::WouldBlock {
-							}
+											break;
-						},
+										}
-						STOP => return Ok(()),
+										return Err(e.into());
-						token => loop {
-							match clients
-								.get(token.0)
-								.unwrap()
-								.as_ref()
-								.unwrap()
-								.borrow()
-								.dispatch()
-							{
-								Ok(_) => continue,
-								Err(e) => {
-									if e.kind() == std::io::ErrorKind::WouldBlock {
-										break;
 									}
-									return Err(e.into());
 								}
-							}
+							},
-						},
+							STOP => return Ok(()),
+							token => loop {
+								match clients
+									.get(token.0)
+									.unwrap()
+									.as_ref()
+									.unwrap()
+									.borrow()
+									.dispatch()
+								{
+									Ok(_) => continue,
+									Err(e) => {
+										if e.kind() == std::io::ErrorKind::WouldBlock {
+											break;
+										}
+										return Err(e.into());
+									}
+								}
+							},
+						}
 					}
 				}
-			}
+			})
-		}));
+			.ok();
 		Ok(EventLoop {
 			socket_path,
 			join_handle,
@@ -94,8 +96,7 @@ impl Drop for EventLoop {
 		let _ = self
 			.join_handle
 			.take()
-			.unwrap()
+			.map(|handle| handle.join())
-			.join()
 			.expect("Couldn't join the event loop thread at drop");
 	}
 }