fixes

Author: syphar

src/storage/archive_index.rs

@@ -2,7 +2,7 @@ use crate::error::Result;
 use crate::storage::{FileRange, compression::CompressionAlgorithm};
 use anyhow::{Context as _, bail};
 use itertools::Itertools as _;
-use sqlx::{Acquire as _, QueryBuilder, Sqlite};
+use sqlx::{Acquire as _, QueryBuilder, Row as _, Sqlite};
 use std::{fs, io, path::Path};
 use tracing::instrument;
 
@@ -21,34 +21,40 @@ impl FileInfo {
     }
 }
 
-/// create SQLite pool on freshly created database.
+/// crates a new empty SQLite database, and returns a configured connection
+/// pool to connect to the DB.
+/// Any existing DB at the given path will be deleted first.
 async fn sqlite_create<P: AsRef<Path>>(path: P) -> Result<sqlx::SqlitePool> {
     let path = path.as_ref();
     if path.exists() {
         fs::remove_file(path)?;
     }
 
-    Ok(sqlx::SqlitePool::connect_with(
+    sqlx::SqlitePool::connect_with(
         sqlx::sqlite::SqliteConnectOptions::new()
             .filename(path)
             .read_only(false)
             .pragma("synchronous", "full")
             .create_if_missing(true),
     )
-    .await?)
+    .await
+    .map_err(Into::into)
 }
 
-/// open existing SQLite database.
+/// open existing SQLite database, return a configured connection poll
+/// to connect to the DB.
+/// Will error when the database doesn't exist at that path.
 async fn sqlite_open<P: AsRef<Path>>(path: P) -> Result<sqlx::SqlitePool> {
-    Ok(sqlx::SqlitePool::connect_with(
+    sqlx::SqlitePool::connect_with(
         sqlx::sqlite::SqliteConnectOptions::new()
             .filename(path)
             .read_only(true)
             .pragma("synchronous", "off") // not needed for readonly db
             .serialized(false) // same as OPEN_NOMUTEX
             .create_if_missing(false),
     )
-    .await?)
+    .await
+    .map_err(Into::into)
 }
 
 /// create an archive index based on a zipfile.
@@ -86,17 +92,17 @@ pub(crate) async fn create<R: io::Read + io::Seek, P: AsRef<Path> + std::fmt::De
             let mut insert_stmt =
                 QueryBuilder::<Sqlite>::new("INSERT INTO files (path, start, end, compression) ");
 
-            let zf = archive.by_index(i)?;
+            let entry = archive.by_index(i)?;
 
-            let start = zf.data_start() as i64;
-            let end = (zf.data_start() + zf.compressed_size() - 1) as i64;
-            let compression_raw = match zf.compression() {
+            let start = entry.data_start() as i64;
+            let end = (entry.data_start() + entry.compressed_size() - 1) as i64;
+            let compression_raw = match entry.compression() {
                 zip::CompressionMethod::Bzip2 => compression_bzip,
                 c => bail!("unsupported compression algorithm {} in zip-file", c),
             };
 
             insert_stmt.push_values([()], |mut b, _| {
-                b.push_bind(zf.name())
+                b.push_bind(entry.name())
                     .push_bind(start)
                     .push_bind(end)
                     .push_bind(compression_raw);
@@ -126,8 +132,6 @@ async fn find_in_sqlite_index<'e, E>(executor: E, search_for: &str) -> Result<Op
 where
     E: sqlx::Executor<'e, Database = sqlx::Sqlite>,
 {
-    use sqlx::Row;
-
     let row = sqlx::query(
         "
         SELECT start, end, compression
@@ -163,20 +167,17 @@ pub(crate) async fn find_in_file<P: AsRef<Path> + std::fmt::Debug>(
     archive_index_path: P,
     search_for: &str,
 ) -> Result<Option<FileInfo>> {
-    // Converted to sqlx (async) from rusqlite
     let path = archive_index_path.as_ref();
 
     let pool = sqlite_open(path).await?;
     let mut conn = pool.acquire().await?;
 
-    // Assuming find_in_sqlite_index now accepts &mut sqlx::SqliteConnection and is async
     find_in_sqlite_index(&mut *conn, search_for).await
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use sqlx::Row as _;
     use std::io::Write;
     use zip::write::SimpleFileOptions;
 
@@ -225,12 +226,11 @@ mod tests {
         let pool = sqlite_open(&tempfile).await?;
         let mut conn = pool.acquire().await?;
 
-        let result = sqlx::query("SELECT count(*) FROM files")
-            .fetch_all(&mut *conn)
+        let row = sqlx::query("SELECT count(*) FROM files")
+            .fetch_one(&mut *conn)
             .await?;
 
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].get::<i64, _>(0), 100_000);
+        assert_eq!(row.get::<i64, _>(0), 100_000);
 
         Ok(())
     }

src/storage/compression.rs

@@ -90,6 +90,10 @@ pub fn compress(content: impl Read, algorithm: CompressionAlgorithm) -> Result<V
     }
 }
 
+/// Wrap an AsyncWrite sink for compression using the specified algorithm.
+///
+/// Will return an AsyncWrite you can just write data to, we will compress
+/// the data, and then write the compressed data into the provided output sink.
 pub fn wrap_writer_for_compression<'a>(
     output_sink: impl AsyncWrite + Unpin + Send + 'a,
     algorithm: CompressionAlgorithm,
@@ -110,6 +114,10 @@ pub fn wrap_writer_for_compression<'a>(
     }
 }
 
+/// Wrap an AsyncRead for decompression.
+///
+/// You provide an AsyncRead that gives us the compressed data. With the
+/// wrapper we return you can then read decompressed data from the wrapper.
 pub fn wrap_reader_for_decompression<'a>(
     input: impl AsyncRead + Unpin + Send + 'a,
     algorithm: CompressionAlgorithm,