misc: clippy

Signed-off-by: Anthony Griffon <[email protected]>

Author: Miaxos

app/roster/src/application/server/cmd/set.rs

@@ -2,14 +2,14 @@ use std::time::Duration;
 
 use bytes::Bytes;
 use bytestring::ByteString;
-use crc::{Crc, CRC_16_XMODEM};
+
 
 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, CRC};
+use crate::application::server::{crc_hash};
 use crate::domain::storage::SetOptions;
 
 /// Set key to hold the string value. If key already holds a value, it is

app/roster/src/application/server/connection.rs

@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 use std::io::{self, Cursor};
-use std::rc::Rc;
+
 
 use bytes::BytesMut;
 use monoio::buf::IoBuf;

app/roster/src/application/server/context.rs

@@ -22,7 +22,7 @@ impl Context {
         self.storage.is_in_slot(hash)
     }
 
-    pub fn slot_nb(&self, hash: u16) -> Option<usize> {
+    pub fn slot_nb(&self, _hash: u16) -> Option<usize> {
         todo!()
         // self.storage.slot_nb(hash)
     }

app/roster/src/application/server/handle.rs

@@ -1,10 +1,10 @@
 use std::cell::RefCell;
-use std::os::fd::{AsRawFd, IntoRawFd};
+use std::os::fd::{IntoRawFd};
 use std::rc::Rc;
 use std::time::Duration;
 
-use monoio::net::TcpStream;
-use monoio::time::Instant;
+
+
 use sharded_thread::shard::Shard;
 
 use super::cmd::Command;

app/roster/src/application/server/mod.rs

@@ -1,33 +1,33 @@
 //! The whole redis server implementation is here.
 use std::net::SocketAddr;
-use std::os::fd::{FromRawFd, RawFd};
-use std::rc::Rc;
+
+
 use std::sync::atomic::AtomicU16;
 use std::sync::Arc;
 use std::thread::JoinHandle;
 
 use crc::{Crc, CRC_16_XMODEM};
 use derive_builder::Builder;
-use futures::StreamExt;
-use monoio::net::{ListenerConfig, TcpListener, TcpStream};
+
+
 
 mod connection;
 mod context;
 pub mod frame;
 pub(crate) mod handle;
-use handle::Handler;
-use monoio::time::Instant;
-use sharded_thread::shard::Shard;
+
+
+
 
 mod cmd;
 mod server_thread;
 
 use self::server_thread::ServerMonoThreadedHandle;
-use crate::application::server::connection::WriteConnection;
-use crate::application::server::context::Context;
+
+
 use crate::application::server::handle::ConnectionMsg;
-use crate::domain;
-use crate::domain::dialer::{Dialer, RootDialer, Slot};
+
+use crate::domain::dialer::{RootDialer, Slot};
 use crate::domain::storage::Storage;
 
 #[derive(Debug, Builder, Clone)]

app/roster/src/application/server/server_thread.rs

@@ -1,8 +1,8 @@
 use std::rc::Rc;
 use std::thread::JoinHandle;
 
-use futures::future::Join;
-use monoio::net::{ListenerConfig, TcpListener, TcpStream};
+
+use monoio::net::{ListenerConfig, TcpListener};
 
 use super::ServerConfig;
 use crate::application::server::connection::WriteConnection;
@@ -43,7 +43,7 @@ impl ServerMonoThreadedHandle {
         cpu: usize,
         storage: &Storage,
     ) -> Self {
-        let (slot, storage_segment) = storage.part(cpu as u16);
+        let (_slot, storage_segment) = storage.part(cpu as u16);
         let dialer = dialer.part(cpu as u16).unwrap();
 
         Self {
@@ -55,7 +55,9 @@ impl ServerMonoThreadedHandle {
     }
 
     pub fn initialize(self) -> JoinHandle<()> {
-        let handle = std::thread::spawn(move || {
+        
+
+        std::thread::spawn(move || {
             monoio::utils::bind_to_cpu_set(Some(self.cpu)).unwrap();
 
             let mut rt = monoio::RuntimeBuilder::<Driver>::new()
@@ -111,8 +113,6 @@ impl ServerMonoThreadedHandle {
                 #[allow(unreachable_code)]
                 Ok::<(), anyhow::Error>(())
             });
-        });
-
-        handle
+        })
     }
 }

app/roster/src/domain/dialer/mod.rs

@@ -1,6 +1,6 @@
 use std::ops::{Deref, Range};
-use std::rc::Rc;
-use std::sync::Arc;
+
+
 
 use sharded_thread::mesh::MeshBuilder;
 use sharded_thread::shard::Shard;

app/roster/src/domain/storage/mod.rs

@@ -1,8 +1,8 @@
 //! Storage primitive which is used to interact with Keys
 
 use std::hash::BuildHasherDefault;
-use std::ops::Range;
-use std::rc::Rc;
+
+
 use std::sync::atomic::AtomicU32;
 use std::sync::Arc;
 
@@ -68,7 +68,7 @@ impl StorageSegment {
             val,
         };
 
-        let old = self
+        let _old = self
             .count
             .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
         /*
@@ -141,14 +141,14 @@ impl Storage {
         // We generate the Slot where we need to create a StorageSegment.
         let mut slots: Vec<(Slot, StorageSegment)> = Vec::new();
         for slot in 0..nb_slot {
-            let part_size: u16 = HASH_SLOT_MAX / nb_slot as u16;
-            let remainder: u16 = HASH_SLOT_MAX % nb_slot as u16;
+            let part_size: u16 = HASH_SLOT_MAX / nb_slot;
+            let remainder: u16 = HASH_SLOT_MAX % nb_slot;
 
-            let start = slot as u16 * part_size as u16;
+            let start = slot * part_size;
             let end = if slot == nb_slot - 1 {
-                (slot as u16 + 1) * part_size + remainder as u16
+                (slot + 1) * part_size + remainder
             } else {
-                (slot as u16 + 1) * part_size as u16
+                (slot + 1) * part_size
             };
 
             let slot = Slot::from(start..end);

app/roster/tests/utils/mod.rs

@@ -1,5 +1,5 @@
 use std::net::SocketAddr;
-use std::str::FromStr;
+
 
 mod port_picker;