Add an experimental mixed io mode. (#61)

Author: rklaehn

Cargo.toml

@@ -20,13 +20,15 @@ smallvec = "1"
 bytes = { version = "1" }
 futures-lite = { version = "2.3", optional = true }
 self_cell = { version = "1" }
-iroh-io = { version = "0.6.0", default_features = false, optional = true }
-positioned-io = { version = "0.3.1", default_features = false }
+iroh-io = { version = "0.6.0", default-features = false, optional = true }
+positioned-io = { version = "0.3.1", default-features = false }
 genawaiter = { version = "0.99.1", features = ["futures03"], optional = true }
+tokio = { version = "1", features = ["sync"], default-features = false, optional = true }
 
 [features]
 tokio_fsm = ["dep:futures-lite", "dep:iroh-io"]
 validate = ["dep:genawaiter"]
+experimental-mixed = ["dep:tokio"]
 default = ["tokio_fsm", "validate"]
 
 [dev-dependencies]

cli/main.rs

@@ -1,7 +1,8 @@
+use std::{io::Write, path::PathBuf};
+
 use anyhow::Context;
 use bao_tree::{BaoTree, BlockSize};
 use clap::{Parser, Subcommand};
-use std::{io::Write, path::PathBuf};
 
 #[derive(Parser, Debug, Clone)]
 #[clap(version)]

examples/encode_decode_async.rs

@@ -1,3 +1,5 @@
+use std::io;
+
 use bao_tree::{
     io::{
         fsm::{decode_ranges, encode_ranges_validated, valid_ranges, CreateOutboard},
@@ -8,7 +10,6 @@ use bao_tree::{
 };
 use bytes::BytesMut;
 use futures_lite::StreamExt;
-use std::io;
 
 /// Use a block size of 16 KiB, a good default for most cases
 const BLOCK_SIZE: BlockSize = BlockSize::from_chunk_log(4);

examples/encode_decode_sync.rs

@@ -1,3 +1,5 @@
+use std::io;
+
 use bao_tree::{
     io::{
         outboard::PreOrderOutboard,
@@ -6,7 +8,6 @@ use bao_tree::{
     },
     BlockSize, ByteRanges, ChunkRanges,
 };
-use std::io;
 
 /// Use a block size of 16 KiB, a good default for most cases
 const BLOCK_SIZE: BlockSize = BlockSize::from_chunk_log(4);

src/io/error.rs

@@ -1,9 +1,10 @@
 //! Errors when encoding or decoding
 //!
 //! These erros contain more specific information about e.g. where a hash mismatch occured
-use crate::{ChunkNum, TreeNode};
 use std::{fmt, io};
 
+use crate::{ChunkNum, TreeNode};
+
 /// Error when decoding from a reader, after the size has been read
 #[derive(Debug)]
 pub enum DecodeError {

src/io/fsm.rs

@@ -14,30 +14,25 @@ use std::{
     result,
 };
 
-use crate::{
-    blake3, hash_subtree,
-    iter::ResponseIter,
-    rec::{encode_selected_rec, truncate_ranges, truncate_ranges_owned},
-    ChunkRanges, ChunkRangesRef,
-};
 use blake3::guts::parent_cv;
 use bytes::Bytes;
+pub use iroh_io::{AsyncSliceReader, AsyncSliceWriter};
 use iroh_io::{AsyncStreamReader, AsyncStreamWriter};
 use smallvec::SmallVec;
 
 pub use super::BaoContentItem;
+use super::{combine_hash_pair, DecodeError};
 use crate::{
+    blake3, hash_subtree,
     io::{
         error::EncodeError,
         outboard::{PostOrderOutboard, PreOrderOutboard},
         Leaf, Parent,
     },
-    iter::BaoChunk,
-    BaoTree, BlockSize, TreeNode,
+    iter::{BaoChunk, ResponseIter},
+    rec::{encode_selected_rec, truncate_ranges, truncate_ranges_owned},
+    BaoTree, BlockSize, ChunkRanges, ChunkRangesRef, TreeNode,
 };
-pub use iroh_io::{AsyncSliceReader, AsyncSliceWriter};
-
-use super::{combine_hash_pair, DecodeError};
 
 /// A binary merkle tree for blake3 hashes of a blob.
 ///
@@ -136,7 +131,7 @@ pub trait CreateOutboard {
     fn init_from(&mut self, data: impl AsyncStreamReader) -> impl Future<Output = io::Result<()>>;
 }
 
-impl<'b, O: Outboard> Outboard for &'b mut O {
+impl<O: Outboard> Outboard for &mut O {
     fn root(&self) -> blake3::Hash {
         (**self).root()
     }
@@ -173,7 +168,7 @@ impl<R: AsyncSliceReader> Outboard for PreOrderOutboard<R> {
     }
 }
 
-impl<'b, O: OutboardMut> OutboardMut for &'b mut O {
+impl<O: OutboardMut> OutboardMut for &mut O {
     async fn save(
         &mut self,
         node: TreeNode,
@@ -760,13 +755,12 @@ mod validate {
     use genawaiter::sync::{Co, Gen};
     use iroh_io::AsyncSliceReader;
 
+    use super::Outboard;
     use crate::{
         blake3, hash_subtree, io::LocalBoxFuture, rec::truncate_ranges, split, BaoTree, ChunkNum,
         ChunkRangesRef, TreeNode,
     };
 
-    use super::Outboard;
-
     /// Given a data file and an outboard, compute all valid ranges.
     ///
     /// This is not cheap since it recomputes the hashes for all chunks.
@@ -797,7 +791,7 @@ mod validate {
         co: &'a Co<io::Result<Range<ChunkNum>>>,
     }
 
-    impl<'a, O: Outboard, D: AsyncSliceReader> RecursiveDataValidator<'a, O, D> {
+    impl<O: Outboard, D: AsyncSliceReader> RecursiveDataValidator<'_, O, D> {
         async fn validate(
             outboard: O,
             data: D,
@@ -923,7 +917,7 @@ mod validate {
         co: &'a Co<io::Result<Range<ChunkNum>>>,
     }
 
-    impl<'a, O: Outboard> RecursiveOutboardValidator<'a, O> {
+    impl<O: Outboard> RecursiveOutboardValidator<'_, O> {
         async fn validate(
             outboard: O,
             ranges: &ChunkRangesRef,