feat: basic client

src/core/eventloop.rs

@@ -1,21 +1,81 @@
-use libstardustxr::fusion::client::Client;
+use super::client::Client;
 use libstardustxr::server;
 use mio::net::UnixListener;
+use mio::unix::pipe;
+use mio::{Events, Interest, Poll, Token};
 use slab::Slab;
+use std::io::Write;
+use std::thread::{self, JoinHandle};
 
-pub struct EventLoop<'a> {
+use anyhow::Result;
+
+pub struct EventLoop {
 	pub socket_path: String,
-	listener: UnixListener,
-	clients: Slab<Client<'a>>,
+	join_handle: Option<JoinHandle<Result<()>>>,
+	stop_write: pipe::Sender,
 }
 
-impl<'a> EventLoop<'a> {
-	pub fn new() -> Option<Self> {
-		let socket_path = server::get_free_socket_path()?;
-		Some(EventLoop {
-			listener: UnixListener::bind(socket_path.clone()).ok()?,
+impl EventLoop {
+	pub fn new(timeout: Option<core::time::Duration>) -> Result<Self> {
+		let socket_path = server::get_free_socket_path()
+			.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 mut clients: Slab<Client> = Slab::new();
+			let mut poll = Poll::new()?;
+			let mut events = Events::with_capacity(1024);
+			const LISTENER: Token = Token(usize::MAX - 1);
+			poll.registry()
+				.register(&mut socket, LISTENER, Interest::READABLE)?;
+			const STOP: Token = Token(usize::MAX);
+			poll.registry()
+				.register(&mut receiver, STOP, Interest::READABLE)?;
+			loop {
+				poll.poll(&mut events, timeout)?;
+				for event in &events {
+					match event.token() {
+						LISTENER => loop {
+							match socket.accept() {
+								Ok((socket, _)) => {
+									clients.insert(Client::from_connection(socket));
+								}
+								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().dispatch() {
+								Ok(_) => continue,
+								Err(e) => {
+									if e.kind() == std::io::ErrorKind::WouldBlock {
+										break;
+									}
+									return Err(e.into());
+								}
+							}
+						},
+					}
+				}
+			}
+		}));
+		Ok(EventLoop {
 			socket_path,
-			clients: Slab::new(),
+			join_handle,
+			stop_write: sender,
 		})
 	}
 }
+
+impl Drop for EventLoop {
+	fn drop(&mut self) {
+		let buf: [u8; 1] = [1; 1];
+		let _ = self.stop_write.write(buf.as_slice());
+		let _ = self.join_handle.take().unwrap().join();
+	}
+}