From b0c8340b9fc9ec0007f33f49562ec5c10adb1d5d Mon Sep 17 00:00:00 2001 From: Wiktor Mazur Date: Mon, 11 Nov 2019 12:23:28 +0100 Subject: [PATCH] Non-threaded player, unwraps handling, invalid packet should not fail the application --- backend/lib/packet-sniffer/src/lib.rs | 2 +- backend/lib/photon-protocol/src/lib.rs | 2 +- backend/src/core.rs | 9 +- backend/src/game_protocol/protocol.rs | 103 ---------------------- backend/src/lib.rs | 113 +++++++++++++------------ backend/src/meter/player.rs | 74 ++++++++-------- 6 files changed, 97 insertions(+), 206 deletions(-) delete mode 100644 backend/src/game_protocol/protocol.rs diff --git a/backend/lib/packet-sniffer/src/lib.rs b/backend/lib/packet-sniffer/src/lib.rs index 06c770e..6fe6746 100644 --- a/backend/lib/packet-sniffer/src/lib.rs +++ b/backend/lib/packet-sniffer/src/lib.rs @@ -92,7 +92,7 @@ pub fn receive(tx: Sender) { } handle_ethernet_frame(&interface, &EthernetPacket::new(packet).unwrap(), &tx); } - Err(e) => panic!("packetdump: unable to receive packet: {}", e), + Err(e) => warn!("packetdump: unable to receive packet: {}", e), } } }); diff --git a/backend/lib/photon-protocol/src/lib.rs b/backend/lib/photon-protocol/src/lib.rs index 94a723d..5e8a231 100644 --- a/backend/lib/photon-protocol/src/lib.rs +++ b/backend/lib/photon-protocol/src/lib.rs @@ -6,7 +6,7 @@ pub use layout::*; use std::collections::HashMap; use std::convert::TryFrom; -use std::io::{Cursor, Read}; +use std::io::{Cursor}; impl TryFrom<(&ReliableCommand, &mut Cursor<&[u8]>)> for Message { type Error = &'static str; diff --git a/backend/src/core.rs b/backend/src/core.rs index 05f1cbd..38ba68c 100644 --- a/backend/src/core.rs +++ b/backend/src/core.rs @@ -90,10 +90,11 @@ pub fn initialize() -> Arc> { if packet.destination_port != 5056 && packet.source_port != 5056 { continue; } - let meter = &mut cloned_meter.lock().unwrap(); - let game_messages = photon.decode(&packet.payload) - .into_iter().filter_map(into_game_message).collect(); - register_messages(meter, &game_messages); + if let Ok(ref mut meter) = cloned_meter.lock() { + let game_messages = photon.decode(&packet.payload) + .into_iter().filter_map(into_game_message).collect(); + register_messages(meter, &game_messages); + } } } }); diff --git a/backend/src/game_protocol/protocol.rs b/backend/src/game_protocol/protocol.rs deleted file mode 100644 index d8c6f86..0000000 --- a/backend/src/game_protocol/protocol.rs +++ /dev/null @@ -1,103 +0,0 @@ -use std::io::Cursor; -use bytes::Buf; - -use log::*; - -static CMD_HEADER_LENGTH: u32 = 12; -static SIGNIFIER_BYTE_LENGTH: usize = 1; - -static LOG_OUT: u8 = 4; -static SEND_UNRELIABLE: u8 = 7; -static SEND_RELIABLE: u8 = 6; - -static REQUEST_CONSTANT: usize = 10000; -static RESPONSE_CONSTANT: usize = 1000; - -static MSG_TYPE_REQUEST: u8 = 2; -static MSG_TYPE_RESPONSE: u8 = 3; -static MSG_TYPE_EVENT: u8 = 4; - -use super::message::Message; -use super::packet::Packet; - -pub fn decode(payload: &[u8]) -> Option> -{ - let mut messages = vec![]; - - let mut cursor = Cursor::new(payload); - cursor.advance(3); - - let cmd_cnt = photon_protocol::deserialize_byte(&mut cursor)?; - cursor.advance(8); - - for _ in 0..cmd_cnt { - let cmd_type = photon_protocol::deserialize_byte(&mut cursor)?; - cursor.advance(3); - let cmd_length = photon_protocol::deserialize_integer(&mut cursor)?; - cursor.advance(4); - - if cmd_type == LOG_OUT { - break; - } else if cmd_type == SEND_UNRELIABLE { - cursor.advance(4); - if let Some(msg) = on_message(&mut cursor, cmd_length - 4) { - messages.push(msg); - } - } else if cmd_type == SEND_RELIABLE { - if let Some(msg) = on_message(&mut cursor, cmd_length) { - messages.push(msg); - } - - } else { - cursor.advance((cmd_length - CMD_HEADER_LENGTH) as usize); - } - } - - Some(messages) -} - -fn on_message(cursor: &mut Cursor<&[u8]>, msg_len: u32) -> Option { - let mut message = None; - - let init = cursor.bytes().len(); - cursor.advance(SIGNIFIER_BYTE_LENGTH); - - let msg_type = photon_protocol::deserialize_byte(cursor)?; - let operation_length = msg_len - CMD_HEADER_LENGTH - 2; - - let mut payload = Cursor::new(&cursor.bytes()[0..operation_length as usize]); - - if msg_type == MSG_TYPE_EVENT { - if let Some(event_data) = photon_protocol::deserialize_event_data(&mut payload) { - if event_data.code != 2 && event_data.parameters.get(&252u8).is_some() { - if let photon_protocol::Value::Short(code) = event_data.parameters.get(&252u8)? { - let packet = Packet{code: *code as usize, parameters: event_data.parameters}; - debug!("EVENT: [{}] {:?}", packet.code, packet); - message = packet.decode(); - } - } - } - } else if msg_type == MSG_TYPE_REQUEST { - if let Some(request) = photon_protocol::deserialize_operation_request(&mut payload) { - let code = request.code as usize + REQUEST_CONSTANT; - let packet = Packet{code, parameters: request.parameters}; - debug!("REQUEST: [{}] {:?}", packet.code, packet); - - message = packet.decode(); - } - } else if msg_type == MSG_TYPE_RESPONSE { - if let Some(response) = photon_protocol::deserialize_operation_response(&mut payload) { - let code = response.code as usize + RESPONSE_CONSTANT; - let packet = Packet{code, parameters: response.parameters}; - debug!("RESPONSE: [{}] {:?}", packet.code, packet); - - message = packet.decode(); - } - } - - cursor.advance(operation_length as usize); - let last = cursor.bytes().len(); - assert!(init - last == msg_len as usize - CMD_HEADER_LENGTH as usize); - - message -} \ No newline at end of file diff --git a/backend/src/lib.rs b/backend/src/lib.rs index 4d2a485..8e87fd1 100644 --- a/backend/src/lib.rs +++ b/backend/src/lib.rs @@ -10,6 +10,7 @@ mod meter; mod core; use std::sync::{Mutex, Arc}; +use log::*; use cpython::PyList; use cpython::PyObject; @@ -48,35 +49,27 @@ lazy_static! { static ref METER: Mutex = Mutex::new(PyMeter::new()); } +macro_rules! set_dict_item { + ($py:ident, $dict:ident, $from:ident, $field_name:ident) => { + if let Ok(_) = $dict.set_item($py, stringify!($field_name), $from.$field_name.to_py_object($py)) + {} + }; +} + + impl ToPyObject for core::PlayerStatistics { type ObjectType = PyObject; fn to_py_object(&self, py: Python) -> Self::ObjectType { let stats = PyDict::new(py); - stats - .set_item(py, "player", self.player.to_py_object(py)) - .unwrap(); - stats - .set_item(py, "damage", self.damage.to_py_object(py)) - .unwrap(); - stats - .set_item(py, "time_in_combat", self.time_in_combat.to_py_object(py)) - .unwrap(); - stats - .set_item(py, "dps", self.dps.to_py_object(py)) - .unwrap(); - stats - .set_item(py, "seconds_in_game", self.seconds_in_game.to_py_object(py)) - .unwrap(); - stats - .set_item(py, "fame", self.fame.to_py_object(py)) - .unwrap(); - stats - .set_item(py, "fame_per_minute", self.fame_per_minute.to_py_object(py)) - .unwrap(); - stats - .set_item(py, "fame_per_hour", self.fame_per_hour.to_py_object(py)) - .unwrap(); + set_dict_item!(py, stats, self, player); + set_dict_item!(py, stats, self, damage); + set_dict_item!(py, stats, self, time_in_combat); + set_dict_item!(py, stats, self, dps); + set_dict_item!(py, stats, self, seconds_in_game); + set_dict_item!(py, stats, self, fame); + set_dict_item!(py, stats, self, fame_per_minute); + set_dict_item!(py, stats, self, fame_per_hour); stats.into_object() } @@ -112,56 +105,64 @@ impl <'source> FromPyObject<'source> for StatType { pub fn stats(py: Python, stat_type: StatType) -> PyResult { - let meter = &mut METER.lock().unwrap(); - - if let Some(m) = meter.get() { - let meter = &mut *m.lock().unwrap(); - return Ok(core::stats(&meter, stat_type) - .into_iter() - .filter(|s| s.damage != 0.0 || s.fame != 0.0) - .collect::>() - .into_py_object(py)) + if let Ok(ref mut py_meter) = METER.lock() { + if let Some(m) = py_meter.get() { + if let Ok(ref mut meter) = m.lock() { + return Ok(core::stats(&meter, stat_type) + .into_iter() + .filter(|s| s.damage != 0.0 || s.fame != 0.0) + .collect::>() + .into_py_object(py)) + } + } } + error!("Failed to acquire locks on meter"); Ok(PyList::new(py, Vec::::new().as_slice())) } pub fn reset(_py: Python, stat_type: StatType) -> PyResult { - let meter = &mut METER.lock().unwrap(); - - if let Some(m) = meter.get() { - let meter = &mut *m.lock().unwrap(); - core::reset(meter, stat_type); + if let Ok(ref mut py_meter) = METER.lock() { + if let Some(m) = py_meter.get() { + if let Ok(ref mut meter) = m.lock() { + core::reset(meter, stat_type); + return Ok(0); + } + } } - Ok(0) + error!("Failed to acquire locks on meter"); + Ok(1) } pub fn get_players_in_party(py: Python) -> PyResult { - let meter = &mut METER.lock().unwrap(); - - if let Some(m) = meter.get() { - let meter = &mut *m.lock().unwrap(); - return Ok(core::get_players_in_party(&meter).into_py_object(py)) + if let Ok(ref mut py_meter) = METER.lock() { + if let Some(m) = py_meter.get() { + if let Ok(ref mut meter) = m.lock() { + return Ok(core::get_players_in_party(&meter).into_py_object(py)) + } + } } + error!("Failed to acquire locks on meter"); Ok(PyList::new(py, Vec::::new().as_slice())) } fn initialize(_py: Python, skip_non_party_members: bool) -> PyResult { - let meter = &mut METER.lock().unwrap(); - - meter.initialize(core::initialize()); - - if let Some(m) = meter.get() { - let meter = &mut *m.lock().unwrap(); - meter.configure(core::MeterConfig { - skip_non_party_members, - ..Default::default() - }) + if let Ok(ref mut py_meter) = METER.lock() { + py_meter.initialize(core::initialize()); + if let Some(m) = py_meter.get() { + if let Ok(ref mut meter) = m.lock() { + meter.configure(core::MeterConfig { + skip_non_party_members, + ..Default::default() + }); + return Ok(0); + } + } } - - Ok(0) + error!("Failed to initialize meter"); + Ok(1) } py_module_initializer!(libaostats, initlibaostats, PyInit_libaostats, |py, m| { diff --git a/backend/src/meter/player.rs b/backend/src/meter/player.rs index acfbde5..b380b9a 100644 --- a/backend/src/meter/player.rs +++ b/backend/src/meter/player.rs @@ -5,6 +5,7 @@ use std::sync::{Arc, Mutex}; use fake_clock::FakeClock as Instant; #[cfg(not(test))] use std::time::Instant; +use log::*; use timer; @@ -14,30 +15,19 @@ use super::traits::DamageStats; use super::traits::FameStats; use super::traits::FameGatherer; -struct Time { - _guard: timer::Guard, - _timer: timer::Timer, +#[derive(Debug)] +struct CombatTime +{ + entered_combat: Option, + time_in_combat: std::time::Duration } -impl Time { - fn with(time_elapsed: Arc>, combat_state: Arc>) -> Time { - let _timer = timer::Timer::new(); - - let _guard = { - _timer.schedule_repeating(chrono::Duration::milliseconds(10), move || { - if *combat_state.lock().unwrap() == CombatState::InCombat { - *time_elapsed.lock().unwrap() += 10.0; - } - }) - }; - - Self { _timer, _guard } - } -} - -impl fmt::Debug for Time { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "") +impl CombatTime { + fn new() -> Self { + Self { + entered_combat: None, + time_in_combat: std::time::Duration::from_millis(0) + } } } @@ -45,9 +35,8 @@ impl fmt::Debug for Time { pub struct Player { pub id: usize, damage_dealt: f32, - time_elapsed: Arc>, - combat_state: Arc>, - _time: Option