Merge pull request #38 from Xuanwo/fix-fmt

chore: Format code to make CI happy

examples/benches/http-server-bench.rs

@@ -1,7 +1,6 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput, BenchmarkId};
-use nuclei::block_on;
 use criterion::async_executor::FuturesExecutor;
-
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use nuclei::block_on;
 
 use nuclei::*;
 use std::net::TcpListener;
@@ -42,7 +41,7 @@ async fn listen(listener: Handle<TcpListener>) -> Result<()> {
                 println!("Connection error: {:#?}", err);
             }
         })
-            .detach();
+        .detach();
     }
 }
 
@@ -89,15 +88,19 @@ pub fn http_server_bench(c: &mut Criterion) {
     let mut group = c.benchmark_group("http_server_bench");
     for i in [1_u64, 10_u64, 25_u64].iter() {
         group.throughput(Throughput::Bytes(DATA.len() as u64 * i));
-        group.bench_function(BenchmarkId::from_parameter(i), |b| b.to_async(FuturesExecutor).iter(|| async {
-            let tasks = (0..*i).map(|e| surf::get(uri).recv_string()).collect::<Vec<_>>();
-            join_all(tasks).await;
-        }));
+        group.bench_function(BenchmarkId::from_parameter(i), |b| {
+            b.to_async(FuturesExecutor).iter(|| async {
+                let tasks = (0..*i)
+                    .map(|e| surf::get(uri).recv_string())
+                    .collect::<Vec<_>>();
+                join_all(tasks).await;
+            })
+        });
     }
     group.finish();
 
     nuclei::block_on(x.cancel());
 }
 
 criterion_group!(benches, http_server_bench);
-criterion_main!(benches);
+criterion_main!(benches);

examples/fwrite-vect.rs

@@ -3,13 +3,10 @@ use std::fs::{File, OpenOptions};
 use std::io;
 use std::path::PathBuf;
 
-
-
-use futures::{AsyncSeekExt, AsyncWriteExt};
 use futures::AsyncReadExt;
+use futures::{AsyncSeekExt, AsyncWriteExt};
 use std::io::{IoSlice, SeekFrom};
 
-
 const IOVEC_WIDTH: usize = 1 << 10;
 
 #[nuclei::main]
@@ -39,7 +36,6 @@ async fn main() -> io::Result<()> {
     assert!(file.seek(SeekFrom::Start(0)).await.is_ok());
     file.read_to_string(&mut bufv).await.unwrap();
 
-
     assert_eq!(bufv.matches('A').count(), IOVEC_WIDTH);
     assert_eq!(bufv.matches('B').count(), IOVEC_WIDTH);
     assert_eq!(bufv.matches('C').count(), IOVEC_WIDTH);

examples/fwrite.rs

@@ -3,7 +3,6 @@ use std::fs::{File, OpenOptions};
 use std::io;
 use std::path::PathBuf;
 
-
 use futures::io::SeekFrom;
 use futures::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
 
@@ -44,7 +43,6 @@ async fn main() -> io::Result<()> {
     assert_eq!(file.read_to_end(&mut buf).await.unwrap(), dark_matter.len());
     assert_eq!(&buf[0..dark_matter.len()], dark_matter.as_bytes());
 
-
     println!("Length of file is {}", buf.len());
 
     Ok(())

examples/h1-server-multishot.rs

@@ -1,12 +1,12 @@
 #[cfg(target_os = "linux")]
 #[nuclei::main]
-async fn main() -> anyhow::Result<()>  {
+async fn main() -> anyhow::Result<()> {
     use nuclei::*;
     use std::net::TcpListener;
 
-    use futures::stream::StreamExt;
     use anyhow::Result;
     use async_dup::Arc;
+    use futures::stream::StreamExt;
 
     use futures::prelude::*;
     use http_types::{Request, Response, StatusCode};
@@ -17,7 +17,6 @@ async fn main() -> anyhow::Result<()>  {
     ////// Reason is: Multishot based IO is only part of io_uring backend.
     /////////////////////////////////////////////////////////////////////////
 
-
     static DATA: &'static str = include_str!("data/quark-gluon-plasma");
 
     /// Serves a request and returns a response.
@@ -46,7 +45,7 @@ async fn main() -> anyhow::Result<()>  {
                     println!("Connection error: {:#?}", err);
                 }
             })
-                .detach();
+            .detach();
         }
 
         Ok(())
@@ -61,4 +60,4 @@ async fn main() -> anyhow::Result<()>  {
 #[cfg(target_os = "macos")]
 fn main() {
     panic!("This example can only be run by IO_URING backend.");
-}
+}

rustfmt.toml

@@ -0,0 +1,2 @@
+edition = "2021"
+reorder_imports = true

src/config.rs

@@ -1,10 +1,9 @@
-
 ///
 /// Nuclei's proactor configuration.
 #[derive(Clone, Debug, Default)]
 pub struct NucleiConfig {
     /// **IO_URING Configuration** allows you to configure [io_uring](https://unixism.net/loti/what_is_io_uring.html) backend.
-    pub iouring: IoUringConfiguration
+    pub iouring: IoUringConfiguration,
 }
 
 /// **IO_URING Configuration**
@@ -56,7 +55,6 @@ pub struct IoUringConfiguration {
     /// If [None] passed unbounded workers will be limited by the process task limit,
     /// as indicated by the rlimit [RLIMIT_NPROC](https://man7.org/linux/man-pages/man2/getrlimit.2.html) limit.
     pub per_numa_unbounded_worker_count: Option<u32>,
-
     // XXX: `redrive_kthread_wake` = bool, syncs queue changes so kernel threads got awakened. increased cpu usage.
 }
 
@@ -69,4 +67,4 @@ impl Default for IoUringConfiguration {
             per_numa_unbounded_worker_count: Some(1 << 9),
         }
     }
-}
+}

src/lib.rs

@@ -32,14 +32,14 @@
 #![allow(dead_code, unused_variables)]
 
 mod async_io;
+/// Nuclei's configuration options reside here.
+pub mod config;
 mod handle;
 mod proactor;
 mod submission_handler;
 mod sys;
 mod utils;
 mod waker;
-/// Nuclei's configuration options reside here.
-pub mod config;
 
 #[cfg(not(any(
     target_os = "linux",     // epoll, iouring
@@ -84,4 +84,4 @@ pub use async_global_executor::*;
 pub use proactor::*;
 
 #[cfg(feature = "attributes")]
-pub use nuclei_attributes::*;
+pub use nuclei_attributes::*;

src/proactor.rs

@@ -1,10 +1,10 @@
+use std::ops::DerefMut;
 use std::task::{Context, Poll};
 use std::time::Duration;
 use std::{future::Future, io};
-use std::ops::DerefMut;
 
-use once_cell::sync::{Lazy, OnceCell};
 use crate::config::NucleiConfig;
+use once_cell::sync::{Lazy, OnceCell};
 
 use super::syscore::*;
 use super::waker::*;
@@ -26,17 +26,25 @@ impl Proactor {
     pub fn get() -> &'static Proactor {
         unsafe {
             &PROACTOR.get_or_init(|| {
-                Proactor(SysProactor::new(NucleiConfig::default()).expect("cannot initialize IO backend"))
+                Proactor(
+                    SysProactor::new(NucleiConfig::default())
+                        .expect("cannot initialize IO backend"),
+                )
             })
         }
     }
 
     /// Builds a proactor instance with given config and returns a reference to it.
     pub fn with_config(config: NucleiConfig) -> &'static Proactor {
         unsafe {
-            let mut proactor = Proactor(SysProactor::new(config.clone()).expect("cannot initialize IO backend"));
-            PROACTOR.set(proactor).map_err(|e| "Proactor instance not being able to set.").unwrap();
-            let proactor = Proactor(SysProactor::new(config).expect("cannot initialize IO backend"));
+            let mut proactor =
+                Proactor(SysProactor::new(config.clone()).expect("cannot initialize IO backend"));
+            PROACTOR
+                .set(proactor)
+                .map_err(|e| "Proactor instance not being able to set.")
+                .unwrap();
+            let proactor =
+                Proactor(SysProactor::new(config).expect("cannot initialize IO backend"));
             &PROACTOR.get_or_init(|| proactor)
         }
     }
@@ -130,7 +138,6 @@ mod proactor_tests {
         let new = Proactor::with_config(config);
         let old = Proactor::get();
 
-
         let nsq = new.0.sq.lock();
         let nlen = nsq.capacity();
         drop(nsq);
@@ -146,4 +153,4 @@ mod proactor_tests {
         assert_eq!(nlen, 16);
         assert_eq!(olen, 16);
     }
-}
+}

src/sys.rs

@@ -6,7 +6,7 @@ pub enum IoBackend {
     /// Linux backend
     Epoll,
     /// Linux backend
-    IoUring
+    IoUring,
 }
 
 #[cfg(unix)]

src/syscore/bsd/kqueue.rs

@@ -1,4 +1,5 @@
 use crate::sys::event::{kevent_ts, kqueue, KEvent};
+use ahash::{HashMap, HashMapExt};
 use futures::channel::oneshot;
 use lever::prelude::*;
 use pin_utils::unsafe_pinned;
@@ -8,7 +9,6 @@ use std::mem::MaybeUninit;
 use std::os::unix::io::{AsRawFd, RawFd};
 use std::pin::Pin;
 use std::task::{Context, Poll};
-use ahash::{HashMap, HashMapExt};
 use std::{os::unix::net::UnixStream, time::Duration};
 
 macro_rules! syscall {
@@ -25,10 +25,10 @@ macro_rules! syscall {
 ///////////////////
 ///////////////////
 
+use crate::config::NucleiConfig;
 use socket2::SockAddr;
 use std::mem;
 use std::os::unix::net::SocketAddr as UnixSocketAddr;
-use crate::config::NucleiConfig;
 
 fn max_len() -> usize {
     // The maximum read limit on most posix-like systems is `SSIZE_MAX`,

src/syscore/bsd/mod.rs

@@ -8,4 +8,4 @@ pub(crate) use kqueue::*;
 
 pub(crate) use processor::*;
 
-pub const BACKEND: crate::sys::IoBackend = crate::sys::IoBackend::Kqueue;
+pub const BACKEND: crate::sys::IoBackend = crate::sys::IoBackend::Kqueue;

src/syscore/linux/epoll/epoll.rs

@@ -1,8 +1,8 @@
 use crate::sys::epoll::*;
+use ahash::{HashMap, HashMapExt};
 use futures::channel::oneshot;
 use lever::prelude::*;
 use pin_utils::unsafe_pinned;
-use ahash::{HashMap, HashMapExt};
 use std::future::Future;
 use std::io::{self, Read, Write};
 use std::mem::MaybeUninit;
@@ -25,10 +25,10 @@ macro_rules! syscall {
 ///////////////////
 ///////////////////
 
+use crate::config::NucleiConfig;
 use socket2::SockAddr;
 use std::mem;
 use std::os::unix::net::SocketAddr as UnixSocketAddr;
-use crate::config::NucleiConfig;
 
 fn max_len() -> usize {
     // The maximum read limit on most posix-like systems is `SSIZE_MAX`,

src/syscore/linux/epoll/mod.rs

@@ -8,4 +8,4 @@ pub(crate) use fs::*;
 
 pub(crate) use processor::*;
 
-pub const BACKEND: crate::sys::IoBackend = crate::sys::IoBackend::Epoll;
+pub const BACKEND: crate::sys::IoBackend = crate::sys::IoBackend::Epoll;

src/syscore/linux/epoll/nethandle.rs

@@ -1,4 +1,3 @@
-
 use std::io;
 use std::marker::Unpin;
 use std::net::{SocketAddr, ToSocketAddrs};

src/syscore/linux/iouring/fs/buffer.rs

@@ -1,12 +1,12 @@
 use futures::ready;
+use rustix_uring::types::Statx;
 use std::alloc::{alloc, dealloc, handle_alloc_error, Layout};
 use std::cmp;
 use std::io;
 use std::mem;
 use std::ptr::NonNull;
 use std::slice;
 use std::task::Poll;
-use rustix_uring::types::Statx;
 
 use super::cancellation::Cancellation;