feat: move backend structure to shared module

Signed-off-by: iverly <[email protected]>

proxy/src/lib.rs

@@ -12,7 +12,6 @@ use tokio::{
 
 use crate::stream::Stream;
 
-pub mod backend;
 pub mod stream;
 
 /// The proxy is responsible for accepting connections from the client and
@@ -237,11 +236,13 @@ impl Proxy {
                             })?;
                     }
                     Event::PutBackend(backend, tx) => {
-                        tx.send(storage.lock().await.add_backend(backend::Backend::new(
-                            backend.hostname,
-                            backend.redirect_ip,
-                            backend.redirect_port,
-                        )))
+                        tx.send(storage.lock().await.add_backend(
+                            shared::models::backend::Backend::new(
+                                backend.hostname,
+                                backend.redirect_ip,
+                                backend.redirect_port,
+                            ),
+                        ))
                         .map_err(|_| {
                             log::error!("failed to send put backend response");
                             anyhow!("failed to send put backend response")
@@ -252,11 +253,11 @@ impl Proxy {
                             .lock()
                             .await
                             .get_backends()
-                            .into_iter()
+                            .iter()
                             .map(|backend| shared::models::backend::Backend {
-                                hostname: backend.hostname().to_string(),
-                                redirect_ip: backend.redirect_ip().to_string(),
-                                redirect_port: backend.redirect_port(),
+                                hostname: backend.1.hostname().to_string(),
+                                redirect_ip: backend.1.redirect_ip().to_string(),
+                                redirect_port: backend.1.redirect_port(),
                             })
                             .collect::<Vec<_>>()))
                             .map_err(|_| {

shared/src/models/backend.rs

@@ -1,6 +1,68 @@
+/// A backend is a Minecraft server that the proxy can connect to.
+///
+/// Properties:
+///
+/// * `host`: The hostname of the backend server.
+/// * `port`: The port that the backend server is listening on.
 #[derive(Debug, Clone)]
 pub struct Backend {
     pub hostname: String,
     pub redirect_ip: String,
     pub redirect_port: u16,
 }
+
+impl Backend {
+    /// Creates a new instance of the `Backend` struct
+    ///
+    /// Arguments:
+    ///
+    /// * `host` - The host of the backend
+    /// * `port` - The port of the backend
+    ///
+    /// Returns:
+    ///
+    /// A new instance of the struct.
+    pub fn new(hostname: String, redirect_ip: String, redirect_port: u16) -> Self {
+        Self {
+            hostname,
+            redirect_ip,
+            redirect_port,
+        }
+    }
+
+    /// It returns the host of the backend
+    ///
+    /// Returns:
+    ///
+    /// The host of the backend
+    pub fn hostname(&self) -> &str {
+        self.hostname.as_str()
+    }
+
+    /// It returns the ip of the backend
+    ///
+    /// Returns:
+    ///
+    /// The ip of the backend
+    pub fn redirect_ip(&self) -> &str {
+        self.redirect_ip.as_str()
+    }
+
+    /// It returns the port of the backend
+    ///
+    /// Returns:
+    ///
+    /// The port of the backend
+    pub fn redirect_port(&self) -> u16 {
+        self.redirect_port
+    }
+
+    /// It returns the address of the backend
+    ///
+    /// Returns:
+    ///
+    /// The address of the backend
+    pub fn addr(&self) -> String {
+        self.redirect_ip.clone() + ":" + &self.redirect_port.to_string()
+    }
+}