feat[transfer]: add logic for handling transfers and resolving them

controller/src/controller.rs

@@ -67,7 +67,7 @@ impl Controller {
             let nodes = Nodes::load_all(&drivers);
             let groups = Groups::load_all(&nodes);
             let servers = Servers::new(handle.clone());
-            let users = Users::new(/*handle.clone()*/);
+            let users = Users::new(handle.clone());
             let event_bus = EventBus::new(/*handle.clone()*/);
             Self {
                 handle: handle.clone(),

controller/src/controller/event.rs

@@ -1,9 +1,8 @@
-use channel::ChannelMessageSended;
 use colored::Colorize;
 use log::debug;
+use uuid::Uuid;
 
 use super::server::{ServerHandle, WeakServerHandle};
-use crate::network::server::proto::ChannelMessage;
 
 use std::{
     any::{Any, TypeId},
@@ -14,10 +13,12 @@ use std::{
 };
 
 pub mod channel;
+pub mod transfer;
 
 #[derive(Eq, PartialEq)]
 pub enum EventKey {
     Channel(String),
+    Transfer(Uuid),
     Custom(TypeId),
 }
 
@@ -54,7 +55,7 @@ impl EventBus {
             .push(registered_listener);
     }
 
-    pub fn register_listener_with_server<E: Event>(
+    pub fn register_listener_under_server<E: Event>(
         &self,
         key: EventKey,
         server: WeakServerHandle,
@@ -108,12 +109,12 @@ impl EventBus {
         }
     }
 
-    pub fn dispatch<E: Event>(&self, event: &E) -> u32 {
+    pub fn dispatch<E: Event>(&self, key: &EventKey, event: &E) -> u32 {
         debug!("[{}] Dispatching event: {:?}", "EVENTS".blue(), event);
 
         let mut count = 0;
         let listeners = self.listeners.lock().unwrap();
-        if let Some(registered_listeners) = listeners.get(&EventKey::Custom(TypeId::of::<E>())) {
+        if let Some(registered_listeners) = listeners.get(key) {
             for registered_listener in registered_listeners {
                 if let Some(listener) = registered_listener
                     .listener
@@ -127,30 +128,8 @@ impl EventBus {
         count
     }
 
-    pub fn dispatch_channel_message(&self, message: ChannelMessage) -> u32 {
-        debug!(
-            "[{}] Dispatching channel message: {:?}",
-            "EVENTS".blue(),
-            message
-        );
-
-        let mut count = 0;
-        let listeners = self.listeners.lock().unwrap();
-        if let Some(registered_listeners) =
-            listeners.get(&EventKey::Channel(message.channel.clone()))
-        {
-            let event = ChannelMessageSended { message };
-            for registered_listener in registered_listeners {
-                if let Some(listener) = registered_listener
-                    .listener
-                    .downcast_ref::<EventListener<ChannelMessageSended>>()
-                {
-                    listener(&event);
-                    count += 1;
-                }
-            }
-        }
-        count
+    pub fn dispatch_custom<E: Event>(&self, event: &E) -> u32 {
+        self.dispatch(&EventKey::Custom(TypeId::of::<E>()), event)
     }
 }
 
@@ -161,8 +140,12 @@ impl Hash for EventKey {
                 state.write_u8(0);
                 channel.hash(state);
             }
-            EventKey::Custom(type_id) => {
+            EventKey::Transfer(server) => {
                 state.write_u8(1);
+                server.hash(state);
+            }
+            EventKey::Custom(type_id) => {
+                state.write_u8(2);
                 type_id.hash(state);
             }
         }

controller/src/controller/event/transfer.rs

@@ -0,0 +1,10 @@
+use crate::controller::user::transfer::Transfer;
+
+use super::Event;
+
+#[derive(Debug)]
+pub struct UserTransferRequested {
+    pub transfer: Transfer,
+}
+
+impl Event for UserTransferRequested {}

controller/src/controller/group.rs

@@ -234,6 +234,16 @@ impl Group {
                 true
             });
     }
+
+    pub fn get_free_server(&self) -> Option<ServerHandle> {
+        let servers = self.servers.lock().expect("Failed to lock servers");
+        for server in servers.iter() {
+            if let GroupedServer::Active(server) = server {
+                return Some(server.clone());
+            }
+        }
+        None
+    }
 }
 
 mod shared {

controller/src/controller/user.rs

@@ -1,5 +1,6 @@
 use std::{
     collections::HashMap,
+    ops::Deref,
     sync::{Arc, Mutex, Weak},
 };
 
@@ -8,7 +9,10 @@ use log::{debug, info};
 use transfer::Transfer;
 use uuid::Uuid;
 
-use super::server::{ServerHandle, WeakServerHandle};
+use super::{
+    server::{ServerHandle, WeakServerHandle},
+    WeakControllerHandle,
+};
 
 pub mod transfer;
 
@@ -18,16 +22,16 @@ pub type WeakUserHandle = Weak<User>;
 type UsersMap = HashMap<Uuid, UserHandle>;
 
 pub struct Users {
-    //controller: WeakControllerHandle,
+    controller: WeakControllerHandle,
 
     /* Users that joined some started server */
     users: Mutex<UsersMap>,
 }
 
 impl Users {
-    pub fn new(/*controller: WeakControllerHandle*/) -> Self {
+    pub fn new(controller: WeakControllerHandle) -> Self {
         Self {
-            //controller,
+            controller,
             users: Mutex::new(HashMap::new()),
         }
     }
@@ -53,7 +57,7 @@ impl Users {
     pub fn handle_user_disconnected(&self, server: ServerHandle, uuid: Uuid) {
         let mut users = self.users.lock().unwrap();
         if let Some(user) = users.get(&uuid).cloned() {
-            if let CurrentServer::Connected(weak_server) = &user.server {
+            if let CurrentServer::Connected(weak_server) = user.server.lock().unwrap().deref() {
                 if let Some(strong_server) = weak_server.upgrade() {
                     // Verify if the user is connected to the server that is saying he is disconnecting
                     if Arc::ptr_eq(&strong_server, &server) {
@@ -74,7 +78,7 @@ impl Users {
     pub fn cleanup_users(&self, dead_server: &ServerHandle) -> u32 {
         let mut amount = 0;
         self.users.lock().unwrap().retain(|_, user| {
-            if let CurrentServer::Connected(weak_server) = &user.server {
+            if let CurrentServer::Connected(weak_server) = user.server.lock().unwrap().deref() {
                 if let Some(server) = weak_server.upgrade() {
                     if Arc::ptr_eq(&server, dead_server) {
                         info!(
@@ -106,7 +110,7 @@ impl Users {
         Arc::new(User {
             name,
             uuid,
-            server: CurrentServer::Connected(Arc::downgrade(server)),
+            server: Mutex::new(CurrentServer::Connected(Arc::downgrade(server))),
         })
     }
 }
@@ -119,5 +123,5 @@ pub enum CurrentServer {
 pub struct User {
     pub name: String,
     pub uuid: Uuid,
-    pub server: CurrentServer,
+    pub server: Mutex<CurrentServer>,
 }

controller/src/controller/user/transfer.rs

@@ -1,18 +1,81 @@
+use std::{ops::Deref, sync::Arc};
+
+use log::error;
+use log::info;
+use log::warn;
+
 use crate::controller::{
+    event::{transfer::UserTransferRequested, EventKey},
     group::WeakGroupHandle,
     server::{ServerHandle, WeakServerHandle},
 };
 
-use super::{UserHandle, Users, WeakUserHandle};
+use super::{CurrentServer, UserHandle, Users, WeakUserHandle};
 
 impl Users {
     pub fn transfer_all_users(&self, _server: &ServerHandle) -> u32 {
         // TODO: Move all players from server to another server
         0
     }
 
-    pub fn transfer_user(&self, _user: &UserHandle, _target: &TransferTarget) -> bool {
-        // TODO: Move all players from server to another server
+    pub fn resolve_transfer(&self, user: &UserHandle, target: &TransferTarget) -> Option<Transfer> {
+        if let CurrentServer::Connected(from) = user.server.lock().unwrap().deref() {
+            match target {
+                TransferTarget::Server(to) => {
+                    return Some(Transfer::new(
+                        Arc::downgrade(user),
+                        from.clone(),
+                        to.clone(),
+                    ));
+                }
+                TransferTarget::Group(group) => {
+                    if let Some(group) = group.upgrade() {
+                        if let Some(to) = group.get_free_server() {
+                            return Some(Transfer::new(
+                                Arc::downgrade(user),
+                                from.clone(),
+                                Arc::downgrade(&to),
+                            ));
+                        } else {
+                            warn!("Failed to find free server in group {} while resolving transfer of user {}", group.name, user.name);
+                        }
+                    } else {
+                        error!(
+                            "Failed to upgrade group handle while resolving transfer of user {}",
+                            user.name
+                        );
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
+    pub fn transfer_user(&self, transfer: Transfer) -> bool {
+        if let Some((user, from, to)) = transfer.get_strong() {
+            info!(
+                "Transfering user {} from {} to server {}",
+                user.name, from.name, to.name
+            );
+
+            let controller = self
+                .controller
+                .upgrade()
+                .expect("Failed to upgrade controller");
+            controller.get_event_bus().dispatch(
+                &EventKey::Transfer(from.uuid),
+                &UserTransferRequested {
+                    transfer: transfer.clone(),
+                },
+            );
+
+            *user.server.lock().unwrap() = CurrentServer::Transfering(transfer);
+            return true;
+        } else {
+            error!("Failed to transfer user because some required information is missing");
+        }
+
         false
     }
 }
@@ -22,8 +85,22 @@ pub enum TransferTarget {
     Group(WeakGroupHandle),
 }
 
+#[derive(Clone, Debug)]
 pub struct Transfer {
     pub user: WeakUserHandle,
     pub from: WeakServerHandle,
     pub to: WeakServerHandle,
 }
+
+impl Transfer {
+    pub fn new(user: WeakUserHandle, from: WeakServerHandle, to: WeakServerHandle) -> Self {
+        Self { user, from, to }
+    }
+
+    pub fn get_strong(&self) -> Option<(UserHandle, ServerHandle, ServerHandle)> {
+        let user = self.user.upgrade()?;
+        let from = self.from.upgrade()?;
+        let to = self.to.upgrade()?;
+        Some((user, from, to))
+    }
+}