server/src/main.rs

@@ -11,8 +11,8 @@ pub(crate) mod scripting;
 pub(crate) mod server;
 
 pub mod listener_manager;
+pub mod network_connection;
 pub mod os_signal_manager;
-pub mod protobuf_listener;
 pub mod server_va;
 
 use crate::server_va::Server;

server/src/network_connection.rs

@@ -0,0 +1,76 @@
+use std::{io, net::SocketAddr};
+
+use foundation::{
+	networking::{read_message, write_message},
+	prelude::{
+		network_client_message,
+		network_server_message,
+		Connect,
+		GetInfo,
+		Info,
+		NetworkClientMessage,
+		NetworkServerMessage,
+		Request,
+	},
+};
+use tokio::net::TcpStream;
+
+pub struct NetworkConnection {
+	stream: TcpStream,
+	addr: SocketAddr,
+}
+
+impl NetworkConnection {
+	pub fn new(stream: TcpStream, addr: SocketAddr) -> Self {
+		Self { stream, addr }
+	}
+
+	pub async fn get_request(&mut self) -> io::Result<ServerRequest> {
+		let message = NetworkServerMessage {
+			message: Some(network_server_message::Message::Request(Request {
+				a: true,
+			})),
+		};
+
+		println!("[NetworkConnection] made message {:?}", message);
+		write_message(&mut self.stream, message).await.unwrap();
+
+		let request = read_message::<NetworkClientMessage>(&mut self.stream)
+			.await
+			.unwrap();
+
+		match request {
+			NetworkClientMessage {
+				message: Some(network_client_message::Message::GetInfo(GetInfo {})),
+			} => Ok(ServerRequest::GetInfo),
+			NetworkClientMessage {
+				message:
+					Some(network_client_message::Message::Connect(Connect {
+						username,
+						uuid,
+					})),
+			} => Ok(ServerRequest::Connect {
+				username,
+				uuid: uuid.parse().unwrap(),
+			}),
+			_ => Ok(ServerRequest::Ignore),
+		}
+	}
+
+	pub async fn send_info(mut self, name: String, owner: String) {
+		let message = NetworkServerMessage {
+			message: Some(network_server_message::Message::GotInfo(Info {
+				server_name: name,
+				owner,
+			})),
+		};
+
+		write_message(&mut self.stream, message).await.unwrap();
+	}
+}
+
+pub enum ServerRequest {
+	GetInfo,
+	Connect { username: String, uuid: uuid::Uuid },
+	Ignore,
+}

server/src/protobuf_listener.rs

@@ -1,3 +0,0 @@
-pub struct ProtobufListener;
-
-impl ProtobufListener {}

server/src/server_va.rs

@@ -1,20 +1,4 @@
-use std::net::SocketAddr;
-
-use foundation::{
-	networking::{read_message, write_message},
-	prelude::{
-		network_client_message,
-		network_server_message,
-		GetInfo,
-		Info,
-		NetworkClientMessage,
-		NetworkServerMessage,
-		Request,
-	},
-};
 use tokio::{
-	io::AsyncWriteExt,
-	net::TcpStream,
 	sync::{
 		mpsc::{unbounded_channel, UnboundedReceiver},
 		Mutex,
@@ -24,6 +8,7 @@ use tokio::{
 
 use crate::{
 	listener_manager::{ConnectionType, ListenerManager},
+	network_connection::{NetworkConnection, ServerRequest},
 	os_signal_manager::OSSignalManager,
 };
 
@@ -49,49 +34,29 @@ impl Server {
 				Some(ServerMessages::NewConnection(
 					ConnectionType::ProtobufConnection(stream, addr),
 				)) => {
+					let conn = NetworkConnection::new(stream, addr);
 					println!("[Server] New protobuf connection");
-					self.handle_protobuf_connection(stream, addr).await;
+					self.handle_protobuf_connection(conn).await;
 				}
 			};
 		}
 	}
 
-	async fn handle_protobuf_connection(
-		&self,
-		mut stream: TcpStream,
-		_addr: SocketAddr,
-	) {
-		let message = NetworkServerMessage {
-			message: Some(network_server_message::Message::Request(Request {
-				a: true,
-			})),
-		};
+	async fn handle_protobuf_connection(&self, mut conn: NetworkConnection) {
+		let req = conn.get_request().await.unwrap();
 
-		println!("[Server] made message {:?}", message);
-		write_message(&mut stream, message).await.unwrap();
-
-		let request = read_message::<NetworkClientMessage>(&mut stream)
-			.await
-			.unwrap();
-
-		match request {
-			NetworkClientMessage {
-				message: Some(network_client_message::Message::GetInfo(GetInfo {})),
-			} => {
-				let message = NetworkServerMessage {
-					message: Some(network_server_message::Message::GotInfo(Info {
-						server_name: "Test server".into(),
-						owner: "mickyb18a@gmail.com".into(),
-					})),
-				};
-				write_message(&mut stream, message).await.unwrap();
-			}
-			_ => {
-				println!("[Server] message not supported");
+		match req {
+			ServerRequest::GetInfo => {
+				conn
+					.send_info("test server".into(), "mickyb18a@gmail.com".into())
+					.await
 			}
+			ServerRequest::Connect {
+				username: _,
+				uuid: _,
+			} => todo!(),
+			ServerRequest::Ignore => todo!(),
 		}
-
-		let _ = stream.flush().await;
 	}
 
 	fn shutdown(&self) {