feat[fallback]!: add option to mark servers as fallbacks

Author: HttpRafa

controller/src/controller/group.rs

@@ -20,7 +20,7 @@ use super::{
 
 const GROUPS_DIRECTORY: &str = "groups";
 
-type GroupHandle = Arc<Group>;
+pub type GroupHandle = Arc<Group>;
 pub type WeakGroupHandle = Weak<Group>;
 
 pub struct Groups {

controller/src/controller/server.rs

@@ -304,6 +304,21 @@ impl Servers {
         }
     }
 
+    pub fn find_fallback_server(&self, excluded: &ServerHandle) -> Option<ServerHandle> {
+        // TODO: Also check if the server have free slots
+        self.servers
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|server| {
+                !Arc::ptr_eq(server, excluded)
+                    && server.allocation.deployment.fallback.enabled
+                    && *server.state.lock().unwrap() == State::Running
+            })
+            .max_by_key(|server| server.allocation.deployment.fallback.priority)
+            .cloned()
+    }
+
     fn start_server(
         &self,
         request: &StartRequestHandle,
@@ -458,6 +473,12 @@ pub enum Retention {
     Permanent,
 }
 
+#[derive(Serialize, Deserialize, Clone, Default)]
+pub struct FallbackPolicy {
+    pub enabled: bool,
+    pub priority: i32,
+}
+
 #[derive(Serialize, Deserialize, Clone)]
 pub struct KeyValue {
     pub key: String,
@@ -470,4 +491,6 @@ pub struct Deployment {
     pub environment: Vec<KeyValue>,
     pub disk_retention: Retention,
     pub image: String,
+
+    pub fallback: FallbackPolicy,
 }

controller/src/controller/user.rs

@@ -106,6 +106,23 @@ impl Users {
         amount
     }
 
+    pub fn get_users_on_server(&self, server: &ServerHandle) -> Vec<UserHandle> {
+        self.users
+            .lock()
+            .unwrap()
+            .values()
+            .filter(|user| {
+                if let CurrentServer::Connected(weak_server) = user.server.lock().unwrap().deref() {
+                    if let Some(strong_server) = weak_server.upgrade() {
+                        return Arc::ptr_eq(&strong_server, server);
+                    }
+                }
+                false
+            })
+            .cloned()
+            .collect()
+    }
+
     fn create_user(&self, name: String, uuid: Uuid, server: &ServerHandle) -> UserHandle {
         Arc::new(User {
             name,

controller/src/controller/user/transfer.rs

@@ -4,18 +4,36 @@ use log::error;
 use log::info;
 use log::warn;
 
+use crate::controller::group::GroupHandle;
 use crate::controller::{
     event::{transfer::UserTransferRequested, EventKey},
-    group::WeakGroupHandle,
     server::{ServerHandle, WeakServerHandle},
 };
 
 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_all_users(&self, server: &ServerHandle) -> u32 {
+        let controller = self
+            .controller
+            .upgrade()
+            .expect("Failed to upgrade controller. This should never happen");
+        let users = self.get_users_on_server(server);
+        let mut count = 0;
+
+        for user in &users {
+            if let Some(fallback_server) = controller.get_servers().find_fallback_server(server) {
+                if let Some(transfer) =
+                    self.resolve_transfer(user, &TransferTarget::Server(fallback_server))
+                {
+                    if self.transfer_user(transfer) {
+                        count += 1;
+                    }
+                }
+            }
+        }
+
+        count
     }
 
     pub fn resolve_transfer(&self, user: &UserHandle, target: &TransferTarget) -> Option<Transfer> {
@@ -25,25 +43,18 @@ impl Users {
                     return Some(Transfer::new(
                         Arc::downgrade(user),
                         from.clone(),
-                        to.clone(),
+                        Arc::downgrade(to),
                     ));
                 }
                 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);
-                        }
+                    if let Some(to) = group.get_free_server() {
+                        return Some(Transfer::new(
+                            Arc::downgrade(user),
+                            from.clone(),
+                            Arc::downgrade(&to),
+                        ));
                     } else {
-                        error!(
-                            "Failed to upgrade group handle while resolving transfer of user {}",
-                            user.name
-                        );
+                        warn!("Failed to find free server in group {} while resolving transfer of user {}", group.name, user.name);
                     }
                 }
             }
@@ -62,7 +73,7 @@ impl Users {
             let controller = self
                 .controller
                 .upgrade()
-                .expect("Failed to upgrade controller");
+                .expect("Failed to upgrade controller. This should never happen");
             controller.get_event_bus().dispatch(
                 &EventKey::Transfer(from.uuid),
                 &UserTransferRequested {
@@ -81,8 +92,8 @@ impl Users {
 }
 
 pub enum TransferTarget {
-    Server(WeakServerHandle),
-    Group(WeakGroupHandle),
+    Server(ServerHandle),
+    Group(GroupHandle),
 }
 
 #[derive(Clone, Debug)]

controller/src/network/admin.rs

@@ -4,7 +4,7 @@ use tonic::{async_trait, Request, Response, Status};
 use crate::controller::{
     group::ScalingPolicy,
     node::{Capabilities, RemoteController},
-    server::{Deployment, KeyValue, Resources, Retention},
+    server::{Deployment, FallbackPolicy, KeyValue, Resources, Retention},
     ControllerHandle, CreationResult,
 };
 
@@ -146,6 +146,12 @@ impl AdminService for AdminServiceImpl {
                     _ => Retention::Temporary,
                 };
             }
+            if let Some(value) = value.fallback {
+                deployment.fallback = FallbackPolicy {
+                    enabled: value.enabled,
+                    priority: value.priority,
+                };
+            }
         }
 
         /* Nodes */

protocol/grpc/admin/admin.proto

@@ -69,6 +69,12 @@ message Group {
         repeated KeyValue settings = 2;
         repeated KeyValue environment = 3;
         optional Retention diskRetention = 4;
+        optional Fallback fallback = 5;
+
+        message Fallback {
+            bool enabled = 1;
+            int32 priority = 2;
+        }
 
         message KeyValue {
             string key = 1;