Introduce PeerEventHandler.

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<Event = PeerEvent>;
+  fn peer_event_handler(&mut self) -> &mut Self::PeerEventHandler;
+
   type RoomEventHandler: EventHandler<Event = RoomEvent>;
   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<H: DispatcherHandlers> Dispatcher<H> {
   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<H: DispatcherHandlers> Dispatcher<H> {
         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<PeerEvent>,
     room_event_handler: FakeEventHandler<RoomEvent>,
     user_event_handler: FakeEventHandler<UserEvent>,
   }
@@ -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<PeerEvent>;
+    fn peer_event_handler(&mut self) -> &mut Self::PeerEventHandler {
+      &mut self.peer_event_handler
+    }
+
     type RoomEventHandler = FakeEventHandler<RoomEvent>;
     fn room_event_handler(&mut self) -> &mut Self::RoomEventHandler {
       &mut self.room_event_handler

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)
+      }
+    }
+  }
+}

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<String, PeerState>,
+}

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;

client/src/peer.rs → 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<String, PeerState>,
-}