fix(sqlite): wait through concurrent gateway writes

Signed-off-by: Drew Newberry <anewberry@nvidia.com>

Author: drew

architecture/gateway.md

@@ -738,6 +738,9 @@ scope semantics.
 For in-memory SQLite, the adapter retains a dedicated keepalive connection for
 the store lifetime. Operational connection replacement therefore preserves the
 shared in-memory schema and objects instead of creating an empty database.
+SQLite connections wait up to 30 seconds for a concurrent writer to release
+the database lock, so short bursts of gateway writes do not surface as
+`SQLITE_BUSY` errors to callers.
 
 Public protobuf APIs represent absolute times with `google.protobuf.Timestamp`
 and elapsed time with `google.protobuf.Duration`. The integer

crates/openshell-server/src/persistence/sqlite.rs

@@ -21,6 +21,7 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::Duration;
 use tokio::sync::Mutex;
 
 static SQLITE_MIGRATOR: sqlx::migrate::Migrator = sqlx::migrate!("./migrations/sqlite");
@@ -83,7 +84,12 @@ impl SqliteStore {
 
         let mut options = SqliteConnectOptions::from_str(url)
             .map_err(|e| map_db_error(&e))?
-            .create_if_missing(true);
+            .create_if_missing(true)
+            // A second gateway request can arrive while a write transaction
+            // is committing. SQLite permits one writer at a time; wait for
+            // the short-lived owner instead of returning SQLITE_BUSY to the
+            // caller after the driver's default five seconds.
+            .busy_timeout(Duration::from_secs(30));
 
         if is_in_memory {
             if options.get_filename().as_os_str().is_empty()

crates/openshell-server/src/persistence/tests.rs

@@ -158,6 +158,43 @@ async fn sqlite_connect_runs_embedded_migrations() {
     assert!(records.is_empty());
 }
 
+#[tokio::test]
+async fn sqlite_write_waits_for_another_writer_to_finish() {
+    use super::WriteCondition;
+    use sqlx::{Connection, SqliteConnection};
+    use std::time::Duration;
+
+    let tmp = tempfile::tempdir().expect("tempdir");
+    let url = format!("sqlite:{}?mode=rwc", tmp.path().join("busy.db").display());
+    let store = Store::connect(&url).await.expect("connect store");
+    let mut locker = SqliteConnection::connect(&url)
+        .await
+        .expect("connect competing writer");
+    sqlx::query("BEGIN IMMEDIATE")
+        .execute(&mut locker)
+        .await
+        .expect("hold write lock");
+
+    let write = store.put_if(
+        "workspace",
+        "concurrent-workspace",
+        "concurrent-workspace",
+        "",
+        b"workspace-payload",
+        None,
+        WriteCondition::MustCreate,
+    );
+    let unlock = async {
+        tokio::time::sleep(Duration::from_secs(6)).await;
+        sqlx::query("COMMIT")
+            .execute(&mut locker)
+            .await
+            .expect("release write lock");
+    };
+    let (result, ()) = tokio::join!(write, unlock);
+    result.expect("waiting writer should succeed after the lock is released");
+}
+
 #[tokio::test]
 async fn sqlite_inference_route_removal_migration_deletes_only_managed_routes() {
     use sqlx::{Connection, SqliteConnection};