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

making moe things weak repferences

This commit is contained in:
michael-bailey 2023-01-21 10:07:41 +00:00
parent 93c7851edd
commit 59568570ff
4 changed files with 88 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
server/src/client_management/client/actor.rs
View File

@ -26,7 +26,10 @@ pub struct Client {
}
impl Client {
pub(crate) fn new(connection: Addr<Connection>, details: ClientDetails) -> Addr<Self> {
pub(crate) fn new(
connection: Addr<Connection>,
details: ClientDetails,
) -> Addr<Self> {
Client {
connection,
details,
@ -139,9 +142,15 @@ impl Actor for Client {
impl Handler<ClientDataMessage> for Client {
type Result = ClientDataResponse;
fn handle(&mut self, msg: ClientDataMessage, _ctx: &mut Self::Context) -> Self::Result {
fn handle(
&mut self,
msg: ClientDataMessage,
_ctx: &mut Self::Context,
) -> Self::Result {
match msg {
ClientDataMessage::Details => ClientDataResponse::Details(self.details.clone()),
ClientDataMessage::Details => {
ClientDataResponse::Details(self.details.clone())
}
_ => todo!(),
}
}
@ -150,7 +159,11 @@ impl Handler<ClientDataMessage> for Client {
// Handles incoming messages to the client.
impl Handler<ClientMessage> for Client {
type Result = ();
fn handle(&mut self, msg: ClientMessage, _ctx: &mut Self::Context) -> Self::Result {
fn handle(
&mut self,
msg: ClientMessage,
_ctx: &mut Self::Context,
) -> Self::Result {
use foundation::messages::client::ClientStreamOut::{
ConnectedClients,
GlobalChatMessages,
@ -180,15 +193,19 @@ impl Handler<ClientMessage> for Client {
.expect("[Client] Failed to encode string"),
)),
ClientlySentMessage { content, from } => self.connection.do_send(SendData(
to_string::<ClientStreamOut>(&UserMessage { from, content })
.expect("[Client] Failed to encode string"),
)),
ClientlySentMessage { content, from } => {
self.connection.do_send(SendData(
to_string::<ClientStreamOut>(&UserMessage { from, content })
.expect("[Client] Failed to encode string"),
))
}
GloballySentMessage { from, content } => self.connection.do_send(SendData(
to_string::<ClientStreamOut>(&GlobalMessage { from, content })
.expect("[Client] Failed to encode string"),
)),
GloballySentMessage { from, content } => {
self.connection.do_send(SendData(
to_string::<ClientStreamOut>(&GlobalMessage { from, content })
.expect("[Client] Failed to encode string"),
))
}
}
}
}
@ -217,7 +234,9 @@ impl Handler<ConnectionObservableOutput> for Client {
GetClients => self.get_clients(ctx),
GetMessages => self.get_messages(ctx),
SendMessage { to, content } => self.send_message(ctx, to, content),
SendGlobalMessage { content } => self.send_gloal_message(ctx, content),
SendGlobalMessage { content } => {
self.send_gloal_message(ctx, content)
}
Disconnect => self.disconnect(ctx),
}
} else {

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

@ -46,7 +46,9 @@ pub struct ClientManager {
}
impl ClientManager {
pub(crate) fn new(delegate: WeakRecipient<ClientManagerOutput>) -> Addr<Self> {
pub(crate) fn new(
delegate: WeakRecipient<ClientManagerOutput>,
) -> Addr<Self> {
ClientManager {
_delegate: delegate,
clients: HashMap::new(),
@ -92,12 +94,14 @@ impl ClientManager {
sender: WeakAddr<Client>,
) {
if let Some(to_send) = sender.upgrade() {
let fut = wrap_future(self.chat_manager.send(ChatManagerDataMessage::GetMessages))
.map(move |out, _a, _ctx| {
if let Ok(ChatManagerDataResponse::GotMessages(res)) = out {
to_send.do_send(ClientMessage::MessageList(res));
}
});
let fut = wrap_future(
self.chat_manager.send(ChatManagerDataMessage::GetMessages),
)
.map(move |out, _a, _ctx| {
if let Ok(ChatManagerDataResponse::GotMessages(res)) = out {
to_send.do_send(ClientMessage::MessageList(res));
}
});
ctx.spawn(fut);
};
}
@ -220,6 +224,7 @@ impl ClientManager {
println!("[ClientManager] adding client");
use crate::prelude::messages::ObservableMessage::Subscribe;
let recp = ctx.address().recipient::<ClientObservableMessage>();
println!("[ClientManager] sending subscribe message to client");
addr.do_send(Subscribe(recp.downgrade()));
self.clients.insert(uuid, addr);
}
@ -229,11 +234,16 @@ impl ClientManager {
use crate::prelude::messages::ObservableMessage::Unsubscribe;
let recp = ctx.address().recipient::<ClientObservableMessage>();
if let Some(addr) = self.clients.remove(&uuid) {
println!("[ClientManager] sending unsubscribe message to client");
addr.do_send(Unsubscribe(recp.downgrade()));
}
}
fn disconnect_client(&mut self, ctx: &mut Context<ClientManager>, uuid: Uuid) {
fn disconnect_client(
&mut self,
ctx: &mut Context<ClientManager>,
uuid: Uuid,
) {
println!("[ClientManager] disconnecting client");
use crate::prelude::messages::ObservableMessage::Unsubscribe;
let recp = ctx.address().recipient::<ClientObservableMessage>();
@ -284,7 +294,9 @@ impl Handler<ClientObservableMessage> for ClientManager {
Message,
};
match msg {
Message(sender, to, content) => self.send_message_request(ctx, sender, to, content),
Message(sender, to, content) => {
self.send_message_request(ctx, sender, to, content)
}
GlobalMessage(sender, content) => {
self.send_global_message_request(ctx, sender, content)
}
@ -304,7 +316,9 @@ impl Handler<ClientManagerDataMessage> for ClientManager {
_ctx: &mut Self::Context,
) -> Self::Result {
match msg {
ClientManagerDataMessage::ClientCount => ClientCount(self.clients.values().count()),
ClientManagerDataMessage::ClientCount => {
ClientCount(self.clients.values().count())
}
ClientManagerDataMessage::Clients => {
Clients(self.clients.values().map(|a| a.downgrade()).collect())
}

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

@ -8,8 +8,8 @@ use actix::{
Context,
Handler,
Message,
Recipient,
SpawnHandle,
WeakRecipient,
};
use tokio::net::TcpListener;
@ -30,14 +30,14 @@ pub(super) enum ListenerOutput {
pub(super) struct NetworkListener {
address: SocketAddr,
delegate: Recipient<ListenerOutput>,
delegate: WeakRecipient<ListenerOutput>,
looper: Option<SpawnHandle>,
}
impl NetworkListener {
pub(crate) fn new<T: ToSocketAddrs>(
address: T,
delegate: Recipient<ListenerOutput>,
delegate: WeakRecipient<ListenerOutput>,
) -> Addr<NetworkListener> {
NetworkListener {
address: address
@ -61,7 +61,12 @@ impl NetworkListener {
while let Ok((stream, addr)) = listener.accept().await {
println!("[NetworkListener] accepted socket");
let conn = Connection::new(stream, addr);
delegate.do_send(NewConnection(conn));
let Some(delegate) = delegate.upgrade() else {
break;
};
delegate.do_send(NewConnection(conn))
}
}));
}

32
server/src/network/network_manager/actor.rs
View File

@ -80,8 +80,10 @@ impl NetworkManager {
) {
println!("[NetworkManager] Got new connection");
let init =
ConnectionInitiator::new(ctx.address().recipient().downgrade(), connection);
let init = ConnectionInitiator::new(
ctx.address().recipient().downgrade(),
connection,
);
self.initiators.push(init);
}
@ -141,9 +143,9 @@ impl Actor for NetworkManager {
let config_mgr = self.config_manager.clone().upgrade();
if let Some(config_mgr) = config_mgr {
let fut = wrap_future(config_mgr.send(ConfigManagerDataMessage::GetValue(
"Network.Port".to_owned(),
)))
let fut = wrap_future(config_mgr.send(
ConfigManagerDataMessage::GetValue("Network.Port".to_owned()),
))
.map(
|out, actor: &mut NetworkManager, ctx: &mut Context<NetworkManager>| {
use crate::config_manager::ConfigManagerDataResponse::GotValue;
@ -152,13 +154,17 @@ impl Actor for NetworkManager {
let recipient = ctx.address().recipient();
let port = if let Ok(GotValue(Some(ConfigValue::Number(port)))) = out {
let port = if let Ok(GotValue(Some(ConfigValue::Number(port)))) = out
{
port
} else {
5600
};
println!("[NetworkManager] got port: {:?}", port);
let nl = NetworkListener::new(format!("0.0.0.0:{}", port), recipient);
let nl = NetworkListener::new(
format!("0.0.0.0:{}", port),
recipient.downgrade(),
);
nl.do_send(ListenerMessage::StartListening);
actor.listener_addr.replace(nl);
},
@ -202,7 +208,11 @@ impl Handler<NetworkDataMessage> for NetworkManager {
impl Handler<ListenerOutput> for NetworkManager {
type Result = ();
fn handle(&mut self, msg: ListenerOutput, ctx: &mut Self::Context) -> Self::Result {
fn handle(
&mut self,
msg: ListenerOutput,
ctx: &mut Self::Context,
) -> Self::Result {
use ListenerOutput::NewConnection;
match msg {
NewConnection(connection) => self.new_connection(ctx, connection),
@ -212,7 +222,11 @@ impl Handler<ListenerOutput> for NetworkManager {
impl Handler<InitiatorOutput> for NetworkManager {
type Result = ();
fn handle(&mut self, msg: InitiatorOutput, ctx: &mut Self::Context) -> Self::Result {
fn handle(
&mut self,
msg: InitiatorOutput,
ctx: &mut Self::Context,
) -> Self::Result {
use InitiatorOutput::{ClientRequest, InfoRequest};
match msg {
ClientRequest(sender, addr, client_details) => {