Change handling server offline

src/main.rs

@@ -1,6 +1,6 @@
 // Yeahbut December 2023
 
-use tokio::net::{TcpListener, TcpStream};
+use tokio::net::{TcpListener, TcpStream, tcp::{OwnedReadHalf, OwnedWriteHalf}};
 use tokio::io;
 use std::error::Error;
 
@@ -27,10 +27,21 @@ async fn handle_client(client_socket: TcpStream) {
 
     let (mut client_reader, mut client_writer) = client_socket.into_split();
 
-    let backend_socket = TcpStream::connect(backend_addr)
+    // "Failed to connect to the backend server"
-        .await.expect("Failed to connect to the backend server");
+
+    let backend_socket = match TcpStream::connect(backend_addr).await {
+        Ok(backend_socket) => Some(backend_socket.into_split()),
+        Err(_) => None,
+    };
+
+    let (mut server_reader, mut server_writer):
+        (Option<OwnedReadHalf>, Option<OwnedWriteHalf>) =
+            match backend_socket {
+                Some(backend_socket) =>
+                    (Some(backend_socket.0), Some(backend_socket.1)),
+                None => (None, None),
+    };
 
-    let (mut server_reader, mut server_writer) = backend_socket.into_split();
     let mut buffer: [u8; 1] = [0; 1];
     client_reader.peek(&mut buffer)
         .await.expect("Failed to peek at first byte from stream");
@@ -54,28 +65,45 @@ async fn handle_client(client_socket: TcpStream) {
             ).await.expect("Error handling status request");
             return;
         } else if handshake_packet.next_state == 2 {
-            handshake::write_handshake(&mut server_writer, handshake::Handshake{
+            match server_writer {
-                protocol_version: mc_types::VERSION_PROTOCOL,
+                Some(mut server_writer) => {
-                server_address: "localhost".to_string(),
+                    handshake::write_handshake(
-                server_port: 25565,
+                        &mut server_writer,
-                next_state: 2,
+                        handshake::Handshake {
-            }).await.expect("Error logging into backend server");
+                            protocol_version: mc_types::VERSION_PROTOCOL,
+                            server_address: "localhost".to_string(),
+                            server_port: 25565,
+                            next_state: 2,
+                        },
+                    ).await.expect("Error logging into backend server");
+
+                    // Forward from client to backend
+                    tokio::spawn(async move {
+                        io::copy(&mut client_reader, &mut server_writer).await
+                            .expect("Error copying from client to backend");
+                    });
+
+                    // Forward from backend to client
+                    match server_reader {
+                        Some(mut server_reader) => tokio::spawn(async move {
+                            io::copy(&mut server_reader, &mut client_writer)
+                                .await
+                                .expect("Error copying from backend to client");
+                        }),
+                        None => {
+                            eprintln!(
+                                "Failed to connect to the backend server");
+                            return;
+                        }
+                    };
+                },
+                None => {}
+            };
         } else {
             return;
         }
     }
 
-    // Forward from client to backend
-    tokio::spawn(async move {
-        io::copy(&mut client_reader, &mut server_writer)
-            .await.expect("Error copying from client to backend");
-    });
-
-    // Forward from backend to client
-    tokio::spawn(async move {
-        io::copy(&mut server_reader, &mut client_writer)
-            .await.expect("Error copying from backend to client");
-    });
 
     println!("Connection Closed");
 }

src/status.rs

@@ -117,8 +117,8 @@ fn favicon() -> Option<String> {
 pub async fn respond_status(
     client_reader: &mut OwnedReadHalf,
     client_writer: &mut OwnedWriteHalf,
-    server_reader: &mut OwnedReadHalf,
+    server_reader: &mut Option<OwnedReadHalf>,
-    server_writer: &mut OwnedWriteHalf,
+    server_writer: &mut Option<OwnedWriteHalf>,
 )-> Result<()> {
     loop {
         println!("Status Handling");
@@ -129,26 +129,59 @@ pub async fn respond_status(
 
         if packet_id == 0x00 {
             println!("Handling Status");
-            let online_players =
+            let favicon = favicon();
-                online_players(server_reader, server_writer).await?;
+
-            let status_response = StatusResponseData {
+            let online_players = match server_reader {
-                version: StatusVersion {
+                Some(server_reader) => match server_writer {
-                    name: mc_types::VERSION_NAME.to_string(),
+                    Some(server_writer) => match online_players(
-                    protocol: mc_types::VERSION_PROTOCOL,
+                        server_reader,
+                        server_writer,
+                    ).await {
+                        Ok(value) => Some(value),
+                        Err(_) => None,
+                    },
+                    None => None,
                 },
-                description: mc_types::Chat {
+                None => None,
-                    text: motd(),
+            };
-                },
+
-                players: StatusPlayers {
+            let status_response =
-                    max: -13,
+                match online_players {
-                    online: online_players.online,
+                    Some(online_players) => StatusResponseData {
-                    sample: online_players.sample,
+                        version: StatusVersion {
-                },
+                            name: mc_types::VERSION_NAME.to_string(),
-                favicon: favicon(),
+                            protocol: mc_types::VERSION_PROTOCOL,
-                enforcesSecureChat: None,
+                        },
-                previewsChat: None,
+                        description: mc_types::Chat {
-                // enforcesSecureChat: Some(false),
+                            text: motd(),
-                // previewsChat: Some(false),
+                        },
+                        players: StatusPlayers {
+                            max: -13,
+                            online: online_players.online,
+                            sample: online_players.sample,
+                        },
+                        favicon: favicon,
+                        enforcesSecureChat: Some(false),
+                        previewsChat: Some(false),
+                    },
+                    None => StatusResponseData {
+                        version: StatusVersion {
+                            name: "Old".to_string(),
+                            protocol: 0,
+                        },
+                        description: mc_types::Chat {
+                            text: "Server Error (Server may be starting)"
+                                .to_string() + "\nPurple Cello Server",
+                        },
+                        players: StatusPlayers {
+                            max: 0,
+                            online: 0,
+                            sample: None,
+                        },
+                        favicon: favicon,
+                        enforcesSecureChat: Some(false),
+                        previewsChat: Some(false),
+                    },
             };
 
             let json = serde_json::to_string(&status_response)?;