From 6a57be5475c2c75ec5b87fc6c64e16e98264da64 Mon Sep 17 00:00:00 2001 From: Titouan Rigoudy Date: Mon, 12 Dec 2022 21:51:06 +0000 Subject: [PATCH] Introduce PeerEventHandler. --- client/src/dispatcher.rs | 30 +++++++++++++++++++--- client/src/peer/event.rs | 36 +++++++++++++++++++++++++++ client/src/peer/map.rs | 8 ++++++ client/src/peer/mod.rs | 9 +++++++ client/src/{peer.rs => peer/state.rs} | 8 ------ 5 files changed, 80 insertions(+), 11 deletions(-) create mode 100644 client/src/peer/event.rs create mode 100644 client/src/peer/map.rs create mode 100644 client/src/peer/mod.rs rename client/src/{peer.rs => peer/state.rs} (86%) diff --git a/client/src/dispatcher.rs b/client/src/dispatcher.rs index 5c77b9b..d4cbb28 100644 --- a/client/src/dispatcher.rs +++ b/client/src/dispatcher.rs @@ -8,11 +8,15 @@ use crate::control::Request as ControlRequest; use crate::event::{Event, EventHandler}; use crate::handlers::*; use crate::message_handler::MessageHandler; +use crate::peer::{PeerEvent, PeerEventHandler}; use crate::room::{RoomEvent, RoomEventHandler}; use crate::user::{UserEvent, UserEventHandler}; /// Subsystem event handlers to which the `Dispatcher` dispatches events. pub trait DispatcherHandlers { + type PeerEventHandler: EventHandler; + fn peer_event_handler(&mut self) -> &mut Self::PeerEventHandler; + type RoomEventHandler: EventHandler; fn room_event_handler(&mut self) -> &mut Self::RoomEventHandler; @@ -23,11 +27,17 @@ pub trait DispatcherHandlers { /// Default event handlers implementing real behavior. #[derive(Default)] pub struct DefaultDispatcherHandlers { + peer_event_handler: PeerEventHandler, room_event_handler: RoomEventHandler, user_event_handler: UserEventHandler, } impl DispatcherHandlers for DefaultDispatcherHandlers { + type PeerEventHandler = PeerEventHandler; + fn peer_event_handler(&mut self) -> &mut Self::PeerEventHandler { + &mut self.peer_event_handler + } + type RoomEventHandler = RoomEventHandler; fn room_event_handler(&mut self) -> &mut Self::RoomEventHandler { &mut self.room_event_handler @@ -74,7 +84,10 @@ impl Dispatcher { fn dispatch_internal(&mut self, event: Event) -> anyhow::Result<()> { match event { Event::ServerResponse(ServerResponse::PeerAddressResponse(response)) => { - PeerAddressResponseHandler::default().run(&mut self.context, &response) + self + .handlers + .peer_event_handler() + .handle(&mut self.context, PeerEvent::AddressResponse(response)) } Event::ServerResponse(ServerResponse::PrivilegedUsersResponse( response, @@ -104,7 +117,10 @@ impl Dispatcher { LoginStatusRequestHandler::default().run(&mut self.context, &()) } Event::ControlRequest(ControlRequest::PeerConnectRequest(request)) => { - PeerConnectRequestHandler::default().run(&mut self.context, &request) + self + .handlers + .peer_event_handler() + .handle(&mut self.context, PeerEvent::ConnectRequest(request)) } Event::ControlRequest(ControlRequest::RoomListRequest) => self .handlers @@ -149,6 +165,7 @@ mod tests { use crate::context::{Context, ContextBundle}; use crate::control; use crate::event::{Event, EventHandler}; + use crate::peer::PeerEvent; use crate::room::RoomEvent; use crate::user::UserEvent; @@ -184,6 +201,7 @@ mod tests { #[derive(Default)] struct FakeDispatcherHandlers { + peer_event_handler: FakeEventHandler, room_event_handler: FakeEventHandler, user_event_handler: FakeEventHandler, } @@ -191,12 +209,18 @@ mod tests { impl FakeDispatcherHandlers { // Defined here for better maintainability as new handlers are added. fn has_events(&self) -> bool { - !self.room_event_handler.events.is_empty() + !self.peer_event_handler.events.is_empty() + || !self.room_event_handler.events.is_empty() || !self.user_event_handler.events.is_empty() } } impl DispatcherHandlers for FakeDispatcherHandlers { + type PeerEventHandler = FakeEventHandler; + fn peer_event_handler(&mut self) -> &mut Self::PeerEventHandler { + &mut self.peer_event_handler + } + type RoomEventHandler = FakeEventHandler; fn room_event_handler(&mut self) -> &mut Self::RoomEventHandler { &mut self.room_event_handler diff --git a/client/src/peer/event.rs b/client/src/peer/event.rs new file mode 100644 index 0000000..1615ecf --- /dev/null +++ b/client/src/peer/event.rs @@ -0,0 +1,36 @@ +//! This module defines events affecting the peer module and their handling. + +use solstice_proto::server; + +use crate::context::Context; +use crate::event::EventHandler; +use crate::handlers::{PeerAddressResponseHandler, PeerConnectRequestHandler}; +use crate::message_handler::MessageHandler; + +/// The type of events that affect the peer module. +pub enum PeerEvent { + AddressResponse(server::PeerAddressResponse), + ConnectRequest(String), +} + +#[derive(Default)] +pub struct PeerEventHandler; + +impl EventHandler for PeerEventHandler { + type Event = PeerEvent; + + fn handle( + &mut self, + context: &mut Context, + event: Self::Event, + ) -> anyhow::Result<()> { + match event { + PeerEvent::AddressResponse(response) => { + PeerAddressResponseHandler::default().run(context, &response) + } + PeerEvent::ConnectRequest(peer_name) => { + PeerConnectRequestHandler::default().run(context, &peer_name) + } + } + } +} diff --git a/client/src/peer/map.rs b/client/src/peer/map.rs new file mode 100644 index 0000000..ee67041 --- /dev/null +++ b/client/src/peer/map.rs @@ -0,0 +1,8 @@ +use std::collections::HashMap; + +use crate::peer::PeerState; + +#[derive(Debug, Default)] +pub struct PeerMap { + pub peers: HashMap, +} diff --git a/client/src/peer/mod.rs b/client/src/peer/mod.rs new file mode 100644 index 0000000..e7af8fc --- /dev/null +++ b/client/src/peer/mod.rs @@ -0,0 +1,9 @@ +//! This module deals with peers, peer connections and data transfer. + +mod event; +mod map; +mod state; + +pub use event::{PeerEvent, PeerEventHandler}; +pub use map::PeerMap; +pub use state::PeerState; diff --git a/client/src/peer.rs b/client/src/peer/state.rs similarity index 86% rename from client/src/peer.rs rename to client/src/peer/state.rs index 8614cfe..ba27a31 100644 --- a/client/src/peer.rs +++ b/client/src/peer/state.rs @@ -1,6 +1,3 @@ -//! This module provides abstractions for interacting with a set of peers. - -use std::collections::HashMap; use std::net::SocketAddr; // Peer states: @@ -62,8 +59,3 @@ pub enum PeerState { } */ } - -#[derive(Debug, Default)] -pub struct PeerMap { - pub peers: HashMap, -}