Use tokio-uring and kioto-uring-executor from crates.io (#28)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lsm"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Kai Mast <kai@kaimast.com>"]
 edition = "2021"
 repository = "https://github.com/kaimast/lsm-rs"
@@ -23,9 +23,8 @@ cfg-if = "1"
 tracing = { version="0.1", default-features=false, features=["attributes"] }
 csv = "1"
 tokio-condvar = { version="0.3", features=["parking_lot"] }
-#tokio-uring = { version="0.4", optional=true }
-tokio-uring = { git="https://github.com/kaimast/tokio-uring.git", features=["mmap"], optional=true }
-tokio-uring-executor = { git="https://github.com/kaimast/tokio-uring-executor.git", optional=true }
+tokio-uring = { version="0.5", optional=true }
+tokio-uring-executor = { package="kioto-uring-executor", version="0.1", optional=true }
 bloomfilter = { version="1", optional=true }
 
 [dependencies.tokio]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Kai Mast
+Copyright (c) 2024 Kai Mast
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

NEWS

@@ -1,8 +1,9 @@
-UNRELEASED:
+0.4:
     - Move sync API into a separate lsm-sync crate
     - Removed KvTrait. The crate now only accept and returns bytes
     - Get operations now return a reference to the data without copying
     - Leverage zerocopy wherever possible to reduce serialization cost
+    - Update tokio-uring and kioto-uring-executor dependencies
 
 0.3:
     - Write-Ahead logging moved to a dedicated thread (or async task)

README.md

@@ -14,10 +14,6 @@ This implementation does *not* aim to reimplement LevelDB. The major differences
 * *io_uring-support*: For async file system access on Linux. Optional and still considered experimental.
 * *Bloom filters* for faster lookups
 
-## Latest Version
-The version on crates.io is quite outdated as it does not allow to publish crates with git dependencies.
-It is recommended to use the `main` git branch instead.
-
 ## Supported Platfomrs and Architectures
 Currently, the code is only tested with Linux on x86 machines, but it should run on most systems supported by the Rust compiler.
 

src/data_blocks/mod.rs

@@ -204,7 +204,7 @@ mod tests {
     use tempfile::tempdir;
 
     #[cfg(feature = "async-io")]
-    use tokio_uring::test as async_test;
+    use tokio_uring_executor::test as async_test;
 
     #[cfg(not(feature = "async-io"))]
     use tokio::test as async_test;

src/disk.rs

@@ -11,14 +11,36 @@ use std::path::Path;
 
 use cfg_if::cfg_if;
 
+/// Read from the offset to the end of the file
+/// Not supported by tokio-uring yet, so added as a helper function here
+#[cfg(feature = "async-io")]
+async fn read_to_end(file: &fs::File, offset: u64) -> Result<Vec<u8>, std::io::Error> {
+    let mut buffer = vec![0u8; 4096];
+    let mut result = vec![];
+    let mut pos = offset;
+
+    loop {
+        let (res, buf) = file.read_at(buffer, pos).await;
+
+        match res {
+            Ok(0) => return Ok(result),
+            Ok(n) => {
+                buffer = buf;
+                result.extend_from_slice(&buffer[..n]);
+                pos += n as u64;
+            }
+            Err(err) => return Err(err),
+        }
+    }
+}
+
 #[inline(always)]
 #[tracing::instrument]
 pub async fn read_uncompressed(fpath: &Path, offset: u64) -> Result<Vec<u8>, std::io::Error> {
     cfg_if! {
         if #[ cfg(feature="async-io") ] {
             let file = fs::File::open(fpath).await?;
-            let (res, buf) = file.read_at_to_end(offset, vec![]).await;
-            res?;
+            let buf = read_to_end(&file, offset).await?;
         } else {
             let mut file = fs::File::open(fpath)?;
 

src/sorted_table/tests.rs

@@ -5,7 +5,7 @@ use crate::manifest::Manifest;
 use tempfile::tempdir;
 
 #[cfg(feature = "async-io")]
-use tokio_uring::test as async_test;
+use tokio_uring_executor::test as async_test;
 
 #[cfg(not(feature = "async-io"))]
 use tokio::test as async_test;