Delete futriix-server/src/server.rs

futriix-server/src/server.rs

@@ -1,123 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::sync::Arc;
-use parking_lot::RwLock;
-use crossbeam::queue::SegQueue;
-use tokio::net::{TcpListener, TcpStream};
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use log::{info, error};
-use colored::Colorize;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum Command {
-    Insert { key: String, value: serde_json::Value },
-    Get { key: String },
-    Update { key: String, value: serde_json::Value },
-    Delete { key: String },
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum Response {
-    Success(Option<serde_json::Value>),
-    Error(String),
-}
-
-pub struct FutriixServer {
-    db: Arc<RwLock<HashMap<String, serde_json::Value>>>,
-    command_queue: Arc<SegQueue<Command>>,
-}
-
-impl FutriixServer {
-    pub fn new() -> Self {
-        FutriixServer {
-            db: Arc::new(RwLock::new(HashMap::new())),
-            command_queue: Arc::new(SegQueue::new()),
-        }
-    }
-
-    pub async fn run(&self, addr: &str) -> Result<(), Box<dyn std::error::Error>> {
-        let listener = TcpListener::bind(addr).await?;
-        
-        info!("{}", "Futriix Server started successfully!".bright_blue());
-        info!("Listening on: {}", addr);
-
-        loop {
-            let (socket, _) = listener.accept().await?;
-            let db = self.db.clone();
-            let queue = self.command_queue.clone();
-
-            tokio::spawn(async move {
-                if let Err(e) = Self::handle_connection(socket, db, queue).await {
-                    error!("Connection error: {}", e);
-                }
-            });
-        }
-    }
-
-    async fn handle_connection(
-        mut socket: TcpStream,
-        db: Arc<RwLock<HashMap<String, serde_json::Value>>>,
-        queue: Arc<SegQueue<Command>>,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        loop {
-            // Read command length
-            let mut len_buf = [0u8; 4];
-            if let Err(e) = socket.read_exact(&mut len_buf).await {
-                if e.kind() == std::io::ErrorKind::UnexpectedEof {
-                    break; // Client disconnected
-                }
-                return Err(e.into());
-            }
-            let len = u32::from_be_bytes(len_buf) as usize;
-            
-            // Read command
-            let mut buf = vec![0u8; len];
-            socket.read_exact(&mut buf).await?;
-            
-            let cmd: Command = rmp_serde::from_slice(&buf)?;
-            queue.push(cmd);
-            
-            while let Some(cmd) = queue.pop() {
-                let response = match cmd {
-                    Command::Insert { key, value } => {
-                        let mut db = db.write();
-                        db.insert(key, value);
-                        Response::Success(None)
-                    }
-                    Command::Get { key } => {
-                        let db = db.read();
-                        match db.get(&key) {
-                            Some(value) => Response::Success(Some(value.clone())),
-                            None => Response::Error("Key not found".to_string()),
-                        }
-                    }
-                    Command::Update { key, value } => {
-                        let mut db = db.write();
-                        if db.contains_key(&key) {
-                            db.insert(key, value);
-                            Response::Success(None)
-                        } else {
-                            Response::Error("Key not found".to_string())
-                        }
-                    }
-                    Command::Delete { key } => {
-                        let mut db = db.write();
-                        if db.remove(&key).is_some() {
-                            Response::Success(None)
-                        } else {
-                            Response::Error("Key not found".to_string())
-                        }
-                    }
-                };
-
-                let response_bytes = rmp_serde::to_vec(&response)?;
-                // Send response length
-                let len = response_bytes.len() as u32;
-                socket.write_all(&len.to_be_bytes()).await?;
-                // Send response
-                socket.write_all(&response_bytes).await?;
-            }
-        }
-        Ok(())
-    }
-}