library

Online co-op book organization video game
git clone https://git.bradleygannon.com/library.git
Log | Files | Refs

net.rs (2514B)

      1 use std::{
      2     collections::LinkedList,
      3     sync::{
      4         Arc, Mutex,
      5         mpsc::{Receiver, Sender, channel},
      6     },
      7     thread::{self, JoinHandle},
      8     time::Duration,
      9 };
     10 
     11 use common::{
     12     game::{Action, Response},
     13     net::{handle_network_read, handle_network_write},
     14 };
     15 use mio::{
     16     Events, Interest, Poll, Token,
     17     net::{TcpListener, TcpStream},
     18 };
     19 use uuid::Uuid;
     20 
     21 const TOKEN: Token = Token(0);
     22 
     23 #[derive(Debug)]
     24 pub(crate) struct Client {
     25     pub(crate) id: Option<Uuid>,
     26     pub(crate) thread: JoinHandle<()>,
     27     pub(crate) tx: Sender<Response>,
     28     pub(crate) sequence_number: u32,
     29 }
     30 
     31 impl Client {
     32     fn new(
     33         stream: TcpStream,
     34         client_to_main_tx: Sender<Action>,
     35         main_to_client_tx: Sender<Response>,
     36         main_to_client_rx: Receiver<Response>,
     37     ) -> Self {
     38         Client {
     39             id: None,
     40             thread: thread::spawn(|| handle_client(stream, main_to_client_rx, client_to_main_tx)),
     41             tx: main_to_client_tx,
     42             sequence_number: 0,
     43         }
     44     }
     45 }
     46 
     47 pub(crate) fn listen(clients: Arc<Mutex<LinkedList<Client>>>, tx: Sender<Action>) {
     48     let mut poll = Poll::new().unwrap();
     49     let mut events = Events::with_capacity(128);
     50     let mut listener = TcpListener::bind("0.0.0.0:6767".parse().unwrap()).unwrap();
     51     poll.registry()
     52         .register(&mut listener, TOKEN, Interest::READABLE)
     53         .unwrap();
     54     loop {
     55         poll.poll(&mut events, None).unwrap();
     56         for _ in events.iter() {
     57             let (stream, _addr) = listener.accept().unwrap();
     58             let (main_to_client_tx, main_to_client_rx) = channel();
     59             clients.lock().unwrap().push_back(Client::new(
     60                 stream,
     61                 tx.clone(),
     62                 main_to_client_tx,
     63                 main_to_client_rx,
     64             ));
     65         }
     66     }
     67 }
     68 
     69 fn handle_client(mut stream: TcpStream, rx: Receiver<Response>, tx: Sender<Action>) {
     70     let poll = Poll::new().unwrap();
     71     poll.registry()
     72         .register(&mut stream, TOKEN, Interest::READABLE)
     73         .unwrap();
     74     let shared_stream = Arc::new(Mutex::new(stream));
     75     let shared_stream_read = shared_stream.clone();
     76     let shared_stream_write = shared_stream.clone();
     77     let read_thread = thread::spawn(|| handle_network_read(poll, shared_stream_read, tx));
     78     let write_thread = thread::spawn(|| handle_network_write(shared_stream_write, rx));
     79     while !read_thread.is_finished() && !write_thread.is_finished() {
     80         thread::sleep(Duration::from_millis(500));
     81     }
     82 }