removing strong references from scriping managers

rustfmt.toml

@@ -1,4 +1,4 @@
-max_width = 90
+max_width = 80
 hard_tabs = true
 tab_spaces = 2
 imports_layout = "HorizontalVertical"

server/src/lua/builder.rs

@@ -1,20 +1,23 @@
-use crate::client_management::ClientManager;
+use actix::{Addr, WeakAddr};
-use crate::lua::lua_manager::LuaManager;
+
-use crate::network::NetworkManager;
+use crate::{
-use crate::Server;
+	client_management::ClientManager,
-use actix::Addr;
+	lua::lua_manager::LuaManager,
+	network::NetworkManager,
+	Server,
+};
 
 pub struct Builder {
-	pub(super) server: Addr<Server>,
+	pub(super) server: WeakAddr<Server>,
-	pub(super) network_manager: Addr<NetworkManager>,
+	pub(super) network_manager: WeakAddr<NetworkManager>,
-	pub(super) client_manager: Addr<ClientManager>,
+	pub(super) client_manager: WeakAddr<ClientManager>,
 }
 
 impl Builder {
 	pub(super) fn new(
-		server: Addr<Server>,
+		server: WeakAddr<Server>,
-		network_manager: Addr<NetworkManager>,
+		network_manager: WeakAddr<NetworkManager>,
-		client_manager: Addr<ClientManager>,
+		client_manager: WeakAddr<ClientManager>,
 	) -> Self {
 		Builder {
 			server,

server/src/lua/lua_manager.rs

@@ -2,29 +2,31 @@
 //!
 //! Holds the LuaManger struct and implements it's methods
 
-use crate::client_management::ClientManager;
+use actix::{fut::wrap_future, Actor, Addr, AsyncContext, Context, WeakAddr};
-use crate::lua::builder::Builder;
-use crate::network::NetworkManager;
-use crate::scripting::scriptable_server::ScriptableServer;
-use crate::Server;
-use actix::fut::wrap_future;
-use actix::{Actor, Addr, AsyncContext, Context};
 use mlua::{Lua, Thread};
 
+use crate::{
+	client_management::ClientManager,
+	lua::builder::Builder,
+	network::NetworkManager,
+	scripting::scriptable_server::ScriptableServer,
+	Server,
+};
+
 /// # LuaManager
 /// Holds common server objects
 /// todo: change to weak references
 pub struct LuaManager {
-	pub(super) server: Addr<Server>,
+	pub(super) server: WeakAddr<Server>,
-	pub(super) _network_manager: Addr<NetworkManager>,
+	pub(super) _network_manager: WeakAddr<NetworkManager>,
-	pub(super) _client_manager: Addr<ClientManager>,
+	pub(super) _client_manager: WeakAddr<ClientManager>,
 }
 
 impl LuaManager {
 	pub fn create(
-		server: Addr<Server>,
+		server: WeakAddr<Server>,
-		network_manager: Addr<NetworkManager>,
+		network_manager: WeakAddr<NetworkManager>,
-		client_manager: Addr<ClientManager>,
+		client_manager: WeakAddr<ClientManager>,
 	) -> Builder {
 		Builder::new(server, network_manager, client_manager)
 	}

server/src/rhai/builder.rs

@@ -1,24 +1,26 @@
-use actix::{Actor, Addr};
+use actix::{Actor, Addr, WeakAddr};
-
-use crate::client_management::ClientManager;
-use crate::network::NetworkManager;
-use crate::rhai::rhai_manager::RhaiManager;
-use crate::Server;
 use rhai::{Engine, Scope};
 
+use crate::{
+	client_management::ClientManager,
+	network::NetworkManager,
+	rhai::rhai_manager::RhaiManager,
+	Server,
+};
+
 pub struct Builder {
 	engine: Engine,
-	server: Addr<Server>,
+	server: WeakAddr<Server>,
-	network_manager: Addr<NetworkManager>,
+	network_manager: WeakAddr<NetworkManager>,
-	client_manager: Addr<ClientManager>,
+	client_manager: WeakAddr<ClientManager>,
 	scope: Scope<'static>,
 }
 
 impl Builder {
 	pub(super) fn new(
-		server: Addr<Server>,
+		server: WeakAddr<Server>,
-		network_manager: Addr<NetworkManager>,
+		network_manager: WeakAddr<NetworkManager>,
-		client_manager: Addr<ClientManager>,
+		client_manager: WeakAddr<ClientManager>,
 	) -> Self {
 		Builder {
 			engine: Engine::new(),

server/src/rhai/rhai_manager.rs

@@ -1,24 +1,26 @@
-use crate::client_management::ClientManager;
+use actix::{Actor, Addr, Context, WeakAddr};
-use crate::network::NetworkManager;
-use crate::rhai::builder::Builder;
-use crate::Server;
-
-use actix::{Actor, Addr, Context};
 use rhai::{Engine, Scope};
 
+use crate::{
+	client_management::ClientManager,
+	network::NetworkManager,
+	rhai::builder::Builder,
+	Server,
+};
+
 pub struct RhaiManager {
 	pub(super) engine: Engine,
 	pub(super) _scope: Scope<'static>,
-	pub(super) _server: Addr<Server>,
+	pub(super) _server: WeakAddr<Server>,
-	pub(super) _network_manager: Addr<NetworkManager>,
+	pub(super) _network_manager: WeakAddr<NetworkManager>,
-	pub(super) _client_manager: Addr<ClientManager>,
+	pub(super) _client_manager: WeakAddr<ClientManager>,
 }
 
 impl RhaiManager {
 	pub fn create(
-		server: Addr<Server>,
+		server: WeakAddr<Server>,
-		network_manager: Addr<NetworkManager>,
+		network_manager: WeakAddr<NetworkManager>,
-		client_manager: Addr<ClientManager>,
+		client_manager: WeakAddr<ClientManager>,
 	) -> Builder {
 		Builder::new(
 			server.clone(),

server/src/scripting/scriptable_server.rs

@@ -1,70 +1,64 @@
-use crate::scripting::scriptable_client_manager::ScriptableClientManager;
+use actix::{Addr, WeakAddr};
-use crate::scripting::scriptable_network_manager::ScriptableNetworkManager;
+use mlua::{Error, UserData, UserDataMethods, Value::Nil};
-use actix::Addr;
-use mlua::{Error, UserData, UserDataMethods};
 
-use crate::server::ServerDataResponse::{ClientManager, Name, NetworkManager, Owner};
+use crate::{
-use crate::server::*;
+	scripting::{
+		scriptable_client_manager::ScriptableClientManager,
+		scriptable_network_manager::ScriptableNetworkManager,
+	},
+	server::{
+		ServerDataResponse::{ClientManager, Name, NetworkManager, Owner},
+		*,
+	},
+};
 
 #[derive(Clone)]
 pub(crate) struct ScriptableServer {
-	pub(super) addr: Addr<Server>,
+	pub(super) addr: WeakAddr<Server>,
 }
 
 impl UserData for ScriptableServer {
 	fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
 		methods.add_async_method("name", |_lua, obj, ()| async move {
-			let name: Option<ServerDataResponse> =
+			let Some(send_fut) = obj.addr.upgrade().map(|addr| addr.send(ServerDataMessage::Name)) else {
-				obj.addr.send(ServerDataMessage::Name).await.ok();
+				return Err(Error::RuntimeError(
-			if let Some(Name(name)) = name {
+					"[ScriptableServer:name] Server doesn't exist. Dunno how you got here".to_string(),
-				Ok(name)
-			} else {
-				Err(Error::RuntimeError(
-					"Name returned null or other value".to_string(),
 				))
-			}
+			};
+
+			let name: Option<ServerDataResponse> = send_fut.await.ok();
+
+			let Some(Name(name)) = name else {
+				return Err(Error::RuntimeError(
+					"[ScriptableServer:name] Name returned nil".to_string(),
+				))
+			};
+
+			Ok(name)
 		});
 
 		methods.add_async_method("owner", |_lua, obj, ()| async move {
-			let owner: Option<ServerDataResponse> =
+			let Some(send_fut) = obj.addr.upgrade().map(|addr| addr.send(ServerDataMessage::Owner)) else {
-				obj.addr.send(ServerDataMessage::Owner).await.ok();
+				return Err(Error::RuntimeError(
-			if let Some(Owner(name)) = owner {
+					"[ScriptableServer:owner] Server doesn't exist. Dunno how you got here".to_string(),
-				Ok(name)
-			} else {
-				Err(Error::RuntimeError(
-					"Name returned null or other value".to_string(),
 				))
-			}
+			};
-		});
 
-		methods.add_async_method("client_manager", |_lua, obj, ()| async move {
+			let owner: Option<ServerDataResponse> = send_fut.await.ok();
-			let name: Option<ServerDataResponse> =
-				obj.addr.send(ServerDataMessage::ClientManager).await.ok();
-			if let Some(ClientManager(Some(cm))) = name {
-				Ok(ScriptableClientManager::from(cm))
-			} else {
-				Err(Error::RuntimeError(
-					"Name returned null or other value".to_string(),
-				))
-			}
-		});
 
-		methods.add_async_method("network_manager", |_lua, obj, ()| async move {
+			let Some(Name(owner)) = owner else {
-			let name: Option<ServerDataResponse> =
+				return Err(Error::RuntimeError(
-				obj.addr.send(ServerDataMessage::NetworkManager).await.ok();
+					"[ScriptableServer:owner] Owner returned nil".to_string(),
-			if let Some(NetworkManager(Some(nm))) = name {
-				Ok(ScriptableNetworkManager::from(nm))
-			} else {
-				Err(Error::RuntimeError(
-					"Name returned null or other value".to_string(),
 				))
-			}
+			};
+
+			Ok(owner)
 		});
 	}
 }
 
-impl From<Addr<Server>> for ScriptableServer {
+impl From<WeakAddr<Server>> for ScriptableServer {
-	fn from(addr: Addr<Server>) -> Self {
+	fn from(addr: WeakAddr<Server>) -> Self {
 		Self { addr }
 	}
 }

server/src/server/server.rs

@@ -99,18 +99,27 @@ impl Actor for Server {
 		let addr = ctx.address().downgrade();
 
 		let nm = NetworkManager::create(addr.clone().recipient()).build();
-		nm.do_send(NetworkMessage::StartListening);
-		self.network_manager.replace(nm.clone());
-
 		let cm = ClientManager::new(addr.recipient());
+		let rm = RhaiManager::create(
+			ctx.address().downgrade(),
+			nm.downgrade(),
+			cm.downgrade(),
+		)
+		.build();
+		let lm = LuaManager::create(
+			ctx.address().downgrade(),
+			nm.downgrade(),
+			cm.downgrade(),
+		)
+		.build();
+
+		self.network_manager.replace(nm.clone());
 		self.client_manager.replace(cm.clone());
-
-		let rm = RhaiManager::create(ctx.address(), nm.clone(), cm.clone()).build();
 		self.rhai_manager.replace(rm);
-
-		let lm = LuaManager::create(ctx.address(), nm, cm).build();
 		self.lua_manager.replace(lm);
 
+		nm.do_send(NetworkMessage::StartListening);
+
 		let name_fut = wrap_future(
 			ConfigManager::shared().send(GetValue("Server.Name".to_owned())),
 		)
@@ -137,7 +146,11 @@ impl Actor for Server {
 impl Handler<ServerDataMessage> for Server {
 	type Result = ServerDataResponse;
 
-	fn handle(&mut self, msg: ServerDataMessage, _ctx: &mut Self::Context) -> Self::Result {
+	fn handle(
+		&mut self,
+		msg: ServerDataMessage,
+		_ctx: &mut Self::Context,
+	) -> Self::Result {
 		println!("[Server] got data message");
 		match msg {
 			ServerDataMessage::Name => ServerDataResponse::Name(self.name.clone()),
@@ -154,7 +167,11 @@ impl Handler<ServerDataMessage> for Server {
 
 impl Handler<NetworkOutput> for Server {
 	type Result = ();
-	fn handle(&mut self, msg: NetworkOutput, ctx: &mut Self::Context) -> Self::Result {
+	fn handle(
+		&mut self,
+		msg: NetworkOutput,
+		ctx: &mut Self::Context,
+	) -> Self::Result {
 		println!("[ServerActor] received message");
 		match msg {
 			// This uses promise like funcionality to queue