misc: remove useless code

Miaxos · Miaxos · commit 11180f6ad244 · 2024-01-23T11:37:25.000+01:00
Signed-off-by: Anthony Griffon &lt;anthony@griffon.one&gt;
diff --git a/app/roster/src/application/server/cmd/get.rs b/app/roster/src/application/server/cmd/get.rs
@@ -4,8 +4,8 @@ use super::parse::Parse;
 use super::CommandExecution;
 use crate::application::server::connection::WriteConnection;
 use crate::application::server::context::Context;
-use crate::application::server::crc_hash;
 use crate::application::server::frame::Frame;
+use crate::infrastructure::hash::crc_hash;
 
 /// Get the value of key. If the key does not exist the special value nil is
 /// returned. An error is returned if the value stored at key is not a string,
diff --git a/app/roster/src/application/server/cmd/set.rs b/app/roster/src/application/server/cmd/set.rs
@@ -3,14 +3,13 @@ use std::time::Duration;
 use bytes::Bytes;
 use bytestring::ByteString;
 
-
 use super::parse::{Parse, ParseError};
 use super::CommandExecution;
 use crate::application::server::connection::WriteConnection;
 use crate::application::server::context::Context;
 use crate::application::server::frame::Frame;
-use crate::application::server::{crc_hash};
 use crate::domain::storage::SetOptions;
+use crate::infrastructure::hash::crc_hash;
 
 /// Set key to hold the string value. If key already holds a value, it is
 /// overwritten, regardless of its type.
diff --git a/app/roster/src/application/server/handle.rs b/app/roster/src/application/server/handle.rs
@@ -1,10 +1,8 @@
 use std::cell::RefCell;
-use std::os::fd::{IntoRawFd};
+use std::os::fd::IntoRawFd;
 use std::rc::Rc;
 use std::time::Duration;
 
-
-
 use sharded_thread::shard::Shard;
 
 use super::cmd::Command;
@@ -38,6 +36,7 @@ impl Handler {
         self.run_internal(ctx, None).await
     }
 
+    #[allow(dead_code)]
     pub async fn continue_run(
         self,
         ctx: Context,
diff --git a/app/roster/src/application/server/mod.rs b/app/roster/src/application/server/mod.rs
@@ -1,34 +1,24 @@
 //! The whole redis server implementation is here.
 use std::net::SocketAddr;
-
-
 use std::sync::atomic::AtomicU16;
 use std::sync::Arc;
 use std::thread::JoinHandle;
 
-use crc::{Crc, CRC_16_XMODEM};
 use derive_builder::Builder;
 
-
-
 mod connection;
 mod context;
 pub mod frame;
 pub(crate) mod handle;
 
-
-
-
 mod cmd;
 mod server_thread;
 
 use self::server_thread::ServerMonoThreadedHandle;
-
-
 use crate::application::server::handle::ConnectionMsg;
-
 use crate::domain::dialer::{RootDialer, Slot};
 use crate::domain::storage::Storage;
+use crate::infrastructure::hash::HASH_SLOT_MAX;
 
 #[derive(Debug, Builder, Clone)]
 #[builder(pattern = "owned", setter(into, strip_option))]
@@ -38,21 +28,6 @@ pub struct ServerConfig {
     connections_limit: Arc<AtomicU16>,
 }
 
-cfg_if::cfg_if! {
-    if #[cfg(target_os = "linux")] {
-        type Driver = monoio::IoUringDriver;
-    } else {
-        type Driver = monoio::LegacyDriver;
-    }
-}
-
-const CRC: Crc<u16> = Crc::<u16>::new(&CRC_16_XMODEM);
-
-pub const HASH_SLOT_MAX: u16 = 16384;
-pub const fn crc_hash(bytes: &[u8]) -> u16 {
-    CRC.checksum(bytes) % HASH_SLOT_MAX
-}
-
 impl ServerConfig {
     /// Initialize a Server by starting the thread for each core and assigning
     /// the storage segment & hash slots based on the configuration.
@@ -83,153 +58,6 @@ impl ServerConfig {
             threads.push(handle.initialize());
         }
 
-        /*
-        let mut slots = Vec::new();
-        for cpu in 0..cpus {
-            let part_size: u16 = HASH_SLOT_MAX / cpus as u16;
-            let remainder: u16 = HASH_SLOT_MAX % cpus as u16;
-
-            let start = cpu as u16 * part_size as u16;
-            let end = if cpu == cpus - 1 {
-                (cpu as u16 + 1) * part_size + remainder as u16
-            } else {
-                (cpu as u16 + 1) * part_size as u16
-            };
-
-            let slot = start..end;
-            slots.push(slot);
-        }
-
-        for cpu in 0..cpus {
-            let config = self.clone();
-            let shard = mesh.join_with(cpu).unwrap();
-
-            let slot = slots.get(cpu).unwrap().clone();
-            let slots = slots.clone();
-
-            let handle = std::thread::spawn(move || {
-                monoio::utils::bind_to_cpu_set(Some(cpu)).unwrap();
-
-                let mut rt = monoio::RuntimeBuilder::<Driver>::new()
-                    .with_entries(1024)
-                    .enable_timer()
-                    .build()
-                    .expect("Cannot build runtime");
-
-                rt.block_on(async move {
-                    // Initialize domain
-                    let storage =
-                        domain::storage::StorageSegment::new(slots, slot);
-                    let shard = Rc::new(shard);
-
-                    let listener = TcpListener::bind_with_config(
-                        config.bind_addr,
-                        &ListenerConfig::new().backlog(16192),
-                    )
-                    .expect("Couldn't listen to addr");
-
-                    // Start the async task which is able to receive connection
-                    // from other thread
-                    let storage_inter_thread = storage.clone();
-                    let shard_inter_thread = shard.clone();
-                    monoio::spawn(async move {
-                        let storage = storage_inter_thread;
-                        let shard = shard_inter_thread;
-
-                        let mut receiver = shard.receiver().unwrap();
-
-                        loop {
-                            let shard = shard.clone();
-                            let ctx = Context::new(storage.clone());
-
-                            // Pre-allocate next buffer;
-
-                            if let Some(ConnectionMsg {
-                                fd,
-                                current_command,
-                                rest_frame,
-                            }) = receiver.next().await
-                            {
-                                let _spawned = monoio::spawn(async move {
-                                    // TODO: We miss things in the buffer right
-                                    // now &
-                                    // pipelining
-                                    // Already accepted tcp stream, we don't
-                                    // need to
-                                    // accept it again.
-                                    let tcp = unsafe {
-                                        std::net::TcpStream::from_raw_fd(fd)
-                                    };
-                                    let conn =
-                                        TcpStream::from_std(tcp).unwrap();
-                                    conn.set_nodelay(true).unwrap();
-
-                                    let (connection, r) =
-                                        WriteConnection::new(conn, 4 * 1024);
-
-                                    let handler = Handler {
-                                        connection,
-                                        connection_r: r,
-                                        shard,
-                                    };
-
-                                    if let Err(err) = handler
-                                        .continue_run(ctx, current_command)
-                                        .await
-                                    {
-                                        dbg!(err.backtrace());
-                                        dbg!(&err);
-                                        // error!(?err);
-                                        panic!("blbl");
-                                    }
-                                    // handler.connection.stop().await.unwrap();
-                                });
-                            } else {
-                                break;
-                            }
-                        }
-                    });
-
-                    loop {
-                        let storage = storage.clone();
-                        let shard = shard.clone();
-
-                        // We accept the TCP Connection
-                        let (conn, _addr) = listener
-                            .accept()
-                            .await
-                            .expect("Unable to accept connections");
-
-                        conn.set_nodelay(true).unwrap();
-                        let ctx = Context::new(storage);
-
-                        // We map it to an `Handler` which is able to understand
-                        // the Redis protocol
-                        let _spawned = monoio::spawn(async move {
-                            let (connection, r) =
-                                WriteConnection::new(conn, 4 * 1024);
-
-                            let handler = Handler {
-                                connection,
-                                connection_r: r,
-                                shard: shard.clone(),
-                            };
-
-                            if let Err(err) = handler.run(ctx).await {
-                                dbg!(err.backtrace());
-                                dbg!(&err);
-                                // error!(?err);
-                                panic!("blbl");
-                            }
-                            // handler.connection.stop().await.unwrap();
-                        });
-                    }
-                });
-            });
-            threads.push(handle);
-        }
-        */
-
         ServerHandle { threads }
     }
 }
diff --git a/app/roster/src/application/server/server_thread.rs b/app/roster/src/application/server/server_thread.rs
@@ -1,7 +1,6 @@
 use std::rc::Rc;
 use std::thread::JoinHandle;
 
-
 use monoio::net::{ListenerConfig, TcpListener};
 
 use super::ServerConfig;
@@ -31,10 +30,6 @@ pub struct ServerMonoThreadedHandle {
     storage: StorageSegment,
 }
 
-pub struct ServerMonoThreadedInitialized {
-    handle: JoinHandle<()>,
-}
-
 impl ServerMonoThreadedHandle {
     /// Start a new server thread on the cpu_core
     pub fn new(
@@ -55,8 +50,6 @@ impl ServerMonoThreadedHandle {
     }
 
     pub fn initialize(self) -> JoinHandle<()> {
-        
-
         std::thread::spawn(move || {
             monoio::utils::bind_to_cpu_set(Some(self.cpu)).unwrap();
 
@@ -112,7 +105,8 @@ impl ServerMonoThreadedHandle {
 
                 #[allow(unreachable_code)]
                 Ok::<(), anyhow::Error>(())
-            });
+            })
+            .unwrap();
         })
     }
 }
diff --git a/app/roster/src/domain/dialer/mod.rs b/app/roster/src/domain/dialer/mod.rs
@@ -1,7 +1,5 @@
 use std::ops::{Deref, Range};
 
-
-
 use sharded_thread::mesh::MeshBuilder;
 use sharded_thread::shard::Shard;
 
@@ -69,12 +67,16 @@ impl RootDialer {
 #[derive(Debug)]
 pub struct Dialer {
     pub shard: Shard<ConnectionMsg>,
+    #[allow(dead_code)]
     cluster: Cluster,
     /// The current local slot of the Dialer
+    #[allow(dead_code)]
     local_slot: Slot,
     /// The whole slice of the current server
+    #[allow(dead_code)]
     global_slot: Slot,
     /// Slot -> part based on index
+    #[allow(dead_code)]
     inner_slots: Vec<Slot>,
 }
 
