Make all diskio functions and structs crate-private

Make some fields private

Author: 0xPoe

src/diskio/immediate.rs

@@ -14,7 +14,7 @@ use std::{
 use super::{CompletedIo, Executor, Item};
 
 #[derive(Debug)]
-pub struct _IncrementalFileState {
+pub(crate) struct _IncrementalFileState {
     completed_chunks: Vec<usize>,
     err: Option<io::Result<()>>,
     item: Option<Item>,
@@ -24,12 +24,12 @@ pub struct _IncrementalFileState {
 pub(super) type IncrementalFileState = Arc<Mutex<Option<_IncrementalFileState>>>;
 
 #[derive(Default, Debug)]
-pub struct ImmediateUnpacker {
+pub(crate) struct ImmediateUnpacker {
     incremental_state: IncrementalFileState,
 }
 
 impl ImmediateUnpacker {
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self {
             ..Default::default()
         }
@@ -136,7 +136,7 @@ pub(super) struct IncrementalFileWriter {
 
 impl IncrementalFileWriter {
     #[allow(unused_variables)]
-    pub fn new<P: AsRef<Path>>(
+    pub(crate) fn new<P: AsRef<Path>>(
         path: P,
         mode: u32,
         state: IncrementalFileState,
@@ -160,7 +160,7 @@ impl IncrementalFileWriter {
         })
     }
 
-    pub fn chunk_submit(&mut self, chunk: Vec<u8>) -> bool {
+    pub(crate) fn chunk_submit(&mut self, chunk: Vec<u8>) -> bool {
         if (self.state.lock().unwrap()).is_none() {
             return false;
         }

src/diskio/mod.rs

@@ -51,10 +51,10 @@
 //    loss or errors in this model.
 // f) data gathering: record (name, bytes, start, duration)
 //    write to disk afterwards as a csv file?
-pub mod immediate;
+pub(crate) mod immediate;
 #[cfg(test)]
 mod test;
-pub mod threaded;
+pub(crate) mod threaded;
 
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
@@ -69,7 +69,7 @@ use crate::utils::notifications::Notification;
 
 /// Carries the implementation specific channel data into the executor.
 #[derive(Debug)]
-pub enum IncrementalFile {
+pub(crate) enum IncrementalFile {
     ImmediateReceiver,
     ThreadedReceiver(Receiver<Vec<u8>>),
 }
@@ -114,41 +114,41 @@ pub enum IncrementalFile {
 
 /// What kind of IO operation to perform
 #[derive(Debug)]
-pub enum Kind {
+pub(crate) enum Kind {
     Directory,
     File(Vec<u8>),
     IncrementalFile(IncrementalFile),
 }
 
 /// The details of the IO operation
 #[derive(Debug)]
-pub struct Item {
+pub(crate) struct Item {
     /// The path to operate on
-    pub full_path: PathBuf,
+    pub(crate) full_path: PathBuf,
     /// The operation to perform
-    pub kind: Kind,
+    pub(crate) kind: Kind,
     /// When the operation started
-    pub start: Option<Instant>,
+    start: Option<Instant>,
     /// Amount of time the operation took to finish
-    pub finish: Option<Duration>,
+    finish: Option<Duration>,
     /// The length of the file, for files (for stats)
-    pub size: Option<usize>,
+    size: Option<usize>,
     /// The result of the operation (could now be factored into CompletedIO...)
-    pub result: io::Result<()>,
+    pub(crate) result: io::Result<()>,
     /// The mode to apply
-    pub mode: u32,
+    mode: u32,
 }
 
 #[derive(Debug)]
-pub enum CompletedIo {
+pub(crate) enum CompletedIo {
     /// A submitted Item has completed
     Item(Item),
     /// An IncrementalFile has completed a single chunk
     Chunk(usize),
 }
 
 impl Item {
-    pub fn make_dir(full_path: PathBuf, mode: u32) -> Self {
+    pub(crate) fn make_dir(full_path: PathBuf, mode: u32) -> Self {
         Self {
             full_path,
             kind: Kind::Directory,
@@ -160,7 +160,7 @@ impl Item {
         }
     }
 
-    pub fn write_file(full_path: PathBuf, content: Vec<u8>, mode: u32) -> Self {
+    pub(crate) fn write_file(full_path: PathBuf, content: Vec<u8>, mode: u32) -> Self {
         let len = content.len();
         Self {
             full_path,
@@ -173,7 +173,7 @@ impl Item {
         }
     }
 
-    pub fn write_file_segmented<'a>(
+    pub(crate) fn write_file_segmented<'a>(
         full_path: PathBuf,
         mode: u32,
         state: IncrementalFileState,
@@ -199,7 +199,7 @@ impl Item {
 /// just allows the immediate codepath to get access to the Arc referenced state
 /// without holding a lifetime reference to the executor, as the threaded code
 /// path is all message passing.
-pub enum IncrementalFileState {
+pub(crate) enum IncrementalFileState {
     Threaded,
     Immediate(immediate::IncrementalFileState),
 }
@@ -232,7 +232,7 @@ impl IncrementalFileState {
 /// Trait object for performing IO. At this point the overhead
 /// of trait invocation is not a bottleneck, but if it becomes
 /// one we could consider an enum variant based approach instead.
-pub trait Executor {
+pub(crate) trait Executor {
     /// Perform a single operation.
     /// During overload situations previously queued items may
     /// need to be completed before the item is accepted:
@@ -262,7 +262,7 @@ pub trait Executor {
 
 /// Trivial single threaded IO to be used from executors.
 /// (Crazy sophisticated ones can obviously ignore this)
-pub fn perform<F: Fn(usize)>(item: &mut Item, chunk_complete_callback: F) {
+pub(crate) fn perform<F: Fn(usize)>(item: &mut Item, chunk_complete_callback: F) {
     // directories: make them, TODO: register with the dir existence cache.
     // Files, write them.
     item.result = match &mut item.kind {
@@ -281,7 +281,7 @@ pub fn perform<F: Fn(usize)>(item: &mut Item, chunk_complete_callback: F) {
 }
 
 #[allow(unused_variables)]
-pub fn write_file<P: AsRef<Path>, C: AsRef<[u8]>>(
+pub(crate) fn write_file<P: AsRef<Path>, C: AsRef<[u8]>>(
     path: P,
     contents: C,
     mode: u32,
@@ -312,7 +312,7 @@ pub fn write_file<P: AsRef<Path>, C: AsRef<[u8]>>(
 }
 
 #[allow(unused_variables)]
-pub fn write_file_incremental<P: AsRef<Path>, F: Fn(usize)>(
+pub(crate) fn write_file_incremental<P: AsRef<Path>, F: Fn(usize)>(
     path: P,
     content_callback: &mut IncrementalFile,
     mode: u32,
@@ -357,15 +357,15 @@ pub fn write_file_incremental<P: AsRef<Path>, F: Fn(usize)>(
     Ok(())
 }
 
-pub fn create_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
+pub(crate) fn create_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
     let path = path.as_ref();
     let path_display = format!("{}", path.display());
     trace_scoped!("create_dir", "name": path_display);
     std::fs::create_dir(path)
 }
 
 /// Get the executor for disk IO.
-pub fn get_executor<'a>(
+pub(crate) fn get_executor<'a>(
     notify_handler: Option<&'a dyn Fn(Notification<'_>)>,
 ) -> Result<Box<dyn Executor + 'a>> {
     // If this gets lots of use, consider exposing via the config file.

src/diskio/threaded.rs

@@ -25,7 +25,7 @@ impl Default for Task {
     }
 }
 
-pub struct Threaded<'a> {
+pub(crate) struct Threaded<'a> {
     n_files: Arc<AtomicUsize>,
     pool: threadpool::ThreadPool,
     notify_handler: Option<&'a dyn Fn(Notification<'_>)>,
@@ -34,7 +34,10 @@ pub struct Threaded<'a> {
 }
 
 impl<'a> Threaded<'a> {
-    pub fn new(notify_handler: Option<&'a dyn Fn(Notification<'_>)>, thread_count: usize) -> Self {
+    pub(crate) fn new(
+        notify_handler: Option<&'a dyn Fn(Notification<'_>)>,
+        thread_count: usize,
+    ) -> Self {
         // Defaults to hardware thread count threads; this is suitable for
         // our needs as IO bound operations tend to show up as write latencies
         // rather than close latencies, so we don't need to look at