fix: debug sql lock error

Author: MasterPtato

packages/edge/infra/client/manager/src/ctx.rs

@@ -975,8 +975,7 @@ impl Ctx {
 		// Delete entries that aren't in our valid images table
 		let deleted = sqlx::query(indoc!(
 			"
-			DELETE
-			FROM images_cache
+			DELETE FROM images_cache
 			WHERE image_id NOT IN (
 				SELECT image_id FROM __valid_images
 			)

packages/edge/infra/client/manager/src/image_download_handler.rs

@@ -123,6 +123,8 @@ impl ImageDownloadHandler {
 				let (removed_count, removed_bytes) = if images_dir_size as u64 + image_download_size
 					> ctx.config().images.max_cache_size()
 				{
+					tracing::info!(image_id=?image_config.id, ?images_dir_size, ?image_download_size, max=?ctx.config().images.max_cache_size(), "-------------------------");
+
 					// Fetch as many images as it takes to clear up enough space for this new image.
 					// Ordered by LRU
 					let rows = sqlx::query_as::<_, (Uuid, i64)>(indoc!(
@@ -148,10 +150,14 @@ impl ImageDownloadHandler {
 									a.image_id IS NULL
 								ORDER BY ic.last_used_ts
 							)
-						SELECT image_id, size
-						FROM cumulative_sizes
-						WHERE running_total - size < ?2
-						ORDER BY last_used_ts
+						DELETE FROM images_cache
+						WHERE image_id IN (
+							SELECT image_id
+							FROM cumulative_sizes
+							WHERE running_total - size < ?2
+							ORDER BY last_used_ts
+						)
+						RETURNING image_id, size
 						",
 					))
 					.bind(image_config.id)
@@ -171,24 +177,32 @@ impl ImageDownloadHandler {
 							"no inactive images to delete to make space for new image, downloading anyway",
 						);
 					} else {
-						tracing::debug!(count=?rows_len, "cache full, clearing LRU entries");
+						tracing::debug!(image_id=?image_config.id, count=?rows_len, "cache full, clearing LRU entries");
 					}
 
+					tracing::info!(image_id=?image_config.id, count=?rows_len, "foo -------------------------");
+
 					let mut total_removed_bytes = 0;
 
 					for (image_id, size) in rows {
+						tracing::info!(image_id=?image_config.id, image_id2=?image_id, "bar -------------------------");
+
 						total_removed_bytes += size;
 
 						// NOTE: The sql query does not return the current image id so there is no chance
 						// for a deadlock here
 						// Acquire lock on entry
 						let entry = self.downloads.entry_async(image_id).await;
 
+						tracing::info!(image_id=?image_config.id, image_id2=?image_id, "bar2 -------------------------");
+
 						match fs::remove_dir_all(ctx.image_path(image_id)).await {
 							Err(e) if e.kind() == ErrorKind::NotFound => {}
 							res => res.context("failed to delete image dir")?,
 						}
 
+						tracing::info!(image_id=?image_config.id, image_id2=?image_id, "bar3 -------------------------");
+
 						// Remove entry and release lock
 						if let Entry::Occupied(entry) = entry {
 							let _ = entry.remove();
@@ -200,6 +214,8 @@ impl ImageDownloadHandler {
 					(0, 0)
 				};
 
+				tracing::info!(image_id=?image_config.id, "baz -------------------------");
+
 				metrics::IMAGE_CACHE_COUNT.set(cache_count + 1 - removed_count);
 				metrics::IMAGE_CACHE_SIZE
 					.set(images_dir_size + image_download_size as i64 - removed_bytes);
@@ -215,8 +231,12 @@ impl ImageDownloadHandler {
 				.execute(&mut *tx)
 				.await?;
 
+				tracing::info!(image_id=?image_config.id, "baz2 -------------------------");
+
 				tx.commit().await?;
 
+				tracing::info!(image_id=?image_config.id, "baz3 -------------------------");
+
 				// Release lock on sqlite pool
 				drop(conn);
 
@@ -237,7 +257,7 @@ impl ImageDownloadHandler {
 				metrics::IMAGE_CACHE_SIZE.set(images_dir_size + image_size as i64 - removed_bytes);
 
 				// Update state to signify download completed successfully
-				let foo = sqlx::query(indoc!(
+				sqlx::query(indoc!(
 					"
 					UPDATE images_cache
 					SET

packages/edge/infra/client/manager/src/utils/mod.rs

@@ -15,8 +15,11 @@ use pegboard_config::Config;
 use sql::SqlitePoolExt;
 use sqlx::{
 	migrate::MigrateDatabase,
-	sqlite::{SqliteAutoVacuum, SqliteConnectOptions, SqlitePoolOptions, SqliteSynchronous},
-	Executor, Sqlite, SqlitePool,
+	sqlite::{
+		SqliteAutoVacuum, SqliteConnectOptions, SqliteJournalMode, SqliteLockingMode,
+		SqlitePoolOptions, SqliteSynchronous,
+	},
+	Sqlite, SqlitePool,
 };
 use tokio::{
 	fs,
@@ -111,24 +114,19 @@ pub async fn init_sqlite_db(config: &Config) -> Result<SqlitePool> {
 async fn build_sqlite_pool(db_url: &str) -> Result<SqlitePool> {
 	let opts = db_url
 		.parse::<SqliteConnectOptions>()?
-		// Set synchronous mode to NORMAL for performance and data safety balance
-		.synchronous(SqliteSynchronous::Normal)
 		// Set busy timeout to 5 seconds to avoid "database is locked" errors
 		.busy_timeout(Duration::from_secs(5))
 		// Enable foreign key constraint enforcement
 		.foreign_keys(true)
 		// Enable auto vacuuming and set it to incremental mode for gradual space reclaiming
-		.auto_vacuum(SqliteAutoVacuum::Incremental);
+		.auto_vacuum(SqliteAutoVacuum::Incremental)
+		// Set synchronous mode to NORMAL for performance and data safety balance
+		.synchronous(SqliteSynchronous::Normal)
+		// Increases write performance
+		.journal_mode(SqliteJournalMode::Wal)
+		.locking_mode(SqliteLockingMode::Normal);
 
 	let pool = SqlitePoolOptions::new()
-		.after_connect(|conn, _meta| {
-			Box::pin(async move {
-				// NOTE: sqlx doesn't seem to have a WAL2 option so we set it with a PRAGMA query
-				conn.execute("PRAGMA journal_mode = WAL2").await?;
-
-				Ok(())
-			})
-		})
 		// Open connection immediately on startup
 		.min_connections(1)
 		.connect_with(opts)