From badc32e2332d4725d13c460b5279d4009ccea023 Mon Sep 17 00:00:00 2001 From: Eva Date: Mon, 4 Oct 2021 16:04:02 +0300 Subject: [PATCH] server-side fixes (#21) * some fixes, send_packet as a function * network fixes - client doesn't spam anymore - remove ip from allowed list --- client/src/network.rs | 16 +- server/Cargo.toml | 1 + server/src/lib.rs | 124 ++++++++---- server/src/server.rs | 449 +++++++++++++++++------------------------- server/src/utils.rs | 26 +-- 5 files changed, 290 insertions(+), 326 deletions(-) diff --git a/client/src/network.rs b/client/src/network.rs index 7a1945b..302b2df 100644 --- a/client/src/network.rs +++ b/client/src/network.rs @@ -77,6 +77,13 @@ impl ConnectionState { _ => None, } } + + fn is_auth(&self) -> bool { + match self { + ConnectionState::Auth(_, _, _) => true, + _ => false, + } + } } struct Network { @@ -381,13 +388,14 @@ impl Network { } } - // SocketEvent::Connected() => log::trace!("connect? {}", addr), // what? SocketEvent::Disconnect(peer, addr) => { if peer == server_peer { log::trace!("CEF Network: Timeout"); handle_result(self.event_tx.send(Event::Timeout)); - self.net_open_connection(self.connection_state.addr().unwrap()); + if !self.connection_state.is_auth() { + self.net_open_connection(self.connection_state.addr().unwrap()); + } } } @@ -395,7 +403,9 @@ impl Network { log::trace!("CEF Network: ConnectionError"); handle_result(self.event_tx.send(Event::Timeout)); - self.net_open_connection(self.connection_state.addr().unwrap()); + if !self.connection_state.is_auth() { + self.net_open_connection(self.connection_state.addr().unwrap()); + } } _ => (), diff --git a/server/Cargo.toml b/server/Cargo.toml index 75dadf4..5322167 100644 --- a/server/Cargo.toml +++ b/server/Cargo.toml @@ -14,3 +14,4 @@ crossbeam-channel = "0.5.1" messages = { path = "../messages" } quick-protobuf = "0.8.0" network = { path = "../network" } +simplelog = "0.10.2" diff --git a/server/src/lib.rs b/server/src/lib.rs index 7c9137a..90f78e5 100644 --- a/server/src/lib.rs +++ b/server/src/lib.rs @@ -3,7 +3,10 @@ use std::net::{IpAddr, SocketAddr}; use std::sync::{Arc, Mutex}; use std::time::{Duration, Instant}; -use log::info; +use crossbeam_channel::Receiver; +use log::{info, trace}; +use messages::packets::EventValue; +// use simplelog::{CombinedLogger, LevelFilter, TermLogger, TerminalMode}; use samp::amx::AmxIdent; use samp::args::Args; @@ -14,20 +17,23 @@ mod client; mod server; mod utils; -use messages::packets::EventValue; - use crate::server::Server; -use crate::utils::{handle_result, IdPool}; - -use crossbeam_channel::Receiver; -const INIT_TIMEOUT: Duration = Duration::from_secs(10); +const INIT_TIMEOUT: Duration = Duration::from_secs(5); const PORT_OFFSET: u16 = 2; pub enum Event { - EmitEvent(i32, String, String), - Connected(i32), - BrowserCreated(i32, u32, i32), + EmitEvent { + player_id: i32, + event: String, + arguments: String, + }, + PlayerConnected(i32), + BrowserCreated { + player_id: i32, + browser_id: u32, + code: i32, + }, } struct CefPlugin { @@ -36,6 +42,7 @@ struct CefPlugin { event_rx: Receiver, amx_list: Vec, await_connect: HashMap, + ips: HashMap, } impl CefPlugin { @@ -60,6 +67,7 @@ impl CefPlugin { events: HashMap::new(), amx_list: Vec::new(), await_connect: HashMap::new(), + ips: HashMap::new(), } } @@ -69,7 +77,11 @@ impl CefPlugin { ) -> AmxResult { let player_ip = player_ip.to_string(); - if let Ok(addr) = player_ip.parse() { + if let Ok(addr) = player_ip.parse::() { + trace!("allow_connection {} {:?}", player_id, addr); + + self.ips.insert(player_id, addr.clone()); + { let mut server = self.server.lock().unwrap(); server.allow_connection(player_id, addr); @@ -83,9 +95,13 @@ impl CefPlugin { #[native(name = "cef_on_player_disconnect")] fn on_player_disconnect(&mut self, _: &Amx, player_id: i32) -> AmxResult { + trace!("remove_connection {} ", player_id); + + let ip = self.ips.remove(&player_id); + { let mut server = self.server.lock().unwrap(); - server.remove_connection(player_id); + server.remove_connection(player_id, ip); } self.remove_from_await_list(player_id); @@ -116,7 +132,7 @@ impl CefPlugin { fn hide_browser( &mut self, _: &Amx, player_id: i32, browser_id: i32, hide: bool, ) -> AmxResult { - let mut server = self.server.lock().unwrap(); + let server = self.server.lock().unwrap(); server.hide_browser(player_id, browser_id, hide); Ok(true) @@ -126,14 +142,14 @@ impl CefPlugin { fn browser_listen_events( &mut self, _: &Amx, player_id: i32, browser_id: i32, focused: bool, ) -> AmxResult { - let mut server = self.server.lock().unwrap(); + let server = self.server.lock().unwrap(); server.focus_browser(player_id, browser_id, focused); Ok(true) } #[native(name = "cef_emit_event", raw)] - fn emit_event(&mut self, _: &Amx, mut args: Args) -> AmxResult { + fn emit_event(&mut self, _: &Amx, args: Args) -> AmxResult { if args.count() < 2 || (args.count() - 2) % 2 != 0 { info!("cef_emit_event invalid count of arguments"); return Ok(false); @@ -184,7 +200,7 @@ impl CefPlugin { } } - let mut server = self.server.lock().unwrap(); + let server = self.server.lock().unwrap(); server.emit_event(player_id, &event_name, arguments); Ok(true) @@ -194,7 +210,7 @@ impl CefPlugin { fn block_input( &mut self, _: &Amx, player_id: i32, browser_id: i32, listen: bool, ) -> AmxResult { - let mut server = self.server.lock().unwrap(); + let server = self.server.lock().unwrap(); server.always_listen_keys(player_id, browser_id, listen); Ok(true) @@ -228,7 +244,7 @@ impl CefPlugin { let texture = texture.to_string(); let url = url.to_string(); - let mut server = self.server.lock().unwrap(); + let server = self.server.lock().unwrap(); server.create_external_browser(player_id, browser_id, texture, url, scale); Ok(true) @@ -238,7 +254,7 @@ impl CefPlugin { fn append_to_object( &mut self, _: &Amx, player_id: i32, browser_id: i32, object_id: i32, ) -> AmxResult { - let mut server = self.server.lock().unwrap(); + let server = self.server.lock().unwrap(); server.append_to_object(player_id, browser_id, object_id); Ok(true) } @@ -247,7 +263,7 @@ impl CefPlugin { fn remove_from_object( &mut self, _: &Amx, player_id: i32, browser_id: i32, object_id: i32, ) -> AmxResult { - let mut server = self.server.lock().unwrap(); + let server = self.server.lock().unwrap(); server.remove_from_object(player_id, browser_id, object_id); Ok(true) } @@ -256,7 +272,7 @@ impl CefPlugin { fn toggle_dev_tools( &mut self, _: &Amx, player_id: i32, browser_id: i32, enabled: bool, ) -> AmxResult { - let mut server = self.server.lock().unwrap(); + let server = self.server.lock().unwrap(); server.toggle_dev_tools(player_id, browser_id, enabled); Ok(true) } @@ -266,7 +282,7 @@ impl CefPlugin { &mut self, _: &Amx, player_id: i32, browser_id: u32, max_distance: f32, reference_distance: f32, ) -> AmxResult { - let mut server = self.server.lock().unwrap(); + let server = self.server.lock().unwrap(); server.set_audio_settings(player_id, browser_id, max_distance, reference_distance); Ok(true) } @@ -276,7 +292,7 @@ impl CefPlugin { &mut self, _: &Amx, player_id: i32, browser_id: u32, url: AmxString, ) -> AmxResult { let url = url.to_string(); - let mut server = self.server.lock().unwrap(); + let server = self.server.lock().unwrap(); server.load_url(player_id, browser_id, url); @@ -294,11 +310,20 @@ impl CefPlugin { } } - keys.into_iter() - .for_each(|player_id| self.remove_from_await_list(player_id)); + keys.into_iter().for_each(|player_id| { + let result = self.remove_from_await_list(player_id); + + trace!( + "notify_timeout::remove_from_await_list({}) {}", + player_id, + result + ); + }); } fn notify_connect(&self, player_id: i32, success: bool) { + trace!("notify_connect({}, {})", player_id, success); + self.amx_list.iter().for_each(|&ident| { samp::amx::get(ident) .map(|amx| exec_public!(amx, "OnCefInitialize", player_id, success)); @@ -316,8 +341,8 @@ impl CefPlugin { self.await_connect.insert(player_id, Instant::now()); } - fn remove_from_await_list(&mut self, player_id: i32) { - self.await_connect.remove(&player_id); + fn remove_from_await_list(&mut self, player_id: i32) -> bool { + self.await_connect.remove(&player_id).is_some() } } @@ -341,21 +366,35 @@ impl SampPlugin for CefPlugin { fn process_tick(&mut self) { while let Ok(event) = self.event_rx.try_recv() { match event { - Event::EmitEvent(player, event, args) => { + Event::EmitEvent { + player_id, + event, + arguments, + } => { + trace!("process_tick::EmitEvent({}) {}", player_id, event); + if let Some((ident, cb)) = self.events.get(&event) { samp::amx::get(*ident) - .map(|amx| exec_public!(amx, &cb, player, &args => string)); + .map(|amx| exec_public!(amx, &cb, player_id, &arguments => string)); } } - Event::Connected(player) => { - println!("Event::Connected({})", player); - self.notify_connect(player, true); - self.remove_from_await_list(player); + Event::PlayerConnected(player) => { + trace!("process_tick::PlayerConnected({})", player); + + if self.remove_from_await_list(player) { + self.notify_connect(player, true); + } } - Event::BrowserCreated(player, browser, code) => { - self.notify_browser_created(player, browser, code); + Event::BrowserCreated { + player_id, + browser_id, + code, + } => { + trace!("process_tick::BrowserCreated({})", player_id); + + self.notify_browser_created(player_id, browser_id, code); } _ => (), @@ -390,6 +429,21 @@ initialize_plugin!( samp::encoding::set_default_encoding(samp::encoding::WINDOWS_1251); let _ = samp::plugin::logger(); // fuck logger + // let mut config = simplelog::ConfigBuilder::new(); + + // let config = config + // .add_filter_allow_str("server") + // .set_max_level(LevelFilter::Trace) + // .build(); + + // CombinedLogger::init(vec![TermLogger::new( + // LevelFilter::Trace, + // config, + // TerminalMode::Mixed, + // simplelog::ColorChoice::Always, + // )]) + // .unwrap(); + let plugin = CefPlugin::new(); return plugin; } diff --git a/server/src/server.rs b/server/src/server.rs index 6b6d88a..f10594e 100644 --- a/server/src/server.rs +++ b/server/src/server.rs @@ -1,9 +1,11 @@ use crossbeam_channel::{Receiver, Sender}; +use log::trace; use messages::{packets, try_into_packet}; use network::{CertStrategy, Event as SocketEvent, PeerId, Socket}; use quick_protobuf::deserialize_from_slice; use std::collections::HashMap; +use std::convert::TryInto; use std::net::{IpAddr, SocketAddr}; use std::sync::{Arc, Mutex}; use std::time::Duration; @@ -13,7 +15,7 @@ use crate::Event; enum Packet { Normal { peer: PeerId, bytes: Vec }, - Disonnect(PeerId), + Disconnect(PeerId), } impl Packet { @@ -22,7 +24,7 @@ impl Packet { } fn disconnect(peer: PeerId) -> Packet { - Packet::Disonnect(peer) + Packet::Disconnect(peer) } } @@ -82,7 +84,10 @@ impl Server { for packet in receiver.try_iter() { match packet { Packet::Normal { peer, bytes } => socket.send_message(peer, bytes), - Packet::Disonnect(peer) => socket.disconnect(peer), + Packet::Disconnect(peer) => { + trace!("socket::disconnect {:?}", peer); + socket.disconnect(peer); + } } } @@ -92,8 +97,6 @@ impl Server { server_clone } - // voice server side - /// обработка пакетов от клиентов fn handle_client_packet(&mut self, peer: PeerId, packet: packets::Packet) { use messages::packets::PacketId; @@ -105,16 +108,17 @@ impl Server { match packet.packet_id { PacketId::REQUEST_JOIN => { - deserialize_from_slice(&packet.bytes).map(|packet| self.handle_auth(peer, packet)); + let _ = deserialize_from_slice(&packet.bytes) + .map(|packet| self.handle_auth(peer, packet)); } PacketId::EMIT_EVENT => { - deserialize_from_slice(&packet.bytes) + let _ = deserialize_from_slice(&packet.bytes) .map(|packet| self.handle_emit_event(peer, packet)); } PacketId::BROWSER_CREATED => { - deserialize_from_slice(&packet.bytes) + let _ = deserialize_from_slice(&packet.bytes) .map(|packet| self.handle_browser_created(peer, packet)); } @@ -123,7 +127,7 @@ impl Server { } /// обработка пакета авторизации - fn handle_auth(&mut self, peer: PeerId, packet: packets::RequestJoin) { + fn handle_auth(&mut self, peer: PeerId, _packet: packets::RequestJoin) { let client = self.clients.get_mut(&peer).unwrap(); // safe let response = packets::JoinResponse { @@ -133,11 +137,11 @@ impl Server { client.set_state(crate::client::State::Connected); - self.event_tx.send(Event::Connected(client.id())); + let _ = self.event_tx.send(Event::PlayerConnected(client.id())); - try_into_packet(response).map(|bytes| { + let _ = try_into_packet(response).map(|bytes| { let packet = Packet::new(peer, bytes); - self.sender.send(packet); + let _ = self.sender.send(packet); }); } @@ -146,11 +150,15 @@ impl Server { let player_id = client.id(); if let Some(args) = &packet.args { - let event_name = packet.event_name.to_string(); - let args = args.to_string(); - let event = Event::EmitEvent(player_id, event_name, args); - - self.event_tx.send(event); + let event = packet.event_name.to_string(); + let arguments = args.to_string(); + let event = Event::EmitEvent { + player_id, + arguments, + event, + }; + + let _ = self.event_tx.send(event); } } @@ -158,180 +166,142 @@ impl Server { let client = self.clients.get_mut(&peer).unwrap(); // safe let player_id = client.id(); - let event = Event::BrowserCreated(player_id, packet.browser_id, packet.status_code); - self.event_tx.send(event); + let event = Event::BrowserCreated { + player_id, + browser_id: packet.browser_id, + code: packet.status_code, + }; + + let _ = self.event_tx.send(event); } /// выпинываем игрока из списка клиентов fn handle_timeout(&mut self, addr: PeerId) { + trace!("handle_timeout {:?}", addr); self.clients.remove(&addr); + + trace!("{:#?}", self.allowed); + trace!("{:#?}", self.clients); } /// обрабатывает новое входящее соединение fn handle_new_connection(&mut self, peer: PeerId, addr: SocketAddr) { + trace!("handle_new_connection {:?} {:?}", peer, addr); + if !self.clients.contains_key(&peer) && self.allowed.contains_key(&addr.ip()) { - let player_id = self.allowed.get(&addr.ip()).unwrap(); - let client = Client::new(player_id.clone(), peer, addr); + let player_id = *self.allowed.get(&addr.ip()).unwrap(); - self.clients.insert(peer, client); + trace!("handle_new_connection: ok {}", player_id); - let request = packets::OpenConnection {}; + if self.peer_by_id(player_id).is_none() { + trace!("handle_new_connection: ok no peer with this id"); - try_into_packet(request).map(|bytes| { - let packet = Packet::new(peer, bytes); - self.sender.send(packet); - }); - } else { - let packet = Packet::disconnect(peer); - let _ = self.sender.send(packet); + let client = Client::new(player_id, peer, addr); + + self.clients.insert(peer, client); + + let request = packets::OpenConnection {}; + + let _ = try_into_packet(request).map(|bytes| { + let packet = Packet::new(peer, bytes); + let _ = self.sender.send(packet); + }); + + return; + } } + + let packet = Packet::disconnect(peer); + let _ = self.sender.send(packet); } // samp server side pub fn allow_connection(&mut self, player_id: i32, addr: IpAddr) { + if let Some(peer) = self.peer_by_id(player_id) { + self.clients.remove(&peer); + } + self.allowed.insert(addr, player_id); } - pub fn remove_connection(&mut self, player_id: i32) { - let addr = self.peer_by_id(player_id); + pub fn remove_connection(&mut self, player_id: i32, addr: Option) { + let peer = self.peer_by_id(player_id); - if let Some(addr) = addr { - if let Some(client) = self.clients.remove(&addr) { + if let Some(peer) = peer { + if let Some(client) = self.clients.remove(&peer) { self.allowed.remove(&client.addr().ip()); - let _ = self.sender.send(Packet::Disonnect(client.peer())); + let _ = self.sender.send(Packet::Disconnect(client.peer())); } } + + if let Some(addr) = addr { + self.allowed.remove(&addr); + } } pub fn create_browser( &mut self, player_id: i32, browser_id: i32, url: String, hidden: bool, focused: bool, ) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; - - clients.get_mut(&addr).map(|client| { - let packet = packets::CreateBrowser { - browser_id: browser_id as u32, - url: url.into(), - hidden, - focused, - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + self.send_packet( + player_id, + packets::CreateBrowser { + browser_id: browser_id as u32, + url: url.into(), + hidden, + focused, + }, + ); } pub fn destroy_browser(&mut self, player_id: i32, browser_id: i32) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; - - clients.get_mut(&addr).map(|client| { - let packet = packets::DestroyBrowser { - browser_id: browser_id as u32, - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + self.send_packet( + player_id, + packets::DestroyBrowser { + browser_id: browser_id as u32, + }, + ); } - pub fn hide_browser(&mut self, player_id: i32, browser_id: i32, hide: bool) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; - - clients.get_mut(&addr).map(|client| { - let packet = packets::HideBrowser { - browser_id: browser_id as u32, - hide, - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + pub fn hide_browser(&self, player_id: i32, browser_id: i32, hide: bool) { + self.send_packet( + player_id, + packets::HideBrowser { + browser_id: browser_id as u32, + hide, + }, + ); } - pub fn focus_browser(&mut self, player_id: i32, browser_id: i32, focused: bool) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; - - clients.get_mut(&addr).map(|client| { - let packet = packets::FocusBrowser { - browser_id: browser_id as u32, - focused, - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + pub fn focus_browser(&self, player_id: i32, browser_id: i32, focused: bool) { + self.send_packet( + player_id, + packets::FocusBrowser { + browser_id: browser_id as u32, + focused, + }, + ); } - pub fn emit_event(&mut self, player_id: i32, event: &str, arguments: Vec) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; - - clients.get_mut(&addr).map(|client| { - let packet = packets::EmitEvent { - event_name: event.into(), - args: None, - arguments, - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + pub fn emit_event(&self, player_id: i32, event: &str, arguments: Vec) { + self.send_packet( + player_id, + packets::EmitEvent { + event_name: event.into(), + args: None, + arguments, + }, + ); } - pub fn always_listen_keys(&mut self, player_id: i32, browser_id: i32, listen: bool) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; - - clients.get_mut(&addr).map(|client| { - let packet = packets::AlwaysListenKeys { - browser_id: browser_id as u32, - listen, - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + pub fn always_listen_keys(&self, player_id: i32, browser_id: i32, listen: bool) { + self.send_packet( + player_id, + packets::AlwaysListenKeys { + browser_id: browser_id as u32, + listen, + }, + ); } pub fn has_plugin(&self, player_id: i32) -> bool { @@ -341,144 +311,97 @@ impl Server { } pub fn create_external_browser( - &mut self, player_id: i32, browser_id: i32, texture: String, url: String, scale: i32, + &self, player_id: i32, browser_id: i32, texture: String, url: String, scale: i32, ) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; - - clients.get_mut(&addr).map(|client| { - let packet = packets::CreateExternalBrowser { - browser_id: browser_id as u32, - url: url.into(), - texture: texture.into(), - scale, - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + self.send_packet( + player_id, + packets::CreateExternalBrowser { + browser_id: browser_id as u32, + url: url.into(), + texture: texture.into(), + scale, + }, + ); } - pub fn append_to_object(&mut self, player_id: i32, browser_id: i32, object_id: i32) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; - - clients.get_mut(&addr).map(|client| { - let packet = packets::AppendToObject { - browser_id: browser_id as u32, - object_id, - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + pub fn append_to_object(&self, player_id: i32, browser_id: i32, object_id: i32) { + self.send_packet( + player_id, + packets::AppendToObject { + browser_id: browser_id as u32, + object_id, + }, + ); } - pub fn remove_from_object(&mut self, player_id: i32, browser_id: i32, object_id: i32) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; - - clients.get_mut(&addr).map(|client| { - let packet = packets::RemoveFromObject { - browser_id: browser_id as u32, - object_id, - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + pub fn remove_from_object(&self, player_id: i32, browser_id: i32, object_id: i32) { + self.send_packet( + player_id, + packets::RemoveFromObject { + browser_id: browser_id as u32, + object_id, + }, + ); } - pub fn toggle_dev_tools(&mut self, player_id: i32, browser_id: i32, enabled: bool) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; - - clients.get_mut(&addr).map(|client| { - let packet = packets::ToggleDevTools { - browser_id: browser_id as u32, - enabled, - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + pub fn toggle_dev_tools(&self, player_id: i32, browser_id: i32, enabled: bool) { + self.send_packet( + player_id, + packets::ToggleDevTools { + browser_id: browser_id as u32, + enabled, + }, + ); } pub fn set_audio_settings( - &mut self, player_id: i32, browser_id: u32, max_distance: f32, reference_distance: f32, + &self, player_id: i32, browser_id: u32, max_distance: f32, reference_distance: f32, ) { - if let Some(addr) = self.peer_by_id(player_id) { - let Server { - ref mut clients, - ref mut sender, - .. - } = self; + self.send_packet( + player_id, + packets::SetAudioSettings { + browser_id, + max_distance, + reference_distance, + }, + ); + } - clients.get_mut(&addr).map(|client| { - let packet = packets::SetAudioSettings { - browser_id, - max_distance, - reference_distance, - }; + pub fn load_url(&self, player_id: i32, browser_id: u32, url: String) { + self.send_packet( + player_id, + packets::LoadUrl { + browser_id, + url: url.into(), + }, + ); + } - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); - }); - } + pub fn receiver(&self) -> Receiver { + self.event_rx.clone() } - pub fn load_url(&mut self, player_id: i32, browser_id: u32, url: String) { + // utils + + fn send_packet<'a, T: TryInto, Error = quick_protobuf::Error>>( + &self, player_id: i32, packet: T, + ) { if let Some(addr) = self.peer_by_id(player_id) { let Server { - ref mut clients, - ref mut sender, + ref clients, + ref sender, .. } = self; - clients.get_mut(&addr).map(|client| { - let packet = packets::LoadUrl { - browser_id, - url: url.into(), - }; - - let bytes = try_into_packet(packet).unwrap(); - let packet = Packet::new(client.peer(), bytes); - sender.send(packet); + clients.get(&addr).map(|client| { + if let Ok(bytes) = try_into_packet(packet) { + let packet = Packet::new(client.peer(), bytes); + let _ = sender.send(packet); + } }); } } - pub fn receiver(&self) -> Receiver { - self.event_rx.clone() - } - - // utils - fn peer_by_id(&self, player_id: i32) -> Option { self.clients .iter() diff --git a/server/src/utils.rs b/server/src/utils.rs index 3a7bf3e..2a84290 100644 --- a/server/src/utils.rs +++ b/server/src/utils.rs @@ -1,29 +1,5 @@ use log::error; -use std::{collections::VecDeque, str::FromStr}; - -pub struct IdPool { - pool: VecDeque, -} - -impl IdPool { - pub fn new(capacity: usize) -> IdPool { - let mut vec = VecDeque::with_capacity(capacity); - - for i in 0..capacity { - vec.push_back(i as u32); - } - - IdPool { pool: vec } - } - - pub fn get(&mut self) -> Option { - self.pool.pop_front() - } - - pub fn reset(&mut self, value: u32) { - self.pool.push_back(value); - } -} +use std::str::FromStr; pub fn handle_result(result: Result) -> Option { if let Err(err) = result.as_ref() {