British-Information-Technologies
/
ChatKit-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

removing strong references from scriping managers

This commit is contained in:
michael-bailey 2023-01-19 21:24:40 +00:00
parent c1616ce11f
commit 4381311fe3
7 changed files with 124 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
rustfmt.toml
View File

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

25
server/src/lua/builder.rs
View File

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

28
server/src/lua/lua_manager.rs
View File

@ -2,29 +2,31 @@
//!
//! Holds the LuaManger struct and implements it's methods
use crate::client_management::ClientManager;
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 actix::{fut::wrap_future, Actor, Addr, AsyncContext, Context, WeakAddr};
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) _network_manager: Addr<NetworkManager>,
pub(super) _client_manager: Addr<ClientManager>,
pub(super) server: WeakAddr<Server>,
pub(super) _network_manager: WeakAddr<NetworkManager>,
pub(super) _client_manager: WeakAddr<ClientManager>,
}
impl LuaManager {
pub fn create(
server: Addr<Server>,
network_manager: Addr<NetworkManager>,
client_manager: Addr<ClientManager>,
server: WeakAddr<Server>,
network_manager: WeakAddr<NetworkManager>,
client_manager: WeakAddr<ClientManager>,
) -> Builder {
Builder::new(server, network_manager, client_manager)
}

26
server/src/rhai/builder.rs
View File

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

26
server/src/rhai/rhai_manager.rs
View File

@ -1,24 +1,26 @@
use crate::client_management::ClientManager;
use crate::network::NetworkManager;
use crate::rhai::builder::Builder;
use crate::Server;
use actix::{Actor, Addr, Context};
use actix::{Actor, Addr, Context, WeakAddr};
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) _network_manager: Addr<NetworkManager>,
pub(super) _client_manager: Addr<ClientManager>,
pub(super) _server: WeakAddr<Server>,
pub(super) _network_manager: WeakAddr<NetworkManager>,
pub(super) _client_manager: WeakAddr<ClientManager>,
}
impl RhaiManager {
pub fn create(
server: Addr<Server>,
network_manager: Addr<NetworkManager>,
client_manager: Addr<ClientManager>,
server: WeakAddr<Server>,
network_manager: WeakAddr<NetworkManager>,
client_manager: WeakAddr<ClientManager>,
) -> Builder {
Builder::new(
server.clone(),

86
server/src/scripting/scriptable_server.rs
View File

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

35
server/src/server/server.rs
View File

@ -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