remove archive index sqlite connection pool for simplicity

Author: syphar

Cargo.lock

@@ -40,7 +40,6 @@ semver = { version = "1.0.4", features = ["serde"] }
 slug = "0.1.1"
 r2d2 = "0.8"
 r2d2_postgres = "0.18"
-r2d2_sqlite = "0.22.0"
 sqlx = { version = "0.7", features = [ "runtime-tokio", "postgres", "chrono" ] }
 url = { version = "2.1.1", features = ["serde"] }
 docsrs-metadata = { path = "crates/metadata" }

Cargo.toml

@@ -15,9 +15,6 @@ pub struct Config {
     pub(crate) max_pool_size: u32,
     pub(crate) min_pool_idle: u32,
 
-    // local pool for sqlite connections
-    pub(crate) max_sqlite_pool_size: u64,
-
     // Storage params
     pub(crate) storage_backend: StorageKind,
 
@@ -143,7 +140,6 @@ impl Config {
 
             database_url: require_env("DOCSRS_DATABASE_URL")?,
             max_pool_size: env("DOCSRS_MAX_POOL_SIZE", 90)?,
-            max_sqlite_pool_size: env("DOCSRS_MAX_SQLITE_POOL_SIZE", 500)?,
             min_pool_idle: env("DOCSRS_MIN_POOL_IDLE", 10)?,
 
             storage_backend: env("DOCSRS_STORAGE_BACKEND", StorageKind::Database)?,

src/config.rs

@@ -1,11 +1,9 @@
 use crate::error::Result;
 use crate::storage::{compression::CompressionAlgorithm, FileRange};
 use anyhow::{bail, Context as _};
-use rusqlite::{Connection, OptionalExtension};
+use rusqlite::{Connection, OpenFlags, OptionalExtension};
 use std::{fs, io, path::Path};
 
-use super::sqlite_pool::SqliteConnectionPool;
-
 #[derive(PartialEq, Eq, Debug)]
 pub(crate) struct FileInfo {
     range: FileRange,
@@ -77,8 +75,8 @@ pub(crate) fn create<R: io::Read + io::Seek, P: AsRef<Path>>(
 fn find_in_sqlite_index(conn: &Connection, search_for: &str) -> Result<Option<FileInfo>> {
     let mut stmt = conn.prepare(
         "
-        SELECT start, end, compression 
-        FROM files 
+        SELECT start, end, compression
+        FROM files
         WHERE path = ?
         ",
     )?;
@@ -104,11 +102,12 @@ fn find_in_sqlite_index(conn: &Connection, search_for: &str) -> Result<Option<Fi
 pub(crate) fn find_in_file<P: AsRef<Path>>(
     archive_index_path: P,
     search_for: &str,
-    pool: &SqliteConnectionPool,
 ) -> Result<Option<FileInfo>> {
-    pool.with_connection(archive_index_path, |connection| {
-        find_in_sqlite_index(connection, search_for)
-    })
+    let connection = Connection::open_with_flags(
+        archive_index_path,
+        OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX,
+    )?;
+    find_in_sqlite_index(&connection, search_for)
 }
 
 #[cfg(test)]
@@ -141,19 +140,13 @@ mod tests {
         let tempfile = tempfile::NamedTempFile::new().unwrap().into_temp_path();
         create(&mut tf, &tempfile).unwrap();
 
-        let fi = find_in_file(&tempfile, "testfile1", &SqliteConnectionPool::default())
-            .unwrap()
-            .unwrap();
+        let fi = find_in_file(&tempfile, "testfile1").unwrap().unwrap();
 
         assert_eq!(fi.range, FileRange::new(39, 459));
         assert_eq!(fi.compression, CompressionAlgorithm::Bzip2);
 
-        assert!(find_in_file(
-            &tempfile,
-            "some_other_file",
-            &SqliteConnectionPool::default(),
-        )
-        .unwrap()
-        .is_none());
+        assert!(find_in_file(&tempfile, "some_other_file",)
+            .unwrap()
+            .is_none());
     }
 }

src/storage/archive_index.rs

@@ -2,12 +2,10 @@ mod archive_index;
 mod compression;
 mod database;
 mod s3;
-mod sqlite_pool;
 
 pub use self::compression::{compress, decompress, CompressionAlgorithm, CompressionAlgorithms};
 use self::database::DatabaseBackend;
 use self::s3::S3Backend;
-use self::sqlite_pool::SqliteConnectionPool;
 use crate::error::Result;
 use crate::web::metrics::RenderingTimesRecorder;
 use crate::{db::Pool, utils::spawn_blocking, Config, InstanceMetrics};
@@ -16,7 +14,6 @@ use chrono::{DateTime, Utc};
 use fn_error_context::context;
 use path_slash::PathExt;
 use std::io::BufReader;
-use std::num::NonZeroU64;
 use std::{
     collections::{HashMap, HashSet},
     ffi::OsStr,
@@ -114,7 +111,6 @@ enum StorageBackend {
 pub struct AsyncStorage {
     backend: StorageBackend,
     config: Arc<Config>,
-    sqlite_pool: Arc<SqliteConnectionPool>,
 }
 
 impl AsyncStorage {
@@ -124,10 +120,6 @@ impl AsyncStorage {
         config: Arc<Config>,
     ) -> Result<Self> {
         Ok(Self {
-            sqlite_pool: Arc::new(SqliteConnectionPool::new(
-                NonZeroU64::new(config.max_sqlite_pool_size)
-                    .ok_or_else(|| anyhow!("invalid sqlite pool size"))?,
-            )),
             config: config.clone(),
             backend: match config.storage_backend {
                 StorageKind::Database => {
@@ -239,10 +231,9 @@ impl AsyncStorage {
     pub(crate) async fn exists_in_archive(&self, archive_path: &str, path: &str) -> Result<bool> {
         match self.get_index_filename(archive_path).await {
             Ok(index_filename) => Ok({
-                let sqlite_pool = self.sqlite_pool.clone();
                 let path = path.to_owned();
                 spawn_blocking(move || {
-                    Ok(archive_index::find_in_file(index_filename, &path, &sqlite_pool)?.is_some())
+                    Ok(archive_index::find_in_file(index_filename, &path)?.is_some())
                 })
                 .await?
             }),
@@ -333,10 +324,8 @@ impl AsyncStorage {
         }
         let index_filename = self.get_index_filename(archive_path).await?;
         let info = {
-            let sqlite_pool = self.sqlite_pool.clone();
             let path = path.to_owned();
-            spawn_blocking(move || archive_index::find_in_file(index_filename, &path, &sqlite_pool))
-                .await
+            spawn_blocking(move || archive_index::find_in_file(index_filename, &path)).await
         }?
         .ok_or(PathNotFoundError)?;