Non-threaded player, unwraps handling, invalid packet should not fail the application
This commit is contained in:
+5
-4
@@ -90,10 +90,11 @@ pub fn initialize() -> Arc<Mutex<meter::Meter>> {
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
@@ -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<Vec<Message>>
|
||||
{
|
||||
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<Message> {
|
||||
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
|
||||
}
|
||||
+57
-56
@@ -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<PyMeter> = 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<PyList> {
|
||||
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::<Vec<meter::PlayerStatistics>>()
|
||||
.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::<Vec<meter::PlayerStatistics>>()
|
||||
.into_py_object(py))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
error!("Failed to acquire locks on meter");
|
||||
Ok(PyList::new(py, Vec::<PyObject>::new().as_slice()))
|
||||
}
|
||||
|
||||
pub fn reset(_py: Python, stat_type: StatType) -> PyResult<u32> {
|
||||
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<PyList> {
|
||||
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::<PyObject>::new().as_slice()))
|
||||
}
|
||||
|
||||
fn initialize(_py: Python, skip_non_party_members: bool) -> PyResult<u32> {
|
||||
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| {
|
||||
|
||||
+33
-41
@@ -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<Instant>,
|
||||
time_in_combat: std::time::Duration
|
||||
}
|
||||
|
||||
impl Time {
|
||||
fn with(time_elapsed: Arc<Mutex<f32>>, combat_state: Arc<Mutex<CombatState>>) -> 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<Mutex<f32>>,
|
||||
combat_state: Arc<Mutex<CombatState>>,
|
||||
_time: Option<Time>,
|
||||
combat_time: CombatTime,
|
||||
combat_state: CombatState,
|
||||
time_started: Instant,
|
||||
fame: f32
|
||||
}
|
||||
@@ -55,15 +44,11 @@ pub struct Player {
|
||||
|
||||
impl Player {
|
||||
pub fn new(id: usize) -> Self {
|
||||
let time_elapsed = Arc::new(Mutex::new(0.0));
|
||||
let combat_state = Arc::new(Mutex::new(CombatState::OutOfCombat));
|
||||
|
||||
Self {
|
||||
id,
|
||||
damage_dealt: 0.0,
|
||||
time_elapsed,
|
||||
combat_state,
|
||||
_time: None,
|
||||
combat_time: CombatTime::new(),
|
||||
combat_state: CombatState::OutOfCombat,
|
||||
time_started: Instant::now(),
|
||||
fame: 0.0
|
||||
}
|
||||
@@ -72,12 +57,7 @@ impl Player {
|
||||
|
||||
impl DamageDealer for Player {
|
||||
fn register_damage_dealt(&mut self, damage_dealt: f32) {
|
||||
if self._time.is_none() {
|
||||
let elapsed = self.time_elapsed.clone();
|
||||
let state = self.combat_state.clone();
|
||||
self._time = Some(Time::with(elapsed, state));
|
||||
}
|
||||
if *self.combat_state.lock().unwrap() == CombatState::OutOfCombat {
|
||||
if self.combat_state == CombatState::OutOfCombat {
|
||||
return
|
||||
}
|
||||
|
||||
@@ -85,15 +65,19 @@ impl DamageDealer for Player {
|
||||
}
|
||||
|
||||
fn enter_combat(&mut self) {
|
||||
*self.combat_state.lock().unwrap() = CombatState::InCombat;
|
||||
self.combat_time.entered_combat = Some(Instant::now());
|
||||
self.combat_state = CombatState::InCombat;
|
||||
}
|
||||
|
||||
fn leave_combat(&mut self) {
|
||||
*self.combat_state.lock().unwrap() = CombatState::OutOfCombat;
|
||||
if let Some(entered_combat) = self.combat_time.entered_combat {
|
||||
self.combat_time.time_in_combat += Instant::now() - entered_combat;
|
||||
}
|
||||
self.combat_state = CombatState::OutOfCombat;
|
||||
}
|
||||
|
||||
fn combat_state(&self) -> CombatState {
|
||||
match *self.combat_state.lock().unwrap() {
|
||||
match self.combat_state {
|
||||
CombatState::InCombat => CombatState::InCombat,
|
||||
CombatState::OutOfCombat => CombatState::OutOfCombat,
|
||||
}
|
||||
@@ -105,7 +89,15 @@ impl DamageStats for Player {
|
||||
self.damage_dealt
|
||||
}
|
||||
fn time_in_combat(&self) -> f32 {
|
||||
*self.time_elapsed.lock().unwrap()
|
||||
if self.combat_state == CombatState::InCombat {
|
||||
if let Some(entered_combat) = self.combat_time.entered_combat {
|
||||
let time_in_combat = self.combat_time.time_in_combat + (Instant::now() - entered_combat);
|
||||
return time_in_combat.as_millis() as f32;
|
||||
}
|
||||
} else {
|
||||
return self.combat_time.time_in_combat.as_millis() as f32;
|
||||
}
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user