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

Merge branch 'feature/cleanup' into develop

This commit is contained in:
michael-bailey 2022-09-15 08:28:03 +01:00
parent ecbc3aafb6 065e16964f
commit 32ea5eec71
15 changed files with 236 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
server/src/client_management/client/client.rs
View File

@ -1,14 +1,20 @@
use actix::{Actor, Addr, AsyncContext, Context, Handler, Recipient};
use foundation::ClientDetails;
use foundation::messages::client::ClientStreamIn;
use std::net::SocketAddr;
use uuid::Uuid;
use crate::client_management::client::messages::{ClientDataMessage, ClientDataResponse, ClientMessage, ClientObservableMessage};
use crate::client_management::client::messages::ClientObservableMessage::{SendGlobalMessageRequest, SendMessageRequest, UpdateRequest};
use crate::client_management::client::messages::ClientObservableMessage::{
SendGlobalMessageRequest, SendMessageRequest, UpdateRequest,
};
use crate::client_management::client::messages::{
ClientDataMessage, ClientDataResponse, ClientMessage,
ClientObservableMessage,
};
use crate::network::{Connection, ConnectionOuput};
use crate::prelude::messages::ObservableMessage;
use actix::{Actor, Addr, AsyncContext, Context, Handler, Recipient};
use foundation::messages::client::ClientStreamIn;
use foundation::ClientDetails;
use std::net::SocketAddr;
use uuid::Uuid;
/// messages the client will send to itself
#[allow(dead_code)]
enum SelfMessage {
ReceivedMessage(ClientStreamIn),
}
@ -38,15 +44,12 @@ impl Client {
fn handle_request(
&mut self,
ctx: &mut Context<Client>,
sender: Addr<Connection>,
addr: SocketAddr,
_sender: Addr<Connection>,
_addr: SocketAddr,
data: String,
) {
use foundation::messages::client::ClientStreamIn::{
Disconnect,
SendGlobalMessage,
SendMessage,
Update,
Disconnect, SendGlobalMessage, SendMessage, Update,
};
use serde_json::from_str;
let msg = from_str::<ClientStreamIn>(data.as_str())
@ -90,7 +93,7 @@ impl Client {
}
#[inline]
fn handle_disconnect(&self, ctx: &mut Context<Client>) {
fn handle_disconnect(&self, _ctx: &mut Context<Client>) {
todo!()
}
@ -107,29 +110,31 @@ impl Actor for Client {
// tells the client that it has been connected.
fn started(&mut self, ctx: &mut Self::Context) {
use crate::network::ConnectionMessage::SendData;
use crate::prelude::messages::ObservableMessage::Subscribe;
use foundation::messages::client::ClientStreamOut;
use foundation::messages::client::ClientStreamOut::Connected;
use serde_json::to_string;
use foundation::messages::client::ClientStreamOut;
use crate::network::ConnectionMessage::SendData;
use crate::network::ConnectionOuput;
use crate::prelude::messages::ObservableMessage::Subscribe;
println!("[Client] started");
self.connection
.do_send::<ObservableMessage<ConnectionOuput>>(Subscribe(ctx.address().recipient()));
.do_send::<ObservableMessage<ConnectionOuput>>(Subscribe(
ctx.address().recipient(),
));
self.connection.do_send(SendData(
to_string::<ClientStreamOut>(&Connected).unwrap(),
));
}
fn stopped(&mut self, ctx: &mut Self::Context) {
use crate::network::ConnectionMessage::SendData;
use crate::prelude::messages::ObservableMessage::Unsubscribe;
use foundation::messages::client::ClientStreamOut;
use foundation::messages::client::ClientStreamOut::Disconnected;
use serde_json::to_string;
use foundation::messages::client::ClientStreamOut;
use crate::network::ConnectionMessage::SendData;
use crate::network::ConnectionOuput;
use crate::prelude::messages::ObservableMessage::Unsubscribe;
self.connection
.do_send::<ObservableMessage<ConnectionOuput>>(Unsubscribe(ctx.address().recipient()));
.do_send::<ObservableMessage<ConnectionOuput>>(Unsubscribe(
ctx.address().recipient(),
));
self.connection.do_send(SendData(
to_string::<ClientStreamOut>(&Disconnected).unwrap(),
));
@ -141,11 +146,13 @@ impl Handler<ClientDataMessage> for Client {
fn handle(
&mut self,
msg: ClientDataMessage,
ctx: &mut Self::Context,
_ctx: &mut Self::Context,
) -> Self::Result {
match msg {
ClientDataMessage::Details => ClientDataResponse::Details(self.details.clone()),
_ => todo!()
ClientDataMessage::Details => {
ClientDataResponse::Details(self.details.clone())
}
_ => todo!(),
}
}
}
@ -158,11 +165,15 @@ impl Handler<ClientMessage> for Client {
msg: ClientMessage,
_ctx: &mut Self::Context,
) -> Self::Result {
use crate::client_management::client::messages::ClientMessage::{SendGlobalMessage, SendMessage, SendUpdate};
use foundation::messages::client::ClientStreamOut::{ConnectedClients, GlobalMessage, UserMessage};
use serde_json::to_string;
use foundation::messages::client::ClientStreamOut;
use crate::client_management::client::messages::ClientMessage::{
SendGlobalMessage, SendMessage, SendUpdate,
};
use crate::network::ConnectionMessage::SendData;
use foundation::messages::client::ClientStreamOut;
use foundation::messages::client::ClientStreamOut::{
ConnectedClients, GlobalMessage, UserMessage,
};
use serde_json::to_string;
match msg {
SendUpdate(clients) => self.connection.do_send(SendData(
@ -182,7 +193,6 @@ impl Handler<ClientMessage> for Client {
.expect("[Client] Failed to encode string"),
))
}
_ => todo!(),
}
}
}
@ -201,7 +211,6 @@ impl Handler<ConnectionOuput> for Client {
RecvData(sender, addr, data) => {
self.handle_request(ctx, sender, addr, data)
}
_ => todo!(),
}
}
@ -213,9 +222,11 @@ impl Handler<ObservableMessage<ClientObservableMessage>> for Client {
fn handle(
&mut self,
msg: ObservableMessage<ClientObservableMessage>,
ctx: &mut Self::Context,
_ctx: &mut Self::Context,
) -> Self::Result {
use crate::prelude::messages::ObservableMessage::{Subscribe, Unsubscribe};
use crate::prelude::messages::ObservableMessage::{
Subscribe, Unsubscribe,
};
match msg {
Subscribe(r) => {
println!("[Client] adding subscriber");

104
server/src/client_management/client_manager.rs
View File

@ -1,46 +1,31 @@
use std::collections::HashMap;
use actix::{
Actor,
ActorFutureExt,
ActorStreamExt,
Addr,
ArbiterHandle,
AsyncContext,
Context,
fut::{wrap_future, wrap_stream},
Handler,
MailboxError,
Message,
MessageResponse,
Recipient,
Running,
StreamHandler,
WeakAddr,
fut::wrap_future, Actor, Addr, AsyncContext, Context, Handler, WeakAddr,
WeakRecipient,
};
use foundation::{
ClientDetails,
messages::client::{ClientStreamIn, ClientStreamIn::SendGlobalMessage},
};
use futures::{SinkExt, TryStreamExt};
use foundation::ClientDetails;
use tokio_stream::StreamExt;
use uuid::Uuid;
use crate::{
network::NetworkOutput,
prelude::messages::ObservableMessage,
};
use crate::client_management::client::{Client, ClientDataResponse};
use crate::client_management::client::{ClientDataMessage, ClientMessage, ClientObservableMessage};
use crate::client_management::client::ClientDataResponse::Details;
use crate::client_management::client::ClientMessage::SendMessage;
use crate::client_management::messages::{ClientManagerDataMessage, ClientManagerDataResponse, ClientManagerMessage, ClientManagerOutput};
use crate::client_management::messages::ClientManagerDataResponse::{ClientCount, Clients};
use crate::client_management::client::{Client, ClientDataResponse};
use crate::client_management::client::{
ClientDataMessage, ClientObservableMessage,
};
use crate::client_management::messages::ClientManagerDataResponse::{
ClientCount, Clients,
};
use crate::client_management::messages::{
ClientManagerDataMessage, ClientManagerDataResponse, ClientManagerMessage,
ClientManagerOutput,
};
pub struct ClientManager {
clients: HashMap<Uuid, Addr<Client>>,
delegate: WeakRecipient<ClientManagerOutput>,
_delegate: WeakRecipient<ClientManagerOutput>,
}
impl ClientManager {
@ -48,10 +33,10 @@ impl ClientManager {
delegate: WeakRecipient<ClientManagerOutput>,
) -> Addr<Self> {
ClientManager {
delegate,
_delegate: delegate,
clients: HashMap::new(),
}
.start()
.start()
}
pub(crate) fn send_update(
@ -61,19 +46,24 @@ impl ClientManager {
) {
println!("[ClientManager] sending update to client");
use crate::client_management::client::ClientMessage::SendUpdate;
let self_addr = ctx.address();
if let Some(to_send) = addr.upgrade() {
let client_addr: Vec<Addr<Client>> =
self.clients.iter().map(|(_, v)| v).cloned().collect();
let collection = tokio_stream::iter(client_addr)
.then(|addr| addr.send(ClientDataMessage::Details))
.map(|val| if let Details(details) = val.unwrap() { details } else { ClientDetails::default() })
.map(|val| {
if let Details(details) = val.unwrap() {
details
} else {
ClientDetails::default()
}
})
.collect();
let fut = wrap_future(async move {
let a: Vec<_> = collection.await;
to_send.send(SendUpdate(a)).await;
let _ = to_send.send(SendUpdate(a)).await;
});
ctx.spawn(fut);
@ -84,7 +74,7 @@ impl ClientManager {
&self,
ctx: &mut Context<ClientManager>,
sender: WeakAddr<Client>,
uuid: Uuid,
_uuid: Uuid,
content: String,
) {
println!("[ClientManager] sending message to client");
@ -94,10 +84,12 @@ impl ClientManager {
let collection = tokio_stream::iter(client_addr)
.then(|addr| addr.send(ClientDataMessage::Details))
.map(|val| val.unwrap())
.map(|val: ClientDataResponse| if let Details(details) = val {
details
} else {
ClientDetails::default()
.map(|val: ClientDataResponse| {
if let Details(details) = val {
details
} else {
ClientDetails::default()
}
})
.collect();
@ -114,8 +106,11 @@ impl ClientManager {
let client_details: Vec<ClientDetails> = collection.await;
let pos = client_details.iter().position(|i| i.uuid == from);
if let Some(pos) = pos {
sender.send(SendMessage { content, from }).await.expect("TODO: panic message");
if let Some(_) = pos {
sender
.send(SendMessage { content, from })
.await
.expect("TODO: panic message");
}
}
});
@ -135,7 +130,6 @@ impl ClientManager {
if let Some(sender) = sender.upgrade() {
let fut = wrap_future(async move {
let details: ClientDataResponse =
sender.send(ClientDataMessage::Details).await.unwrap();
@ -153,7 +147,8 @@ impl ClientManager {
})
})
.collect();
let a: Vec<_> = collection.await;
// this is shit, i dont need this
let _: Vec<_> = collection.await;
});
ctx.spawn(fut);
}
@ -185,7 +180,7 @@ impl ClientManager {
impl Actor for ClientManager {
type Context = Context<Self>;
fn started(&mut self, ctx: &mut Self::Context) {
fn started(&mut self, _ctx: &mut Self::Context) {
println!("[ClientManager] started");
}
}
@ -216,9 +211,7 @@ impl Handler<ClientObservableMessage> for ClientManager {
ctx: &mut Self::Context,
) -> Self::Result {
use crate::client_management::client::ClientObservableMessage::{
SendGlobalMessageRequest,
SendMessageRequest,
UpdateRequest,
SendGlobalMessageRequest, SendMessageRequest, UpdateRequest,
};
match msg {
SendMessageRequest(addr, uuid, content) => {
@ -228,7 +221,6 @@ impl Handler<ClientObservableMessage> for ClientManager {
self.send_global_message_request(ctx, addr, content)
}
UpdateRequest(addr) => self.send_update(ctx, addr),
_ => todo!(),
}
}
}
@ -236,16 +228,18 @@ impl Handler<ClientObservableMessage> for ClientManager {
impl Handler<ClientManagerDataMessage> for ClientManager {
type Result = ClientManagerDataResponse;
fn handle(&mut self, msg: ClientManagerDataMessage, ctx: &mut Self::Context) -> Self::Result {
fn handle(
&mut self,
msg: ClientManagerDataMessage,
_ctx: &mut Self::Context,
) -> Self::Result {
match msg {
ClientManagerDataMessage::ClientCount => {
ClientCount(self.clients.values().count())
}
ClientManagerDataMessage::Clients => Clients(
self.clients.values()
.map(|a| a.downgrade())
.collect()
)
ClientManagerDataMessage::Clients => {
Clients(self.clients.values().map(|a| a.downgrade()).collect())
}
}
}
}

12
server/src/client_management/messages.rs
View File

@ -1,18 +1,20 @@
use crate::client_management::client::Client;
use crate::client_management::ClientManager;
use actix::{Addr, Message, MessageResponse, WeakAddr};
use uuid::Uuid;
use crate::client_management::ClientManager;
use crate::client_management::client::Client;
#[derive(Message)]
#[rtype(result = "()")]
pub(crate) enum ClientManagerMessage {
AddClient(Uuid, Addr<Client>),
#[allow(dead_code)]
RemoveClient(Uuid),
}
#[derive(Message)]
#[rtype(result = "()")]
pub(crate) enum ClientManagerOutput {
#[allow(dead_code)]
UpdateRequest(Addr<ClientManager>),
}
@ -20,11 +22,11 @@ pub(crate) enum ClientManagerOutput {
#[rtype(result = "ClientManagerDataResponse")]
pub enum ClientManagerDataMessage {
ClientCount,
Clients
Clients,
}
#[derive(MessageResponse)]
pub enum ClientManagerDataResponse {
ClientCount(usize),
Clients(Vec<WeakAddr<Client>>)
}
Clients(Vec<WeakAddr<Client>>),
}

8
server/src/config_manager/builder.rs
View File

@ -21,19 +21,11 @@ impl Builder {
self
}
pub fn set_config_path(&mut self, path: impl Into<String>) {
self.file_path = path.into();
}
pub fn args(mut self, args: Arguments) -> Self {
self.args.replace(args);
self
}
pub fn set_args(&mut self, args: Arguments) {
self.args.replace(args);
}
pub(super) fn build(self) -> Addr<ConfigManager> {
ConfigManager::from(self).start()
}

3
server/src/config_manager/messages.rs
View File

@ -4,6 +4,7 @@ use actix::{Message, MessageResponse};
#[derive(Message, Debug)]
#[rtype(result = "()")]
pub enum ConfigManagerOutput {
#[allow(dead_code)]
ConfigUpdated(String, ConfigValue),
}
@ -11,7 +12,9 @@ pub enum ConfigManagerOutput {
#[rtype(result = "ConfigManagerDataResponse")]
pub enum ConfigManagerDataMessage {
GetValue(String),
#[allow(dead_code)]
SetValue(String, Option<ConfigValue>),
#[allow(dead_code)]
SoftSetValue(String, Option<ConfigValue>),
}

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

@ -1,13 +1,10 @@
use actix::{Actor, Addr};
use mlua::Lua;
use rhai::{Engine, RegisterNativeFunction, Scope};
use crate::client_management::ClientManager;
use crate::lua::lua_manager::LuaManager;
use crate::network::NetworkManager;
use crate::Server;
use actix::Addr;
pub struct Builder {
pub(crate) engine: Lua,
pub(super) server: Addr<Server>,
pub(super) network_manager: Addr<NetworkManager>,
pub(super) client_manager: Addr<ClientManager>,
@ -20,7 +17,6 @@ impl Builder {
client_manager: Addr<ClientManager>,
) -> Self {
Builder {
engine: Lua::new(),
server,
network_manager,
client_manager,
@ -30,4 +26,4 @@ impl Builder {
pub(crate) fn build(self) -> Addr<LuaManager> {
Addr::from(self)
}
}
}

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

@ -2,36 +2,31 @@
//!
//! Holds the LuaManger struct and implements it's methods
use actix::{Actor, Addr, ArbiterHandle, AsyncContext, Context, Running};
use actix::fut::wrap_future;
use mlua::{Lua, Thread, ThreadStatus};
use rhai::{Engine, Func, Scope};
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 mlua::{Lua, Thread};
/// # 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) _network_manager: Addr<NetworkManager>,
pub(super) _client_manager: Addr<ClientManager>,
}
impl LuaManager {
pub fn create(
server: Addr<Server>,
network_manager: Addr<NetworkManager>,
client_manager: Addr<ClientManager>
client_manager: Addr<ClientManager>,
) -> Builder {
Builder::new(
server,
network_manager,
client_manager
)
Builder::new(server, network_manager, client_manager)
}
fn create_lua(&self) -> Lua {
@ -53,13 +48,18 @@ impl Actor for LuaManager {
let engine = self.create_lua();
ctx.spawn(wrap_future(async move {
let coroutine: Thread = engine.load(r#"
let coroutine: Thread = engine
.load(
r#"
coroutine.create(function ()
print("hello lua")
print(chat.server:name())
end)
"#).eval().unwrap();
let coroutine = coroutine.into_async::<(),()>(());
"#,
)
.eval()
.unwrap();
let coroutine = coroutine.into_async::<(), ()>(());
coroutine.await.expect("TODO: panic message");
}));
}
@ -71,8 +71,9 @@ impl From<Builder> for Addr<LuaManager> {
fn from(b: Builder) -> Addr<LuaManager> {
LuaManager {
server: b.server,
network_manager: b.network_manager,
client_manager: b.client_manager
}.start()
_network_manager: b.network_manager,
_client_manager: b.client_manager,
}
.start()
}
}

32
server/src/network/connection/mod.rs
View File

@ -1,27 +1,14 @@
use std::{io::Write, net::SocketAddr, pin::Pin, sync::Arc};
use actix::{
fut::wrap_future,
Actor,
ActorContext,
Addr,
AsyncContext,
Context,
Handler,
Message,
Recipient,
SpawnHandle,
fut::wrap_future, Actor, ActorContext, Addr, AsyncContext, Context,
Handler, Message, Recipient, SpawnHandle,
};
use futures::{future::join_all, Future, FutureExt};
use serde::Serialize;
use tokio::{
io::{
split,
AsyncBufReadExt,
AsyncWriteExt,
BufReader,
ReadHalf,
WriteHalf,
split, AsyncBufReadExt, AsyncWriteExt, BufReader, ReadHalf, WriteHalf,
},
net::TcpStream,
sync::Mutex,
@ -64,7 +51,7 @@ pub struct Connection {
write_half: Arc<Mutex<WriteHalf<TcpStream>>>,
address: SocketAddr,
observers: Vec<Recipient<ConnectionOuput>>,
loop_future: Option<SpawnHandle>,
_loop_future: Option<SpawnHandle>,
}
impl Connection {
@ -78,7 +65,7 @@ impl Connection {
write_half: Arc::new(Mutex::new(write_half)),
address,
observers: Vec::new(),
loop_future: None,
_loop_future: None,
}
.start()
}
@ -113,7 +100,8 @@ impl Actor for Connection {
}
println!("[Connection] read line");
addr.send(UpdateObserversWithData(buffer_string.clone()))
let _ = addr
.send(UpdateObserversWithData(buffer_string.clone()))
.await;
buffer_string.clear();
}
@ -171,8 +159,8 @@ impl Handler<ConnectionMessage> for Connection {
println!("[Connection] sending data");
let mut lock = writer.lock().await;
let mut buffer = Vec::new();
writeln!(&mut buffer, "{}", d.as_str());
lock.write_all(&buffer).await;
let _ = writeln!(&mut buffer, "{}", d.as_str());
let _ = lock.write_all(&buffer).await;
}));
}
CloseConnection => ctx.stop(),

23
server/src/network/connection_initiator/mod.rs
View File

@ -1,14 +1,7 @@
use std::net::SocketAddr;
use actix::{
Actor,
ActorContext,
Addr,
AsyncContext,
Context,
Handler,
Message,
Recipient,
Actor, ActorContext, Addr, AsyncContext, Context, Handler, Message,
WeakRecipient,
};
use foundation::{
@ -25,12 +18,6 @@ use crate::{
prelude::messages::ObservableMessage,
};
#[derive(Debug, Clone, Copy)]
enum ConnectionPhase {
Started,
Requested,
}
#[derive(Message)]
#[rtype(result = "()")]
pub(crate) enum InitiatorOutput {
@ -65,13 +52,11 @@ impl ConnectionInitiator {
&mut self,
sender: Addr<Connection>,
ctx: &mut <Self as Actor>::Context,
address: SocketAddr,
_address: SocketAddr,
data: String,
) {
use InitiatorOutput::{ClientRequest, InfoRequest};
use NetworkSockIn::{Connect, Info};
use NetworkSockOut::{Connecting, GotInfo};
use ObservableMessage::Unsubscribe;
let msg = from_str::<NetworkSockIn>(data.as_str());
if let Err(e) = msg.as_ref() {
@ -155,8 +140,8 @@ impl Handler<ConnectionOuput> for ConnectionInitiator {
msg: ConnectionOuput,
ctx: &mut Self::Context,
) -> Self::Result {
use ConnectionOuput::{ConnectionClosed, RecvData};
use ConnectionPhase::Requested;
use ConnectionOuput::RecvData;
if let RecvData(sender, addr, data) = msg {
self.handle_request(sender, ctx, addr, data)
}

20
server/src/network/listener/mod.rs
View File

@ -1,23 +1,12 @@
use std::net::{SocketAddr, ToSocketAddrs};
use actix::{
fut::wrap_future,
Actor,
Addr,
AsyncContext,
Context,
Handler,
Message,
Recipient,
SpawnHandle,
fut::wrap_future, Actor, Addr, AsyncContext, Context, Handler, Message,
Recipient, SpawnHandle,
};
use tokio::net::TcpListener;
use crate::network::{
connection::Connection,
ConnectionInitiator,
InitiatorOutput,
};
use crate::network::connection::Connection;
#[derive(Message)]
#[rtype(result = "()")]
@ -58,9 +47,8 @@ impl NetworkListener {
fn start_listening(&mut self, ctx: &mut <Self as Actor>::Context) {
println!("[NetworkListener] started listening");
let addr = self.address.clone();
let self_addr = ctx.address();
let delegate = self.delegate.clone();
let loop_future = ctx.spawn(wrap_future(async move {
ctx.spawn(wrap_future(async move {
use ListenerOutput::NewConnection;
let listener = TcpListener::bind(addr).await.unwrap();
while let Ok((stream, addr)) = listener.accept().await {

22
server/src/prelude/mod.rs
View File

@ -3,17 +3,25 @@
mod observer;
#[allow(unused_imports)]
pub mod actors {
//! exports all actors used in the program.
pub use crate::server::Server;
pub(crate) use crate::network::{Connection, ConnectionInitiator, NetworkManager};
pub(crate) use crate::client_management::ClientManager;
pub(crate) use crate::client_management::client::Client;
pub(crate) use crate::client_management::ClientManager;
pub(crate) use crate::network::{
Connection, ConnectionInitiator, NetworkManager,
};
pub use crate::server::Server;
}
#[allow(unused_imports)]
pub mod messages {
//! exports all messages used in the program.
pub(crate) use super::observer::ObservableMessage;
pub(crate) use crate::network::{ConnectionMessage, ConnectionOuput, NetworkMessage, NetworkOutput};
pub(crate) use crate::client_management::{ClientManagerMessage, ClientManagerOutput};
}
pub(crate) use crate::client_management::{
ClientManagerMessage, ClientManagerOutput,
};
pub(crate) use crate::network::{
ConnectionMessage, ConnectionOuput, NetworkMessage, NetworkOutput,
};
}

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

@ -1,10 +1,10 @@
use actix::{Actor, Addr};
use mlua::Lua;
use rhai::{Engine, RegisterNativeFunction, Scope};
use crate::client_management::ClientManager;
use crate::rhai::rhai_manager::RhaiManager;
use crate::network::NetworkManager;
use crate::rhai::rhai_manager::RhaiManager;
use crate::Server;
use rhai::{Engine, Scope};
pub struct Builder {
engine: Engine,
@ -25,34 +25,36 @@ impl Builder {
server,
network_manager,
client_manager,
scope: Default::default()
scope: Default::default(),
}
}
pub fn scope_object<T: 'static>(mut self, name: &str, obj: T) -> Self
where
T: Clone {
where
T: Clone,
{
self.engine.register_type::<T>();
self.scope.set_value(name, obj);
self
}
pub fn scope_fn<F, A>(mut self, name: &str, func: F ) -> Self
where
F: RegisterNativeFunction<A, ()>
{
self.engine.register_fn(name, func);
self
}
// not sure what this is for?
// pub fn scope_fn<F, A>(mut self, name: &str, func: F) -> Self
// where
// F: RegisterNativeFunction<A, ()>,
// {
// self.engine.register_fn(name, func);
// self
// }
pub(crate) fn build(self) -> Addr<RhaiManager> {
RhaiManager {
engine: self.engine,
scope: self.scope,
server: self.server,
network_manager: self.network_manager,
client_manager: self.client_manager
}.start()
_scope: self.scope,
_server: self.server,
_network_manager: self.network_manager,
_client_manager: self.client_manager,
}
.start()
}
}
}

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

@ -1,37 +1,44 @@
use actix::{Actor, Addr, ArbiterHandle, AsyncContext, Context, Running};
use actix::fut::wrap_future;
use rhai::{Engine, Func, Scope};
use crate::client_management::ClientManager;
use crate::rhai::builder::Builder;
use crate::network::NetworkManager;
use crate::rhai::builder::Builder;
use crate::Server;
use actix::{Actor, Addr, Context};
use rhai::{Engine, Scope};
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) _scope: Scope<'static>,
pub(super) _server: Addr<Server>,
pub(super) _network_manager: Addr<NetworkManager>,
pub(super) _client_manager: Addr<ClientManager>,
}
impl RhaiManager {
pub fn create(
server: Addr<Server>,
network_manager: Addr<NetworkManager>,
client_manager: Addr<ClientManager>
client_manager: Addr<ClientManager>,
) -> Builder {
Builder::new(server.clone(), network_manager.clone(), client_manager.clone())
.scope_object("server", server)
Builder::new(
server.clone(),
network_manager.clone(),
client_manager.clone(),
)
.scope_object("server", server)
}
}
impl Actor for RhaiManager {
type Context = Context<Self>;
fn started(&mut self, ctx: &mut Self::Context) {
self.engine.run(r#"
fn started(&mut self, _ctx: &mut Self::Context) {
self.engine
.run(
r#"
print("hello rhai")
"#).unwrap();
"#,
)
.unwrap();
}
}

36
server/src/scripting/scriptable_client.rs
View File

@ -1,41 +1,49 @@
use actix::Addr;
use mlua::{Error, UserData, UserDataFields, UserDataMethods};
use crate::client_management::client::Client;
use crate::client_management::client::{ClientDataMessage, ClientDataResponse};
use crate::client_management::client::ClientDataResponse::{Username, Uuid};
use crate::server::ServerDataResponse::Name;
use crate::client_management::client::{ClientDataMessage, ClientDataResponse};
use actix::Addr;
use mlua::{Error, UserData, UserDataMethods};
#[derive(Clone)]
pub(crate) struct ScriptableClient {
addr: Addr<Client>
addr: Addr<Client>,
}
impl UserData for ScriptableClient {
fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
methods.add_async_method("username", |_lua, obj, ()| async move {
let name: Option<ClientDataResponse> = obj.addr.send(ClientDataMessage::Username).await.ok();
let name: Option<ClientDataResponse> =
obj.addr.send(ClientDataMessage::Username).await.ok();
if let Some(Username(name)) = name {
Ok(name)
} else {
Err(Error::RuntimeError("Name returned null or other value".to_string()))
Err(Error::RuntimeError(
"Name returned null or other value".to_string(),
))
}
});
methods.add_async_method("uuid", |_lua, obj, ()| async move {
let uuid: Option<ClientDataResponse> = obj.addr.send(ClientDataMessage::Uuid).await.ok();
let uuid: Option<ClientDataResponse> =
obj.addr.send(ClientDataMessage::Uuid).await.ok();
if let Some(Uuid(uuid)) = uuid {
Ok(uuid.to_string())
} else {
Err(Error::RuntimeError("Uuid returned null or other value".to_string()))
Err(Error::RuntimeError(
"Uuid returned null or other value".to_string(),
))
}
});
methods.add_async_method("address", |_lua, obj, ()| async move {
let address: Option<ClientDataResponse> = obj.addr.send(ClientDataMessage::Address).await.ok();
let address: Option<ClientDataResponse> =
obj.addr.send(ClientDataMessage::Address).await.ok();
if let Some(Username(address)) = address {
Ok(address)
} else {
Err(Error::RuntimeError("address returned null or other value".to_string()))
Err(Error::RuntimeError(
"address returned null or other value".to_string(),
))
}
});
}
@ -43,8 +51,6 @@ impl UserData for ScriptableClient {
impl From<Addr<Client>> for ScriptableClient {
fn from(addr: Addr<Client>) -> Self {
Self {
addr
}
Self { addr }
}
}
}

24
server/src/scripting/scriptable_client_manager.rs
View File

@ -1,21 +1,21 @@
use actix::{ActorStreamExt, Addr};
use mlua::{Error, UserData, UserDataFields, UserDataMethods};
use crate::client_management::{ClientManager, ClientManagerDataMessage};
use crate::client_management::ClientManagerDataResponse::Clients;
use crate::client_management::{ClientManager, ClientManagerDataMessage};
use crate::scripting::scriptable_client::ScriptableClient;
use actix::Addr;
use mlua::{Error, UserData, UserDataMethods};
#[derive(Clone)]
pub(crate) struct ScriptableClientManager {
addr: Addr<ClientManager>
addr: Addr<ClientManager>,
}
impl UserData for ScriptableClientManager {
fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
methods.add_async_method("clients", |lua, obj, ()| async move {
methods.add_async_method("clients", |_lua, obj, ()| async move {
let res = obj.addr.send(ClientManagerDataMessage::Clients).await;
if let Ok(Clients(clients)) = res {
let clients: Vec<ScriptableClient> = clients.into_iter()
let clients: Vec<ScriptableClient> = clients
.into_iter()
.map(|a| a.upgrade())
.filter(|o| o.is_some())
.map(|o| o.unwrap())
@ -24,7 +24,9 @@ impl UserData for ScriptableClientManager {
Ok(clients)
} else {
Err(Error::RuntimeError("clients returned null or other value".to_string()))
Err(Error::RuntimeError(
"clients returned null or other value".to_string(),
))
}
})
}
@ -32,8 +34,6 @@ impl UserData for ScriptableClientManager {
impl From<Addr<ClientManager>> for ScriptableClientManager {
fn from(addr: Addr<ClientManager>) -> Self {
Self {
addr
}
Self { addr }
}
}
}