feat(ci): clippy and tests

fix(ci): Rust 1.70.0 compatibility

Author: cxw620

.github/workflows/rust.yml

@@ -10,6 +10,9 @@ env:
   CARGO_TERM_COLOR: always
 
 jobs:
+  pre_ci:
+    uses: dtolnay/.github/.github/workflows/pre_ci.yml@master
+
   build:
     name: Build - ${{ matrix.platform.target }}
     runs-on: ubuntu-24.04
@@ -42,7 +45,7 @@ jobs:
           args: "--release --verbose --features feat-rate-limit"
 
   test:
-    name: Test
+    name: Test 1.70.0
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout
@@ -52,3 +55,27 @@ jobs:
           toolchain: 1.70.0
       - name: Run tests
         run: cargo test --release --verbose --features feat-rate-limit
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@clippy
+      - run: cargo clippy --tests --benches -- -Dclippy::all -Dclippy::pedantic
+
+  doc:
+    name: Documentation
+    needs: pre_ci
+    if: needs.pre_ci.outputs.continue
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    env:
+      RUSTDOCFLAGS: -Dwarnings
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: dtolnay/install@cargo-docs-rs
+      - run: cargo docs-rs

Cargo.toml

@@ -14,19 +14,24 @@ repository = "https://github.com/hanyu-dev/tokio-splice2"
 
 [package.metadata.docs.rs]
 features = ["feat-rate-limit"]
-targets = ["x86_64-unknown-linux-gnu", "i686-unknown-linux-gnu", "aarch64-unknown-linux-gnu"]
+targets = ["x86_64-unknown-linux-gnu"]
+rustdoc-args = [
+    "--generate-link-to-definition",
+    "--extern-html-root-url=core=https://doc.rust-lang.org",
+    "--extern-html-root-url=alloc=https://doc.rust-lang.org",
+    "--extern-html-root-url=std=https://doc.rust-lang.org",
+]
 
 [dependencies]
 crossbeam-utils = "0.8.21"
 pin-project = "1.1.10"
 rustix = { version = "1.0.0", features = ["pipe"] }
-tokio = { version = "1.46.0", features = ["fs", "net"] }
+tokio = { version = "1.47.1", features = ["fs", "net"] }
 tracing = { version = "0.1.41", optional = true }
 
 [dev-dependencies]
-human-format-next = "0.2.2"
-rand = "0.9.1"
-tokio = { version = "1.46.0", features = ["net", "macros", "rt", "rt-multi-thread", "signal", "io-util", "time"] }
+rand = "0.9.2"
+tokio = { version = "1.47.1", features = ["net", "macros", "rt", "rt-multi-thread", "signal", "io-util", "time"] }
 tracing-appender = { version = "0.2.3", features = ["parking_lot"] }
 tracing-subscriber = { version = "0.3.19", features = ["env-filter", "parking_lot"] }
 

examples/proxy.rs

@@ -1,11 +1,8 @@
 //! Example: simple L4 proxy
 
-use std::num::NonZeroU64;
 use std::{env, io};
 
 use tokio::net::{TcpListener, TcpStream};
-#[cfg(feature = "feat-rate-limit")]
-use tokio_splice2::rate::RateLimit;
 
 // #[tokio::main(flavor = "current_thread")]
 #[tokio::main]
@@ -91,19 +88,14 @@ async fn forwarding(mut stream1: TcpStream) -> io::Result<()> {
     // let result = tokio_splice::zero_copy_bidirectional(&mut stream1, &mut
     // stream2).await;
 
-    let limit = env::var("LIMIT")
-        .ok()
-        .and_then(|r| r.parse().ok())
-        .unwrap_or(1u64 * 1000 * 1000);
+    // let limit = env::var("LIMIT")
+    //     .ok()
+    //     .and_then(|r| r.parse().ok())
+    //     .unwrap_or(1u64 * 1000 * 1000);
 
-    println!(
-        "Rate limit is set to {}/s",
-        human_format_next::Formatter::SI
-            .with_custom_unit("B")
-            .format(limit),
-    );
+    // println!("Rate limit is set to {limit} B/s");
 
-    let limit = RateLimit::new(NonZeroU64::new(limit).unwrap());
+    // let limit = RateLimit::new(NonZeroU64::new(limit).unwrap());
 
     // let rate_limiter_clone = rate_limiter.clone();
     // tokio::spawn(async move {
@@ -141,12 +133,8 @@ async fn forwarding(mut stream1: TcpStream) -> io::Result<()> {
     //     }
     // });
 
-    let io_sl2sr = tokio_splice2::context::SpliceIoCtx::prepare()?
-        .into_io()
-        .with_rate_limit(limit.clone());
-    let io_sr2sl = tokio_splice2::context::SpliceIoCtx::prepare()?
-        .into_io()
-        .with_rate_limit(limit);
+    let io_sl2sr = tokio_splice2::context::SpliceIoCtx::prepare()?.into_io();
+    let io_sr2sl = tokio_splice2::context::SpliceIoCtx::prepare()?.into_io();
 
     let traffic = tokio_splice2::io::SpliceBidiIo { io_sl2sr, io_sr2sl }
         .execute(&mut stream1, &mut stream2)
@@ -157,17 +145,9 @@ async fn forwarding(mut stream1: TcpStream) -> io::Result<()> {
     // let total = traffic.0 + traffic.1;
     let cost = instant.elapsed();
     println!(
-        "Forwarded traffic: total: {}, time: {:.2}s, avg: {:.4} -> {}, error: {:?}",
-        human_format_next::Formatter::SI
-            .with_custom_unit("B")
-            .with_decimals::<4>()
-            .format(total as f64),
+        "Forwarded traffic: total: {total} B, time: {:.2} s, avg: {:.4} B/s, error: {:?}",
         cost.as_secs_f64(),
         total as f64 / cost.as_secs_f64(),
-        human_format_next::Formatter::SI
-            .with_custom_unit("B/s")
-            .with_decimals::<4>()
-            .format((total as f64 / cost.as_secs_f64()) as u64),
         traffic.error
     );
 

src/context.rs

@@ -81,6 +81,7 @@ impl<R, W> SpliceIoCtx<R, W> {
         Self::_prepare()
     }
 
+    #[must_use]
     #[inline]
     /// Set the target length of bytes to be copy from `R` to `W`.
     ///
@@ -173,25 +174,36 @@ impl<R, W> SpliceIoCtx<R, W> {
     /// Set the pipe size.
     ///
     /// See [`Pipe`]'s top level docs for more details.
+    ///
+    /// ## Errors
+    ///
+    /// * Set pipe size failed.
+    ///
+    /// For more details, see [`fcntl(2)`].
+    ///
+    /// [`fcntl(2)`]: https://man7.org/linux/man-pages/man2/fcntl.2.html.
     pub fn set_pipe_size(mut self, pipe_size: usize) -> io::Result<Self> {
         self.pipe.set_pipe_size(pipe_size)?;
         Ok(self)
     }
 }
 
 impl<R, W> SpliceIoCtx<R, W> {
+    #[must_use]
     #[inline]
     /// Returns bytes that have been read from `R`.
     pub const fn has_read(&self) -> usize {
         self.has_read
     }
 
+    #[must_use]
     #[inline]
     /// Returns bytes that have been written to `W`.
     pub const fn has_written(&self) -> usize {
         self.has_written
     }
 
+    #[must_use]
     #[inline]
     /// Returns the pipe size.
     pub const fn pipe_size(&self) -> NonZeroUsize {
@@ -216,6 +228,7 @@ impl<R, W> SpliceIoCtx<R, W> {
         self.pipe.splice_drain_finished() && self.pipe.splice_pump_finished()
     }
 
+    #[must_use]
     #[inline]
     /// Returns the traffic result (client TX one).
     pub const fn traffic_client_tx(&self, error: Option<io::Error>) -> TrafficResult {
@@ -226,6 +239,7 @@ impl<R, W> SpliceIoCtx<R, W> {
         }
     }
 
+    #[must_use]
     #[inline]
     /// Returns the traffic result (client RX one).
     pub const fn traffic_client_rx(&self, error: Option<io::Error>) -> TrafficResult {
@@ -236,6 +250,7 @@ impl<R, W> SpliceIoCtx<R, W> {
         }
     }
 
+    #[must_use]
     #[inline]
     /// Builder pattern version of [`SpliceIo::new`].
     pub fn into_io(self) -> SpliceIo<R, W> {

src/io.rs

@@ -58,6 +58,7 @@ impl<R, W, const RATE_LIMITER_IS_ENABLED: bool> ops::Deref
 }
 
 impl<R, W> SpliceIo<R, W, RATE_LIMITER_DISABLED> {
+    #[must_use]
     /// Create a new `SpliceIo` instance with ctx and pinned `R` / `W`.
     pub fn new(ctx: SpliceIoCtx<R, W>) -> Self {
         SpliceIo {

src/lib.rs

@@ -82,6 +82,10 @@ pub use rate::RateLimit;
 ///
 /// See [`SpliceIoCtx::prepare`] and [`SpliceIo::execute`] for more details; see
 /// the [crate-level documentation](crate) for known limitations.
+///
+/// ## Errors
+///
+/// * Create pipe failed.
 pub async fn copy<R, W>(r: &mut R, w: &mut W) -> std::io::Result<traffic::TrafficResult>
 where
     R: io::AsyncReadFd + IsNotFile + Unpin,
@@ -98,6 +102,11 @@ where
 ///
 /// See [`SpliceIoCtx::prepare_reading_file`] for more details; see the
 /// [crate-level documentation](crate) for known limitations.
+///
+/// ## Errors
+///
+/// * Create pipe failed.
+/// * Invalid file length or offset.
 pub async fn sendfile<R, W>(
     r: &mut R,
     w: &mut W,
@@ -126,6 +135,10 @@ where
 ///
 /// See [`SpliceIoCtx::prepare`] and [`SpliceBidiIo::execute`] for more details;
 /// see the [crate-level documentation](crate) for known limitations.
+///
+/// ## Errors
+///
+/// * Create pipe failed.
 pub async fn copy_bidirectional<A, B>(
     sl: &mut A,
     sr: &mut B,

src/pipe.rs

@@ -41,7 +41,7 @@ pub const DEFAULT_PIPE_SIZE: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked
 
 #[derive(Debug)]
 /// Linux Pipe.
-pub(crate) struct Pipe {
+pub struct Pipe {
     /// File descriptor for reading from the pipe
     read_side_fd: Fd,
 
@@ -117,7 +117,7 @@ impl Pipe {
     /// Create a pipe, with flags `O_NONBLOCK` and `O_CLOEXEC`.
     ///
     /// The default pipe size is set to `MAXIMUM_PIPE_SIZE` bytes.
-    pub(crate) fn new() -> io::Result<Self> {
+    pub fn new() -> io::Result<Self> {
         pipe_with(PipeFlags::NONBLOCK | PipeFlags::CLOEXEC)
             .map_err(|e| io::Error::from_raw_os_error(e.raw_os_error()))
             .and_then(|(read_fd, write_fd)| {
@@ -150,7 +150,7 @@ impl Pipe {
     /// For more details, see [`fcntl(2)`].
     ///
     /// [`fcntl(2)`]: https://man7.org/linux/man-pages/man2/fcntl.2.html.
-    pub(crate) fn set_pipe_size(&mut self, pipe_size: usize) -> io::Result<usize> {
+    pub fn set_pipe_size(&mut self, pipe_size: usize) -> io::Result<usize> {
         let Some(write_side_fd) = self.write_side_fd.as_fd() else {
             return Err(io::Error::new(
                 io::ErrorKind::Other,
@@ -173,7 +173,7 @@ impl Pipe {
         matches!(self.write_side_fd, Fd::Reserved(_) | Fd::Closed)
     }
 
-    #[inline(always)]
+    #[inline]
     /// Close the pipe write side file descriptor.
     pub(crate) fn set_splice_drain_finished(&mut self) {
         self.write_side_fd.set_reserved();
@@ -198,7 +198,7 @@ impl Pipe {
 
     #[inline]
     /// Returns the size of the pipe, in bytes.
-    pub(crate) const fn size(&self) -> NonZeroUsize {
+    pub const fn size(&self) -> NonZeroUsize {
         self.size
     }
 }

src/pipe/pipe.rs

@@ -1,6 +1,6 @@
 //! Pipe pool to reuse pipes.
 
-use core::{mem, sync::atomic::AtomicUsize};
+use std::{mem, sync::atomic::AtomicUsize};
 use std::collections::VecDeque;
 use std::io;