+43

Cargo.lock

··· 1298 "clap", 1299 "clap-verbosity-flag", 1300 "constcat", 0 1301 "diesel", 1302 "diesel_migrations", 1303 "dotenvy", ··· 1862 dependencies = [ 1863 "data-encoding", 1864 "syn 2.0.101", 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1865 ] 1866 1867 [[package]]

··· 1298 "clap", 1299 "clap-verbosity-flag", 1300 "constcat", 1301 + "deadpool-diesel", 1302 "diesel", 1303 "diesel_migrations", 1304 "dotenvy", ··· 1863 dependencies = [ 1864 "data-encoding", 1865 "syn 2.0.101", 1866 + ] 1867 + 1868 + [[package]] 1869 + name = "deadpool" 1870 + version = "0.12.2" 1871 + source = "registry+https://github.com/rust-lang/crates.io-index" 1872 + checksum = "5ed5957ff93768adf7a65ab167a17835c3d2c3c50d084fe305174c112f468e2f" 1873 + dependencies = [ 1874 + "deadpool-runtime", 1875 + "num_cpus", 1876 + "serde", 1877 + "tokio", 1878 + ] 1879 + 1880 + [[package]] 1881 + name = "deadpool-diesel" 1882 + version = "0.6.1" 1883 + source = "registry+https://github.com/rust-lang/crates.io-index" 1884 + checksum = "590573e9e29c5190a5ff782136f871e6e652e35d598a349888e028693601adf1" 1885 + dependencies = [ 1886 + "deadpool", 1887 + "deadpool-sync", 1888 + "diesel", 1889 + ] 1890 + 1891 + [[package]] 1892 + name = "deadpool-runtime" 1893 + version = "0.1.4" 1894 + source = "registry+https://github.com/rust-lang/crates.io-index" 1895 + checksum = "092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b" 1896 + dependencies = [ 1897 + "tokio", 1898 + ] 1899 + 1900 + [[package]] 1901 + name = "deadpool-sync" 1902 + version = "0.1.4" 1903 + source = "registry+https://github.com/rust-lang/crates.io-index" 1904 + checksum = "524bc3df0d57e98ecd022e21ba31166c2625e7d3e5bcc4510efaeeab4abcab04" 1905 + dependencies = [ 1906 + "deadpool-runtime", 1907 + "tracing", 1908 ] 1909 1910 [[package]]

+1

Cargo.toml

··· 252 lazy_static = "1.5.0" 253 secp256k1 = "0.28.2" 254 dotenvy = "0.15.7" 0 255 [dependencies.rocket_sync_db_pools] 256 version = "=0.1.0" 257 features = ["diesel_sqlite_pool"]

··· 252 lazy_static = "1.5.0" 253 secp256k1 = "0.28.2" 254 dotenvy = "0.15.7" 255 + deadpool-diesel = { version = "0.6.1", features = ["serde", "sqlite", "tracing"] } 256 [dependencies.rocket_sync_db_pools] 257 version = "=0.1.0" 258 features = ["diesel_sqlite_pool"]

+9 -4

src/account_manager/mod.rs

··· 30 31 #[derive(Clone, Debug)] 32 pub struct AccountManager { 33 - pub db: Arc<DbConn>, 34 } 35 36 - pub type AccountManagerCreator = Box<dyn Fn(Arc<DbConn>) -> AccountManager + Send + Sync>; 0 37 38 impl AccountManager { 39 - pub fn new(db: Arc<DbConn>) -> Self { 40 Self { db } 41 } 42 43 pub fn creator() -> AccountManagerCreator { 44 - Box::new(move |db: Arc<DbConn>| -> AccountManager { AccountManager::new(db) }) 0 0 0 0 45 } 46 47 pub async fn get_account(

··· 30 31 #[derive(Clone, Debug)] 32 pub struct AccountManager { 33 + pub db: deadpool_diesel::Connection<SqliteConnection>, 34 } 35 36 + pub type AccountManagerCreator = 37 + Box<dyn Fn(deadpool_diesel::Connection<SqliteConnection>) -> AccountManager + Send + Sync>; 38 39 impl AccountManager { 40 + pub fn new(db: deadpool_diesel::Connection<SqliteConnection>) -> Self { 41 Self { db } 42 } 43 44 pub fn creator() -> AccountManagerCreator { 45 + Box::new( 46 + move |db: deadpool_diesel::Connection<SqliteConnection>| -> AccountManager { 47 + AccountManager::new(db) 48 + }, 49 + ) 50 } 51 52 pub async fn get_account(

+50 -32

src/actor_store/blob.rs

··· 27 use rsky_repo::error::BlobError; 28 use rsky_repo::types::{PreparedBlobRef, PreparedWrite}; 29 use std::str::FromStr as _; 30 - use std::sync::Arc; 31 32 use super::sql_blob::{BlobStoreSql, ByteStream}; 33 - use crate::db::DbConn; 34 35 pub struct GetBlobOutput { 36 pub size: i32, ··· 45 /// DID of the actor 46 pub did: String, 47 /// Database connection 48 - pub db: Arc<DbConn>, 49 } 50 51 impl BlobReader { 52 /// Create a new blob reader 53 - pub fn new(blobstore: BlobStoreSql, db: Arc<DbConn>) -> Self { 54 BlobReader { 55 did: blobstore.did.clone(), 56 blobstore, ··· 65 let did = self.did.clone(); 66 let found = self 67 .db 68 - .run(move |conn| { 69 BlobSchema::blob 70 .filter(BlobSchema::did.eq(did)) 71 .filter(BlobSchema::cid.eq(cid.to_string())) ··· 74 .first(conn) 75 .optional() 76 }) 77 - .await?; 0 78 79 match found { 80 None => bail!("Blob not found"), ··· 107 let did = self.did.clone(); 108 let res = self 109 .db 110 - .run(move |conn| { 111 let results = RecordBlobSchema::record_blob 112 .filter(RecordBlobSchema::blobCid.eq(cid.to_string())) 113 .filter(RecordBlobSchema::did.eq(did)) ··· 115 .get_results(conn)?; 116 Ok::<_, result::Error>(results.into_iter().map(|row| row.record_uri)) 117 }) 118 - .await? 0 119 .collect::<Vec<String>>(); 120 121 Ok(res) ··· 163 use rsky_pds::schema::pds::blob::dsl as BlobSchema; 164 165 let did = self.did.clone(); 166 - self.db.run(move |conn| { 167 let BlobMetadata { 168 temp_key, 169 size, ··· 207 .execute(conn)?; 208 209 Ok(BlobRef::new(cid, mime_type, size, None)) 210 - }).await 211 } 212 213 /// Process blobs associated with writes ··· 265 let uris_clone = uris.clone(); 266 let deleted_repo_blobs: Vec<models::RecordBlob> = self 267 .db 268 - .run(move |conn| { 269 RecordBlobSchema::record_blob 270 .filter(RecordBlobSchema::recordUri.eq_any(&uris_clone)) 271 .filter(RecordBlobSchema::did.eq(&did)) 272 .load::<models::RecordBlob>(conn) 273 }) 274 - .await?; 0 275 276 if deleted_repo_blobs.is_empty() { 277 return Ok(()); ··· 280 // Now perform the delete 281 let uris_clone = uris.clone(); 282 self.db 283 - .run(move |conn| { 284 delete(RecordBlobSchema::record_blob) 285 .filter(RecordBlobSchema::recordUri.eq_any(uris_clone)) 286 .execute(conn) 287 }) 288 - .await?; 0 289 290 // Extract blob cids from the deleted records 291 let deleted_repo_blob_cids: Vec<String> = deleted_repo_blobs ··· 298 let did_clone = self.did.clone(); 299 let duplicated_cids: Vec<String> = self 300 .db 301 - .run(move |conn| { 302 RecordBlobSchema::record_blob 303 .filter(RecordBlobSchema::blobCid.eq_any(cids_clone)) 304 .filter(RecordBlobSchema::did.eq(did_clone)) 305 .select(RecordBlobSchema::blobCid) 306 .load::<String>(conn) 307 }) 308 - .await?; 0 309 310 // Extract new blob cids from writes (creates and updates) 311 let new_blob_cids: Vec<String> = writes ··· 333 let cids = cids_to_delete.clone(); 334 let did_clone = self.did.clone(); 335 self.db 336 - .run(move |conn| { 337 delete(BlobSchema::blob) 338 .filter(BlobSchema::cid.eq_any(cids)) 339 .filter(BlobSchema::did.eq(did_clone)) 340 .execute(conn) 341 }) 342 - .await?; 0 343 344 // Delete from blob storage 345 // Ideally we'd use a background queue here, but for now: ··· 364 365 let found = self 366 .db 367 - .run(move |conn| { 368 BlobSchema::blob 369 .filter( 370 BlobSchema::cid ··· 375 .first(conn) 376 .optional() 377 }) 378 - .await?; 0 379 380 if let Some(found) = found { 381 verify_blob(&blob, &found).await?; ··· 385 .await?; 386 } 387 self.db 388 - .run(move |conn| { 389 update(BlobSchema::blob) 390 .filter(BlobSchema::tempKey.eq(found.temp_key)) 391 .set(BlobSchema::tempKey.eq::<Option<String>>(None)) 392 .execute(conn) 393 }) 394 - .await?; 0 395 Ok(()) 396 } else { 397 bail!("Could not find blob: {:?}", blob.cid.to_string()) ··· 406 let did = self.did.clone(); 407 408 self.db 409 - .run(move |conn| { 410 insert_into(RecordBlobSchema::record_blob) 411 .values(( 412 RecordBlobSchema::blobCid.eq(cid), ··· 416 .on_conflict_do_nothing() 417 .execute(conn) 418 }) 419 - .await?; 0 420 421 Ok(()) 422 } ··· 427 428 let did = self.did.clone(); 429 self.db 430 - .run(move |conn| { 431 let res = BlobSchema::blob 432 .filter(BlobSchema::did.eq(&did)) 433 .count() ··· 435 Ok(res) 436 }) 437 .await 0 438 } 439 440 /// Count blobs associated with records ··· 443 444 let did = self.did.clone(); 445 self.db 446 - .run(move |conn| { 447 let res: i64 = RecordBlobSchema::record_blob 448 .filter(RecordBlobSchema::did.eq(&did)) 449 .select(count_distinct(RecordBlobSchema::blobCid)) ··· 451 Ok(res) 452 }) 453 .await 0 454 } 455 456 /// List blobs that are referenced but missing ··· 463 464 let did = self.did.clone(); 465 self.db 466 - .run(move |conn| { 467 let ListMissingBlobsOpts { cursor, limit } = opts; 468 469 if limit > 1000 { ··· 513 Ok(result) 514 }) 515 .await 0 516 } 517 518 /// List all blobs with optional filtering ··· 541 if let Some(cursor) = cursor { 542 builder = builder.filter(RecordBlobSchema::blobCid.gt(cursor)); 543 } 544 - self.db.run(move |conn| builder.load(conn)).await? 0 0 0 545 } else { 546 let mut builder = RecordBlobSchema::record_blob 547 .select(RecordBlobSchema::blobCid) ··· 553 if let Some(cursor) = cursor { 554 builder = builder.filter(RecordBlobSchema::blobCid.gt(cursor)); 555 } 556 - self.db.run(move |conn| builder.load(conn)).await? 0 0 0 557 }; 558 559 Ok(res) ··· 564 use rsky_pds::schema::pds::blob::dsl as BlobSchema; 565 566 self.db 567 - .run(move |conn| { 568 let res = BlobSchema::blob 569 .filter(BlobSchema::cid.eq(cid.to_string())) 570 .select(models::Blob::as_select()) ··· 586 } 587 }) 588 .await 0 589 } 590 591 /// Update the takedown status of a blob ··· 604 let did_clone = self.did.clone(); 605 606 self.db 607 - .run(move |conn| { 608 update(BlobSchema::blob) 609 .filter(BlobSchema::cid.eq(blob_cid)) 610 .filter(BlobSchema::did.eq(did_clone)) ··· 612 .execute(conn)?; 613 Ok::<_, result::Error>(blob) 614 }) 615 - .await?; 0 616 617 let res = match takedown.applied { 618 true => self.blobstore.quarantine(blob).await,

··· 27 use rsky_repo::error::BlobError; 28 use rsky_repo::types::{PreparedBlobRef, PreparedWrite}; 29 use std::str::FromStr as _; 0 30 31 use super::sql_blob::{BlobStoreSql, ByteStream}; 0 32 33 pub struct GetBlobOutput { 34 pub size: i32, ··· 43 /// DID of the actor 44 pub did: String, 45 /// Database connection 46 + pub db: deadpool_diesel::Connection<SqliteConnection>, 47 } 48 49 impl BlobReader { 50 /// Create a new blob reader 51 + pub fn new(blobstore: BlobStoreSql, db: deadpool_diesel::Connection<SqliteConnection>) -> Self { 52 BlobReader { 53 did: blobstore.did.clone(), 54 blobstore, ··· 63 let did = self.did.clone(); 64 let found = self 65 .db 66 + .interact(move |conn| { 67 BlobSchema::blob 68 .filter(BlobSchema::did.eq(did)) 69 .filter(BlobSchema::cid.eq(cid.to_string())) ··· 72 .first(conn) 73 .optional() 74 }) 75 + .await 76 + .expect("Failed to get blob metadata")?; 77 78 match found { 79 None => bail!("Blob not found"), ··· 106 let did = self.did.clone(); 107 let res = self 108 .db 109 + .interact(move |conn| { 110 let results = RecordBlobSchema::record_blob 111 .filter(RecordBlobSchema::blobCid.eq(cid.to_string())) 112 .filter(RecordBlobSchema::did.eq(did)) ··· 114 .get_results(conn)?; 115 Ok::<_, result::Error>(results.into_iter().map(|row| row.record_uri)) 116 }) 117 + .await 118 + .expect("Failed to get records for blob")? 119 .collect::<Vec<String>>(); 120 121 Ok(res) ··· 163 use rsky_pds::schema::pds::blob::dsl as BlobSchema; 164 165 let did = self.did.clone(); 166 + self.db.interact(move |conn| { 167 let BlobMetadata { 168 temp_key, 169 size, ··· 207 .execute(conn)?; 208 209 Ok(BlobRef::new(cid, mime_type, size, None)) 210 + }).await.expect("Failed to track untethered blob") 211 } 212 213 /// Process blobs associated with writes ··· 265 let uris_clone = uris.clone(); 266 let deleted_repo_blobs: Vec<models::RecordBlob> = self 267 .db 268 + .interact(move |conn| { 269 RecordBlobSchema::record_blob 270 .filter(RecordBlobSchema::recordUri.eq_any(&uris_clone)) 271 .filter(RecordBlobSchema::did.eq(&did)) 272 .load::<models::RecordBlob>(conn) 273 }) 274 + .await 275 + .expect("Failed to get deleted repo blobs")?; 276 277 if deleted_repo_blobs.is_empty() { 278 return Ok(()); ··· 281 // Now perform the delete 282 let uris_clone = uris.clone(); 283 self.db 284 + .interact(move |conn| { 285 delete(RecordBlobSchema::record_blob) 286 .filter(RecordBlobSchema::recordUri.eq_any(uris_clone)) 287 .execute(conn) 288 }) 289 + .await 290 + .expect("Failed to delete repo blobs")?; 291 292 // Extract blob cids from the deleted records 293 let deleted_repo_blob_cids: Vec<String> = deleted_repo_blobs ··· 300 let did_clone = self.did.clone(); 301 let duplicated_cids: Vec<String> = self 302 .db 303 + .interact(move |conn| { 304 RecordBlobSchema::record_blob 305 .filter(RecordBlobSchema::blobCid.eq_any(cids_clone)) 306 .filter(RecordBlobSchema::did.eq(did_clone)) 307 .select(RecordBlobSchema::blobCid) 308 .load::<String>(conn) 309 }) 310 + .await 311 + .expect("Failed to get duplicated cids")?; 312 313 // Extract new blob cids from writes (creates and updates) 314 let new_blob_cids: Vec<String> = writes ··· 336 let cids = cids_to_delete.clone(); 337 let did_clone = self.did.clone(); 338 self.db 339 + .interact(move |conn| { 340 delete(BlobSchema::blob) 341 .filter(BlobSchema::cid.eq_any(cids)) 342 .filter(BlobSchema::did.eq(did_clone)) 343 .execute(conn) 344 }) 345 + .await 346 + .expect("Failed to delete blobs")?; 347 348 // Delete from blob storage 349 // Ideally we'd use a background queue here, but for now: ··· 368 369 let found = self 370 .db 371 + .interact(move |conn| { 372 BlobSchema::blob 373 .filter( 374 BlobSchema::cid ··· 379 .first(conn) 380 .optional() 381 }) 382 + .await 383 + .expect("Failed to verify blob")?; 384 385 if let Some(found) = found { 386 verify_blob(&blob, &found).await?; ··· 390 .await?; 391 } 392 self.db 393 + .interact(move |conn| { 394 update(BlobSchema::blob) 395 .filter(BlobSchema::tempKey.eq(found.temp_key)) 396 .set(BlobSchema::tempKey.eq::<Option<String>>(None)) 397 .execute(conn) 398 }) 399 + .await 400 + .expect("Failed to update blob")?; 401 Ok(()) 402 } else { 403 bail!("Could not find blob: {:?}", blob.cid.to_string()) ··· 412 let did = self.did.clone(); 413 414 self.db 415 + .interact(move |conn| { 416 insert_into(RecordBlobSchema::record_blob) 417 .values(( 418 RecordBlobSchema::blobCid.eq(cid), ··· 422 .on_conflict_do_nothing() 423 .execute(conn) 424 }) 425 + .await 426 + .expect("Failed to associate blob")?; 427 428 Ok(()) 429 } ··· 434 435 let did = self.did.clone(); 436 self.db 437 + .interact(move |conn| { 438 let res = BlobSchema::blob 439 .filter(BlobSchema::did.eq(&did)) 440 .count() ··· 442 Ok(res) 443 }) 444 .await 445 + .expect("Failed to count blobs") 446 } 447 448 /// Count blobs associated with records ··· 451 452 let did = self.did.clone(); 453 self.db 454 + .interact(move |conn| { 455 let res: i64 = RecordBlobSchema::record_blob 456 .filter(RecordBlobSchema::did.eq(&did)) 457 .select(count_distinct(RecordBlobSchema::blobCid)) ··· 459 Ok(res) 460 }) 461 .await 462 + .expect("Failed to count record blobs") 463 } 464 465 /// List blobs that are referenced but missing ··· 472 473 let did = self.did.clone(); 474 self.db 475 + .interact(move |conn| { 476 let ListMissingBlobsOpts { cursor, limit } = opts; 477 478 if limit > 1000 { ··· 522 Ok(result) 523 }) 524 .await 525 + .expect("Failed to list missing blobs") 526 } 527 528 /// List all blobs with optional filtering ··· 551 if let Some(cursor) = cursor { 552 builder = builder.filter(RecordBlobSchema::blobCid.gt(cursor)); 553 } 554 + self.db 555 + .interact(move |conn| builder.load(conn)) 556 + .await 557 + .expect("Failed to list blobs")? 558 } else { 559 let mut builder = RecordBlobSchema::record_blob 560 .select(RecordBlobSchema::blobCid) ··· 566 if let Some(cursor) = cursor { 567 builder = builder.filter(RecordBlobSchema::blobCid.gt(cursor)); 568 } 569 + self.db 570 + .interact(move |conn| builder.load(conn)) 571 + .await 572 + .expect("Failed to list blobs")? 573 }; 574 575 Ok(res) ··· 580 use rsky_pds::schema::pds::blob::dsl as BlobSchema; 581 582 self.db 583 + .interact(move |conn| { 584 let res = BlobSchema::blob 585 .filter(BlobSchema::cid.eq(cid.to_string())) 586 .select(models::Blob::as_select()) ··· 602 } 603 }) 604 .await 605 + .expect("Failed to get blob takedown status") 606 } 607 608 /// Update the takedown status of a blob ··· 621 let did_clone = self.did.clone(); 622 623 self.db 624 + .interact(move |conn| { 625 update(BlobSchema::blob) 626 .filter(BlobSchema::cid.eq(blob_cid)) 627 .filter(BlobSchema::did.eq(did_clone)) ··· 629 .execute(conn)?; 630 Ok::<_, result::Error>(blob) 631 }) 632 + .await 633 + .expect("Failed to update blob takedown status")?; 634 635 let res = match takedown.applied { 636 true => self.blobstore.quarantine(blob).await,

+7 -6

src/actor_store/mod.rs

··· 32 use std::{env, fmt}; 33 use tokio::sync::RwLock; 34 35 - use crate::db::DbConn; 36 - 37 use blob::BlobReader; 38 use preference::PreferenceReader; 39 use record::RecordReader; ··· 74 // Combination of RepoReader/Transactor, BlobReader/Transactor, SqlRepoReader/Transactor 75 impl ActorStore { 76 /// Concrete reader of an individual repo (hence BlobStoreSql which takes `did` param) 77 - pub fn new(did: String, blobstore: BlobStoreSql, db: DbConn) -> Self { 78 - let db = Arc::new(db); 0 0 0 79 ActorStore { 80 storage: Arc::new(RwLock::new(SqlRepoReader::new( 81 did.clone(), ··· 437 pub async fn destroy(&mut self) -> Result<()> { 438 let did: String = self.did.clone(); 439 let storage_guard = self.storage.read().await; 440 - let db: Arc<DbConn> = storage_guard.db.clone(); 441 use rsky_pds::schema::pds::blob::dsl as BlobSchema; 442 443 let blob_rows: Vec<String> = db ··· 471 } 472 let did: String = self.did.clone(); 473 let storage_guard = self.storage.read().await; 474 - let db: Arc<DbConn> = storage_guard.db.clone(); 475 use rsky_pds::schema::pds::record::dsl as RecordSchema; 476 477 let cid_strs: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect();

··· 32 use std::{env, fmt}; 33 use tokio::sync::RwLock; 34 0 0 35 use blob::BlobReader; 36 use preference::PreferenceReader; 37 use record::RecordReader; ··· 72 // Combination of RepoReader/Transactor, BlobReader/Transactor, SqlRepoReader/Transactor 73 impl ActorStore { 74 /// Concrete reader of an individual repo (hence BlobStoreSql which takes `did` param) 75 + pub fn new( 76 + did: String, 77 + blobstore: BlobStoreSql, 78 + db: deadpool_diesel::Connection<SqliteConnection>, 79 + ) -> Self { 80 ActorStore { 81 storage: Arc::new(RwLock::new(SqlRepoReader::new( 82 did.clone(), ··· 438 pub async fn destroy(&mut self) -> Result<()> { 439 let did: String = self.did.clone(); 440 let storage_guard = self.storage.read().await; 441 + let db: deadpool_diesel::Connection<SqliteConnection> = storage_guard.db.clone(); 442 use rsky_pds::schema::pds::blob::dsl as BlobSchema; 443 444 let blob_rows: Vec<String> = db ··· 472 } 473 let did: String = self.did.clone(); 474 let storage_guard = self.storage.read().await; 475 + let db: deadpool_diesel::Connection<SqliteConnection> = storage_guard.db.clone(); 476 use rsky_pds::schema::pds::record::dsl as RecordSchema; 477 478 let cid_strs: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect();

+6 -8

src/actor_store/preference.rs

··· 4 //! 5 //! Modified for SQLite backend 6 7 - use std::sync::Arc; 8 - 9 use anyhow::{Result, bail}; 10 use diesel::*; 11 use rsky_lexicon::app::bsky::actor::RefPreferences; ··· 13 use rsky_pds::actor_store::preference::util::pref_in_scope; 14 use rsky_pds::auth_verifier::AuthScope; 15 use rsky_pds::models::AccountPref; 16 - 17 - use crate::db::DbConn; 18 19 pub struct PreferenceReader { 20 pub did: String, 21 - pub db: Arc<DbConn>, 22 } 23 24 impl PreferenceReader { 25 - pub fn new(did: String, db: Arc<DbConn>) -> Self { 26 PreferenceReader { did, db } 27 } 28 ··· 35 36 let did = self.did.clone(); 37 self.db 38 - .run(move |conn| { 39 let prefs_res = AccountPrefSchema::account_pref 40 .filter(AccountPrefSchema::did.eq(&did)) 41 .select(AccountPref::as_select()) ··· 62 Ok(account_prefs) 63 }) 64 .await 0 65 } 66 67 #[tracing::instrument(skip_all)] ··· 73 ) -> Result<()> { 74 let did = self.did.clone(); 75 self.db 76 - .run(move |conn| { 77 match values 78 .iter() 79 .all(|value| pref_match_namespace(&namespace, &value.get_type())) ··· 142 } 143 }) 144 .await 0 145 } 146 }

··· 4 //! 5 //! Modified for SQLite backend 6 0 0 7 use anyhow::{Result, bail}; 8 use diesel::*; 9 use rsky_lexicon::app::bsky::actor::RefPreferences; ··· 11 use rsky_pds::actor_store::preference::util::pref_in_scope; 12 use rsky_pds::auth_verifier::AuthScope; 13 use rsky_pds::models::AccountPref; 0 0 14 15 pub struct PreferenceReader { 16 pub did: String, 17 + pub db: deadpool_diesel::Connection<SqliteConnection>, 18 } 19 20 impl PreferenceReader { 21 + pub fn new(did: String, db: deadpool_diesel::Connection<SqliteConnection>) -> Self { 22 PreferenceReader { did, db } 23 } 24 ··· 31 32 let did = self.did.clone(); 33 self.db 34 + .interact(move |conn| { 35 let prefs_res = AccountPrefSchema::account_pref 36 .filter(AccountPrefSchema::did.eq(&did)) 37 .select(AccountPref::as_select()) ··· 58 Ok(account_prefs) 59 }) 60 .await 61 + .expect("Failed to get preferences") 62 } 63 64 #[tracing::instrument(skip_all)] ··· 70 ) -> Result<()> { 71 let did = self.did.clone(); 72 self.db 73 + .interact(move |conn| { 74 match values 75 .iter() 76 .all(|value| pref_match_namespace(&namespace, &value.get_type())) ··· 139 } 140 }) 141 .await 142 + .expect("Failed to put preferences") 143 } 144 }

+37 -24

src/actor_store/record.rs

··· 17 use rsky_syntax::aturi::AtUri; 18 use std::env; 19 use std::str::FromStr; 20 - use std::sync::Arc; 21 - 22 - use crate::db::DbConn; 23 24 /// Combined handler for record operations with both read and write capabilities. 25 pub(crate) struct RecordReader { 26 /// Database connection. 27 - pub db: Arc<DbConn>, 28 /// DID of the actor. 29 pub did: String, 30 } 31 32 impl RecordReader { 33 /// Create a new record handler. 34 - pub(crate) fn new(did: String, db: Arc<DbConn>) -> Self { 35 Self { did, db } 36 } 37 ··· 41 42 let other_did = self.did.clone(); 43 self.db 44 - .run(move |conn| { 45 let res: i64 = record.filter(did.eq(&other_did)).count().get_result(conn)?; 46 Ok(res) 47 }) 48 .await 0 49 } 50 51 /// List all collections in the repository. ··· 54 55 let other_did = self.did.clone(); 56 self.db 57 - .run(move |conn| { 58 let collections = record 59 .filter(did.eq(&other_did)) 60 .select(collection) ··· 65 Ok(collections) 66 }) 67 .await 0 68 } 69 70 /// List records for a specific collection. ··· 116 builder = builder.filter(RecordSchema::rkey.lt(rkey_end)); 117 } 118 } 119 - let res: Vec<(Record, RepoBlock)> = self.db.run(move |conn| builder.load(conn)).await?; 0 0 0 0 120 res.into_iter() 121 .map(|row| { 122 Ok(RecordsForCollection { ··· 156 } 157 let record: Option<(Record, RepoBlock)> = self 158 .db 159 - .run(move |conn| builder.first(conn).optional()) 160 - .await?; 0 161 if let Some(record) = record { 162 Ok(Some(GetRecord { 163 uri: record.0.uri, ··· 197 } 198 let record_uri = self 199 .db 200 - .run(move |conn| builder.first::<String>(conn).optional()) 201 - .await?; 0 202 Ok(!!record_uri.is_some()) 203 } 204 ··· 211 212 let res = self 213 .db 214 - .run(move |conn| { 215 RecordSchema::record 216 .select(RecordSchema::takedownRef) 217 .filter(RecordSchema::uri.eq(uri)) 218 .first::<Option<String>>(conn) 219 .optional() 220 }) 221 - .await?; 0 222 if let Some(res) = res { 223 if let Some(takedown_ref) = res { 224 Ok(Some(StatusAttr { ··· 242 243 let res = self 244 .db 245 - .run(move |conn| { 246 RecordSchema::record 247 .select(RecordSchema::cid) 248 .filter(RecordSchema::uri.eq(uri)) 249 .first::<String>(conn) 250 .optional() 251 }) 252 - .await?; 0 253 if let Some(res) = res { 254 Ok(Some(Cid::from_str(&res)?)) 255 } else { ··· 269 270 let res = self 271 .db 272 - .run(move |conn| { 273 RecordSchema::record 274 .inner_join( 275 BacklinkSchema::backlink.on(BacklinkSchema::uri.eq(RecordSchema::uri)), ··· 280 .filter(RecordSchema::collection.eq(collection)) 281 .load::<Record>(conn) 282 }) 283 - .await?; 0 284 Ok(res) 285 } 286 ··· 365 // Track current version of record 366 let (record, uri) = self 367 .db 368 - .run(move |conn| { 369 insert_into(RecordSchema::record) 370 .values(row) 371 .on_conflict(RecordSchema::uri) ··· 378 .execute(conn)?; 379 Ok::<_, Error>((record, uri)) 380 }) 381 - .await?; 0 382 383 if let Some(record) = record { 384 // Maintain backlinks ··· 402 use rsky_pds::schema::pds::record::dsl as RecordSchema; 403 let uri = uri.to_string(); 404 self.db 405 - .run(move |conn| { 406 delete(RecordSchema::record) 407 .filter(RecordSchema::uri.eq(&uri)) 408 .execute(conn)?; ··· 415 Ok(()) 416 }) 417 .await 0 418 } 419 420 /// Remove backlinks for a URI. ··· 422 use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema; 423 let uri = uri.to_string(); 424 self.db 425 - .run(move |conn| { 426 delete(BacklinkSchema::backlink) 427 .filter(BacklinkSchema::uri.eq(uri)) 428 .execute(conn)?; 429 Ok(()) 430 }) 431 .await 0 432 } 433 434 /// Add backlinks to the database. ··· 438 } else { 439 use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema; 440 self.db 441 - .run(move |conn| { 442 insert_or_ignore_into(BacklinkSchema::backlink) 443 .values(&backlinks) 444 .execute(conn)?; 445 Ok(()) 446 }) 447 .await 0 448 } 449 } 450 ··· 466 let uri_string = uri.to_string(); 467 468 self.db 469 - .run(move |conn| { 470 update(RecordSchema::record) 471 .filter(RecordSchema::uri.eq(uri_string)) 472 .set(RecordSchema::takedownRef.eq(takedown_ref)) ··· 474 Ok(()) 475 }) 476 .await 0 477 } 478 }

··· 17 use rsky_syntax::aturi::AtUri; 18 use std::env; 19 use std::str::FromStr; 0 0 0 20 21 /// Combined handler for record operations with both read and write capabilities. 22 pub(crate) struct RecordReader { 23 /// Database connection. 24 + pub db: deadpool_diesel::Connection<SqliteConnection>, 25 /// DID of the actor. 26 pub did: String, 27 } 28 29 impl RecordReader { 30 /// Create a new record handler. 31 + pub(crate) fn new(did: String, db: deadpool_diesel::Connection<SqliteConnection>) -> Self { 32 Self { did, db } 33 } 34 ··· 38 39 let other_did = self.did.clone(); 40 self.db 41 + .interact(move |conn| { 42 let res: i64 = record.filter(did.eq(&other_did)).count().get_result(conn)?; 43 Ok(res) 44 }) 45 .await 46 + .expect("Failed to count records") 47 } 48 49 /// List all collections in the repository. ··· 52 53 let other_did = self.did.clone(); 54 self.db 55 + .interact(move |conn| { 56 let collections = record 57 .filter(did.eq(&other_did)) 58 .select(collection) ··· 63 Ok(collections) 64 }) 65 .await 66 + .expect("Failed to list collections") 67 } 68 69 /// List records for a specific collection. ··· 115 builder = builder.filter(RecordSchema::rkey.lt(rkey_end)); 116 } 117 } 118 + let res: Vec<(Record, RepoBlock)> = self 119 + .db 120 + .interact(move |conn| builder.load(conn)) 121 + .await 122 + .expect("Failed to load records")?; 123 res.into_iter() 124 .map(|row| { 125 Ok(RecordsForCollection { ··· 159 } 160 let record: Option<(Record, RepoBlock)> = self 161 .db 162 + .interact(move |conn| builder.first(conn).optional()) 163 + .await 164 + .expect("Failed to load record")?; 165 if let Some(record) = record { 166 Ok(Some(GetRecord { 167 uri: record.0.uri, ··· 201 } 202 let record_uri = self 203 .db 204 + .interact(move |conn| builder.first::<String>(conn).optional()) 205 + .await 206 + .expect("Failed to check record")?; 207 Ok(!!record_uri.is_some()) 208 } 209 ··· 216 217 let res = self 218 .db 219 + .interact(move |conn| { 220 RecordSchema::record 221 .select(RecordSchema::takedownRef) 222 .filter(RecordSchema::uri.eq(uri)) 223 .first::<Option<String>>(conn) 224 .optional() 225 }) 226 + .await 227 + .expect("Failed to get takedown status")?; 228 if let Some(res) = res { 229 if let Some(takedown_ref) = res { 230 Ok(Some(StatusAttr { ··· 248 249 let res = self 250 .db 251 + .interact(move |conn| { 252 RecordSchema::record 253 .select(RecordSchema::cid) 254 .filter(RecordSchema::uri.eq(uri)) 255 .first::<String>(conn) 256 .optional() 257 }) 258 + .await 259 + .expect("Failed to get current CID")?; 260 if let Some(res) = res { 261 Ok(Some(Cid::from_str(&res)?)) 262 } else { ··· 276 277 let res = self 278 .db 279 + .interact(move |conn| { 280 RecordSchema::record 281 .inner_join( 282 BacklinkSchema::backlink.on(BacklinkSchema::uri.eq(RecordSchema::uri)), ··· 287 .filter(RecordSchema::collection.eq(collection)) 288 .load::<Record>(conn) 289 }) 290 + .await 291 + .expect("Failed to get backlinks")?; 292 Ok(res) 293 } 294 ··· 373 // Track current version of record 374 let (record, uri) = self 375 .db 376 + .interact(move |conn| { 377 insert_into(RecordSchema::record) 378 .values(row) 379 .on_conflict(RecordSchema::uri) ··· 386 .execute(conn)?; 387 Ok::<_, Error>((record, uri)) 388 }) 389 + .await 390 + .expect("Failed to index record")?; 391 392 if let Some(record) = record { 393 // Maintain backlinks ··· 411 use rsky_pds::schema::pds::record::dsl as RecordSchema; 412 let uri = uri.to_string(); 413 self.db 414 + .interact(move |conn| { 415 delete(RecordSchema::record) 416 .filter(RecordSchema::uri.eq(&uri)) 417 .execute(conn)?; ··· 424 Ok(()) 425 }) 426 .await 427 + .expect("Failed to delete record") 428 } 429 430 /// Remove backlinks for a URI. ··· 432 use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema; 433 let uri = uri.to_string(); 434 self.db 435 + .interact(move |conn| { 436 delete(BacklinkSchema::backlink) 437 .filter(BacklinkSchema::uri.eq(uri)) 438 .execute(conn)?; 439 Ok(()) 440 }) 441 .await 442 + .expect("Failed to remove backlinks") 443 } 444 445 /// Add backlinks to the database. ··· 449 } else { 450 use rsky_pds::schema::pds::backlink::dsl as BacklinkSchema; 451 self.db 452 + .interact(move |conn| { 453 insert_or_ignore_into(BacklinkSchema::backlink) 454 .values(&backlinks) 455 .execute(conn)?; 456 Ok(()) 457 }) 458 .await 459 + .expect("Failed to add backlinks") 460 } 461 } 462 ··· 478 let uri_string = uri.to_string(); 479 480 self.db 481 + .interact(move |conn| { 482 update(RecordSchema::record) 483 .filter(RecordSchema::uri.eq(uri_string)) 484 .set(RecordSchema::takedownRef.eq(takedown_ref)) ··· 486 Ok(()) 487 }) 488 .await 489 + .expect("Failed to update takedown status") 490 } 491 }

+30 -25

src/actor_store/sql_blob.rs

··· 7 use anyhow::{Context, Result}; 8 use cidv10::Cid; 9 use diesel::prelude::*; 10 - use std::sync::Arc; 11 - 12 - use crate::db::DbConn; 13 14 /// ByteStream implementation for blob data 15 pub struct ByteStream { ··· 27 } 28 29 /// SQL-based implementation of blob storage 30 - #[derive(Clone)] 31 pub struct BlobStoreSql { 32 /// Database connection for metadata 33 - pub db: Arc<DbConn>, 34 /// DID of the actor 35 pub did: String, 36 } ··· 61 62 impl BlobStoreSql { 63 /// Create a new SQL-based blob store for the given DID 64 - pub fn new(did: String, db: Arc<DbConn>) -> Self { 65 BlobStoreSql { db, did } 66 } 67 68 - /// Create a factory function for blob stores 69 - pub fn creator(db: Arc<DbConn>) -> Box<dyn Fn(String) -> BlobStoreSql> { 70 - let db_clone = db.clone(); 71 - Box::new(move |did: String| BlobStoreSql::new(did, db_clone.clone())) 72 - } 0 0 73 74 /// Store a blob temporarily - now just stores permanently with a key returned for API compatibility 75 pub async fn put_temp(&self, bytes: Vec<u8>) -> Result<String> { ··· 109 110 // Store directly in the database 111 self.db 112 - .run(move |conn| { 113 let data_clone = bytes.clone(); 114 let entry = BlobEntry { 115 cid: cid_str.clone(), ··· 128 .execute(conn) 129 .context("Failed to insert blob data") 130 }) 131 - .await?; 0 132 133 Ok(()) 134 } ··· 146 147 // Update the quarantine flag in the database 148 self.db 149 - .run(move |conn| { 150 diesel::update(blobs::table) 151 .filter(blobs::cid.eq(&cid_str)) 152 .filter(blobs::did.eq(&did_clone)) ··· 154 .execute(conn) 155 .context("Failed to quarantine blob") 156 }) 157 - .await?; 0 158 159 Ok(()) 160 } ··· 166 167 // Update the quarantine flag in the database 168 self.db 169 - .run(move |conn| { 170 diesel::update(blobs::table) 171 .filter(blobs::cid.eq(&cid_str)) 172 .filter(blobs::did.eq(&did_clone)) ··· 174 .execute(conn) 175 .context("Failed to unquarantine blob") 176 }) 177 - .await?; 0 178 179 Ok(()) 180 } ··· 189 // Get the blob data from the database 190 let blob_data = self 191 .db 192 - .run(move |conn| { 193 blobs 194 .filter(self::blobs::cid.eq(&cid_str)) 195 .filter(did.eq(&did_clone)) ··· 199 .optional() 200 .context("Failed to query blob data") 201 }) 202 - .await?; 0 203 204 if let Some(bytes) = blob_data { 205 Ok(ByteStream::new(bytes)) ··· 227 228 // Delete from database 229 self.db 230 - .run(move |conn| { 231 diesel::delete(blobs) 232 .filter(self::blobs::cid.eq(&blob_cid)) 233 .filter(did.eq(&did_clone)) 234 .execute(conn) 235 .context("Failed to delete blob") 236 }) 237 - .await?; 0 238 239 Ok(()) 240 } ··· 248 249 // Delete all blobs in one operation 250 self.db 251 - .run(move |conn| { 252 diesel::delete(blobs) 253 .filter(self::blobs::cid.eq_any(cid_strings)) 254 .filter(did.eq(&did_clone)) 255 .execute(conn) 256 .context("Failed to delete multiple blobs") 257 }) 258 - .await?; 0 259 260 Ok(()) 261 } ··· 269 270 let exists = self 271 .db 272 - .run(move |conn| { 273 diesel::select(diesel::dsl::exists( 274 blobs 275 .filter(self::blobs::cid.eq(&cid_str)) ··· 278 .get_result::<bool>(conn) 279 .context("Failed to check if blob exists") 280 }) 281 - .await?; 0 282 283 Ok(exists) 284 }

··· 7 use anyhow::{Context, Result}; 8 use cidv10::Cid; 9 use diesel::prelude::*; 0 0 0 10 11 /// ByteStream implementation for blob data 12 pub struct ByteStream { ··· 24 } 25 26 /// SQL-based implementation of blob storage 0 27 pub struct BlobStoreSql { 28 /// Database connection for metadata 29 + pub db: deadpool_diesel::Connection<SqliteConnection>, 30 /// DID of the actor 31 pub did: String, 32 } ··· 57 58 impl BlobStoreSql { 59 /// Create a new SQL-based blob store for the given DID 60 + pub fn new(did: String, db: deadpool_diesel::Connection<SqliteConnection>) -> Self { 61 BlobStoreSql { db, did } 62 } 63 64 + // /// Create a factory function for blob stores 65 + // pub fn creator( 66 + // db: deadpool_diesel::Connection<SqliteConnection>, 67 + // ) -> Box<dyn Fn(String) -> BlobStoreSql> { 68 + // let db_clone = db.clone(); 69 + // Box::new(move |did: String| BlobStoreSql::new(did, db_clone.clone())) 70 + // } 71 72 /// Store a blob temporarily - now just stores permanently with a key returned for API compatibility 73 pub async fn put_temp(&self, bytes: Vec<u8>) -> Result<String> { ··· 107 108 // Store directly in the database 109 self.db 110 + .interact(move |conn| { 111 let data_clone = bytes.clone(); 112 let entry = BlobEntry { 113 cid: cid_str.clone(), ··· 126 .execute(conn) 127 .context("Failed to insert blob data") 128 }) 129 + .await 130 + .expect("Failed to store blob data")?; 131 132 Ok(()) 133 } ··· 145 146 // Update the quarantine flag in the database 147 self.db 148 + .interact(move |conn| { 149 diesel::update(blobs::table) 150 .filter(blobs::cid.eq(&cid_str)) 151 .filter(blobs::did.eq(&did_clone)) ··· 153 .execute(conn) 154 .context("Failed to quarantine blob") 155 }) 156 + .await 157 + .expect("Failed to update quarantine status")?; 158 159 Ok(()) 160 } ··· 166 167 // Update the quarantine flag in the database 168 self.db 169 + .interact(move |conn| { 170 diesel::update(blobs::table) 171 .filter(blobs::cid.eq(&cid_str)) 172 .filter(blobs::did.eq(&did_clone)) ··· 174 .execute(conn) 175 .context("Failed to unquarantine blob") 176 }) 177 + .await 178 + .expect("Failed to update unquarantine status")?; 179 180 Ok(()) 181 } ··· 190 // Get the blob data from the database 191 let blob_data = self 192 .db 193 + .interact(move |conn| { 194 blobs 195 .filter(self::blobs::cid.eq(&cid_str)) 196 .filter(did.eq(&did_clone)) ··· 200 .optional() 201 .context("Failed to query blob data") 202 }) 203 + .await 204 + .expect("Failed to get blob data")?; 205 206 if let Some(bytes) = blob_data { 207 Ok(ByteStream::new(bytes)) ··· 229 230 // Delete from database 231 self.db 232 + .interact(move |conn| { 233 diesel::delete(blobs) 234 .filter(self::blobs::cid.eq(&blob_cid)) 235 .filter(did.eq(&did_clone)) 236 .execute(conn) 237 .context("Failed to delete blob") 238 }) 239 + .await 240 + .expect("Failed to delete blob")?; 241 242 Ok(()) 243 } ··· 251 252 // Delete all blobs in one operation 253 self.db 254 + .interact(move |conn| { 255 diesel::delete(blobs) 256 .filter(self::blobs::cid.eq_any(cid_strings)) 257 .filter(did.eq(&did_clone)) 258 .execute(conn) 259 .context("Failed to delete multiple blobs") 260 }) 261 + .await 262 + .expect("Failed to delete multiple blobs")?; 263 264 Ok(()) 265 } ··· 273 274 let exists = self 275 .db 276 + .interact(move |conn| { 277 diesel::select(diesel::dsl::exists( 278 blobs 279 .filter(self::blobs::cid.eq(&cid_str)) ··· 282 .get_result::<bool>(conn) 283 .context("Failed to check if blob exists") 284 }) 285 + .await 286 + .expect("Failed to check blob existence")?; 287 288 Ok(exists) 289 }

+105 -93

src/actor_store/sql_repo.rs

··· 25 use std::sync::Arc; 26 use tokio::sync::RwLock; 27 28 - use crate::db::DbConn; 29 - 30 - #[derive(Clone, Debug)] 31 pub struct SqlRepoReader { 32 pub cache: Arc<RwLock<BlockMap>>, 33 - pub db: Arc<DbConn>, 34 pub root: Option<Cid>, 35 pub rev: Option<String>, 36 pub now: String, 37 pub did: String, 38 } 39 0 0 0 0 0 0 0 0 0 0 40 impl ReadableBlockstore for SqlRepoReader { 41 fn get_bytes<'life>( 42 &'life self, 43 cid: &'life Cid, 44 ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + Sync + 'life>> { 45 let did: String = self.did.clone(); 46 - let db: Arc<DbConn> = self.db.clone(); 47 let cid = cid.clone(); 48 49 Box::pin(async move { ··· 56 return Ok(Some(cached_result.clone())); 57 } 58 59 - let found: Option<Vec<u8>> = db 60 - .run(move |conn| { 0 61 RepoBlockSchema::repo_block 62 .filter(RepoBlockSchema::cid.eq(cid.to_string())) 63 .filter(RepoBlockSchema::did.eq(did)) ··· 65 .first(conn) 66 .optional() 67 }) 68 - .await?; 0 69 match found { 70 None => Ok(None), 71 Some(result) => { ··· 94 cids: Vec<Cid>, 95 ) -> Pin<Box<dyn Future<Output = Result<BlocksAndMissing>> + Send + Sync + 'life>> { 96 let did: String = self.did.clone(); 97 - let db: Arc<DbConn> = self.db.clone(); 98 99 Box::pin(async move { 100 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; ··· 115 116 let _: Vec<_> = stream::iter(missing_strings.chunks(500)) 117 .then(|batch| { 118 - let this_db = db.clone(); 119 let this_did = did.clone(); 120 let blocks = Arc::clone(&blocks); 121 let missing = Arc::clone(&missing_set); ··· 123 124 async move { 125 // Database query 126 - let rows: Vec<(String, Vec<u8>)> = this_db 127 - .run(move |conn| { 0 128 RepoBlockSchema::repo_block 129 .filter(RepoBlockSchema::cid.eq_any(batch)) 130 .filter(RepoBlockSchema::did.eq(this_did)) 131 .select((RepoBlockSchema::cid, RepoBlockSchema::content)) 132 .load(conn) 133 }) 134 - .await?; 0 135 136 // Process rows with locked access 137 let mut blocks = blocks.lock().await; ··· 191 rev: String, 192 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'life>> { 193 let did: String = self.did.clone(); 194 - let db: Arc<DbConn> = self.db.clone(); 195 let bytes_cloned = bytes.clone(); 196 Box::pin(async move { 197 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; 198 199 - db.run(move |conn| { 200 - insert_into(RepoBlockSchema::repo_block) 201 - .values(( 202 - RepoBlockSchema::did.eq(did), 203 - RepoBlockSchema::cid.eq(cid.to_string()), 204 - RepoBlockSchema::repoRev.eq(rev), 205 - RepoBlockSchema::size.eq(bytes.len() as i32), 206 - RepoBlockSchema::content.eq(bytes), 207 - )) 208 - .execute(conn) 209 - }) 210 - .await?; 0 0 211 { 212 let mut cache_guard = self.cache.write().await; 213 cache_guard.set(cid, bytes_cloned); ··· 222 rev: String, 223 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'life>> { 224 let did: String = self.did.clone(); 225 - let db: Arc<DbConn> = self.db.clone(); 226 227 Box::pin(async move { 228 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; ··· 242 let chunks: Vec<Vec<RepoBlock>> = 243 blocks.chunks(50).map(|chunk| chunk.to_vec()).collect(); 244 245 - let _: Vec<_> = stream::iter(chunks) 246 - .then(|batch| { 247 - let db = db.clone(); 248 - async move { 249 - db.run(move |conn| { 250 - insert_or_ignore_into(RepoBlockSchema::repo_block) 251 - .values(batch) 252 - .execute(conn) 253 - .map(|_| ()) 254 - }) 255 - .await 256 - .map_err(anyhow::Error::from) 257 - } 258 - }) 259 - .collect::<Vec<_>>() 260 - .await 261 - .into_iter() 262 - .collect::<Result<Vec<()>>>()?; 263 264 Ok(()) 265 }) ··· 271 is_create: Option<bool>, 272 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'life>> { 273 let did: String = self.did.clone(); 274 - let db: Arc<DbConn> = self.db.clone(); 275 let now: String = self.now.clone(); 276 277 Box::pin(async move { ··· 279 280 let is_create = is_create.unwrap_or(false); 281 if is_create { 282 - db.run(move |conn| { 283 - insert_into(RepoRootSchema::repo_root) 284 - .values(( 285 - RepoRootSchema::did.eq(did), 286 - RepoRootSchema::cid.eq(cid.to_string()), 287 - RepoRootSchema::rev.eq(rev), 288 - RepoRootSchema::indexedAt.eq(now), 289 - )) 290 - .execute(conn) 291 - }) 292 - .await?; 0 0 293 } else { 294 - db.run(move |conn| { 295 - update(RepoRootSchema::repo_root) 296 - .filter(RepoRootSchema::did.eq(did)) 297 - .set(( 298 - RepoRootSchema::cid.eq(cid.to_string()), 299 - RepoRootSchema::rev.eq(rev), 300 - RepoRootSchema::indexedAt.eq(now), 301 - )) 302 - .execute(conn) 303 - }) 304 - .await?; 0 0 305 } 306 Ok(()) 307 }) ··· 324 325 // Basically handles getting ipld blocks from db 326 impl SqlRepoReader { 327 - pub fn new(did: String, now: Option<String>, db: Arc<DbConn>) -> Self { 0 0 0 0 328 let now = now.unwrap_or_else(rsky_common::now); 329 SqlRepoReader { 330 cache: Arc::new(RwLock::new(BlockMap::new())), ··· 371 cursor: &Option<CidAndRev>, 372 ) -> Result<Vec<RepoBlock>> { 373 let did: String = self.did.clone(); 374 - let db: Arc<DbConn> = self.db.clone(); 375 let since = since.clone(); 376 let cursor = cursor.clone(); 377 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; 378 379 - Ok(db 380 - .run(move |conn| { 0 381 let mut builder = RepoBlockSchema::repo_block 382 .select(RepoBlock::as_select()) 383 .order((RepoBlockSchema::repoRev.desc(), RepoBlockSchema::cid.desc())) ··· 404 } 405 builder.load(conn) 406 }) 407 - .await?) 0 408 } 409 410 pub async fn count_blocks(&self) -> Result<i64> { 411 let did: String = self.did.clone(); 412 - let db: Arc<DbConn> = self.db.clone(); 413 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; 414 415 - let res = db 416 - .run(move |conn| { 0 417 RepoBlockSchema::repo_block 418 .filter(RepoBlockSchema::did.eq(did)) 419 .count() 420 .get_result(conn) 421 }) 422 - .await?; 0 423 Ok(res) 424 } 425 ··· 429 /// Proactively cache all blocks from a particular commit (to prevent multiple roundtrips) 430 pub async fn cache_rev(&mut self, rev: String) -> Result<()> { 431 let did: String = self.did.clone(); 432 - let db: Arc<DbConn> = self.db.clone(); 433 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; 434 435 - let result: Vec<(String, Vec<u8>)> = db 436 - .run(move |conn| { 0 437 RepoBlockSchema::repo_block 438 .filter(RepoBlockSchema::did.eq(did)) 439 .filter(RepoBlockSchema::repoRev.eq(rev)) ··· 441 .limit(15) 442 .get_results::<(String, Vec<u8>)>(conn) 443 }) 444 - .await?; 0 445 for row in result { 446 let mut cache_guard = self.cache.write().await; 447 cache_guard.set(Cid::from_str(&row.0)?, row.1) ··· 454 return Ok(()); 455 } 456 let did: String = self.did.clone(); 457 - let db: Arc<DbConn> = self.db.clone(); 458 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; 459 460 let cid_strings: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect(); 461 - db.run(move |conn| { 462 - delete(RepoBlockSchema::repo_block) 463 - .filter(RepoBlockSchema::did.eq(did)) 464 - .filter(RepoBlockSchema::cid.eq_any(cid_strings)) 465 - .execute(conn) 466 - }) 467 - .await?; 0 0 468 Ok(()) 469 } 470 471 pub async fn get_root_detailed(&self) -> Result<CidAndRev> { 472 let did: String = self.did.clone(); 473 - let db: Arc<DbConn> = self.db.clone(); 474 use rsky_pds::schema::pds::repo_root::dsl as RepoRootSchema; 475 476 - let res = db 477 - .run(move |conn| { 0 478 RepoRootSchema::repo_root 479 .filter(RepoRootSchema::did.eq(did)) 480 .select(models::RepoRoot::as_select()) 481 .first(conn) 482 }) 483 - .await?; 0 484 485 Ok(CidAndRev { 486 cid: Cid::from_str(&res.cid)?,

··· 25 use std::sync::Arc; 26 use tokio::sync::RwLock; 27 0 0 0 28 pub struct SqlRepoReader { 29 pub cache: Arc<RwLock<BlockMap>>, 30 + pub db: deadpool_diesel::Connection<SqliteConnection>, 31 pub root: Option<Cid>, 32 pub rev: Option<String>, 33 pub now: String, 34 pub did: String, 35 } 36 37 + impl std::fmt::Debug for SqlRepoReader { 38 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 39 + f.debug_struct("SqlRepoReader") 40 + .field("did", &self.did) 41 + .field("root", &self.root) 42 + .field("rev", &self.rev) 43 + .finish() 44 + } 45 + } 46 + 47 impl ReadableBlockstore for SqlRepoReader { 48 fn get_bytes<'life>( 49 &'life self, 50 cid: &'life Cid, 51 ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + Sync + 'life>> { 52 let did: String = self.did.clone(); 0 53 let cid = cid.clone(); 54 55 Box::pin(async move { ··· 62 return Ok(Some(cached_result.clone())); 63 } 64 65 + let found: Option<Vec<u8>> = self 66 + .db 67 + .interact(move |conn| { 68 RepoBlockSchema::repo_block 69 .filter(RepoBlockSchema::cid.eq(cid.to_string())) 70 .filter(RepoBlockSchema::did.eq(did)) ··· 72 .first(conn) 73 .optional() 74 }) 75 + .await 76 + .expect("Failed to get block")?; 77 match found { 78 None => Ok(None), 79 Some(result) => { ··· 102 cids: Vec<Cid>, 103 ) -> Pin<Box<dyn Future<Output = Result<BlocksAndMissing>> + Send + Sync + 'life>> { 104 let did: String = self.did.clone(); 0 105 106 Box::pin(async move { 107 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; ··· 122 123 let _: Vec<_> = stream::iter(missing_strings.chunks(500)) 124 .then(|batch| { 0 125 let this_did = did.clone(); 126 let blocks = Arc::clone(&blocks); 127 let missing = Arc::clone(&missing_set); ··· 129 130 async move { 131 // Database query 132 + let rows: Vec<(String, Vec<u8>)> = self 133 + .db 134 + .interact(move |conn| { 135 RepoBlockSchema::repo_block 136 .filter(RepoBlockSchema::cid.eq_any(batch)) 137 .filter(RepoBlockSchema::did.eq(this_did)) 138 .select((RepoBlockSchema::cid, RepoBlockSchema::content)) 139 .load(conn) 140 }) 141 + .await 142 + .expect("Failed to get blocks")?; 143 144 // Process rows with locked access 145 let mut blocks = blocks.lock().await; ··· 199 rev: String, 200 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'life>> { 201 let did: String = self.did.clone(); 0 202 let bytes_cloned = bytes.clone(); 203 Box::pin(async move { 204 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; 205 206 + self.db 207 + .interact(move |conn| { 208 + insert_into(RepoBlockSchema::repo_block) 209 + .values(( 210 + RepoBlockSchema::did.eq(did), 211 + RepoBlockSchema::cid.eq(cid.to_string()), 212 + RepoBlockSchema::repoRev.eq(rev), 213 + RepoBlockSchema::size.eq(bytes.len() as i32), 214 + RepoBlockSchema::content.eq(bytes), 215 + )) 216 + .execute(conn) 217 + }) 218 + .await 219 + .expect("Failed to put block")?; 220 { 221 let mut cache_guard = self.cache.write().await; 222 cache_guard.set(cid, bytes_cloned); ··· 231 rev: String, 232 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'life>> { 233 let did: String = self.did.clone(); 0 234 235 Box::pin(async move { 236 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; ··· 250 let chunks: Vec<Vec<RepoBlock>> = 251 blocks.chunks(50).map(|chunk| chunk.to_vec()).collect(); 252 253 + for batch in chunks { 254 + self.db 255 + .interact(move |conn| { 256 + insert_or_ignore_into(RepoBlockSchema::repo_block) 257 + .values(&batch) 258 + .execute(conn) 259 + }) 260 + .await 261 + .expect("Failed to insert blocks")?; 262 + } 0 0 0 0 0 0 0 0 263 264 Ok(()) 265 }) ··· 271 is_create: Option<bool>, 272 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + Sync + 'life>> { 273 let did: String = self.did.clone(); 0 274 let now: String = self.now.clone(); 275 276 Box::pin(async move { ··· 278 279 let is_create = is_create.unwrap_or(false); 280 if is_create { 281 + self.db 282 + .interact(move |conn| { 283 + insert_into(RepoRootSchema::repo_root) 284 + .values(( 285 + RepoRootSchema::did.eq(did), 286 + RepoRootSchema::cid.eq(cid.to_string()), 287 + RepoRootSchema::rev.eq(rev), 288 + RepoRootSchema::indexedAt.eq(now), 289 + )) 290 + .execute(conn) 291 + }) 292 + .await 293 + .expect("Failed to create root")?; 294 } else { 295 + self.db 296 + .interact(move |conn| { 297 + update(RepoRootSchema::repo_root) 298 + .filter(RepoRootSchema::did.eq(did)) 299 + .set(( 300 + RepoRootSchema::cid.eq(cid.to_string()), 301 + RepoRootSchema::rev.eq(rev), 302 + RepoRootSchema::indexedAt.eq(now), 303 + )) 304 + .execute(conn) 305 + }) 306 + .await 307 + .expect("Failed to update root")?; 308 } 309 Ok(()) 310 }) ··· 327 328 // Basically handles getting ipld blocks from db 329 impl SqlRepoReader { 330 + pub fn new( 331 + did: String, 332 + now: Option<String>, 333 + db: deadpool_diesel::Connection<SqliteConnection>, 334 + ) -> Self { 335 let now = now.unwrap_or_else(rsky_common::now); 336 SqlRepoReader { 337 cache: Arc::new(RwLock::new(BlockMap::new())), ··· 378 cursor: &Option<CidAndRev>, 379 ) -> Result<Vec<RepoBlock>> { 380 let did: String = self.did.clone(); 0 381 let since = since.clone(); 382 let cursor = cursor.clone(); 383 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; 384 385 + Ok(self 386 + .db 387 + .interact(move |conn| { 388 let mut builder = RepoBlockSchema::repo_block 389 .select(RepoBlock::as_select()) 390 .order((RepoBlockSchema::repoRev.desc(), RepoBlockSchema::cid.desc())) ··· 411 } 412 builder.load(conn) 413 }) 414 + .await 415 + .expect("Failed to get block range")?) 416 } 417 418 pub async fn count_blocks(&self) -> Result<i64> { 419 let did: String = self.did.clone(); 0 420 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; 421 422 + let res = self 423 + .db 424 + .interact(move |conn| { 425 RepoBlockSchema::repo_block 426 .filter(RepoBlockSchema::did.eq(did)) 427 .count() 428 .get_result(conn) 429 }) 430 + .await 431 + .expect("Failed to count blocks")?; 432 Ok(res) 433 } 434 ··· 438 /// Proactively cache all blocks from a particular commit (to prevent multiple roundtrips) 439 pub async fn cache_rev(&mut self, rev: String) -> Result<()> { 440 let did: String = self.did.clone(); 0 441 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; 442 443 + let result: Vec<(String, Vec<u8>)> = self 444 + .db 445 + .interact(move |conn| { 446 RepoBlockSchema::repo_block 447 .filter(RepoBlockSchema::did.eq(did)) 448 .filter(RepoBlockSchema::repoRev.eq(rev)) ··· 450 .limit(15) 451 .get_results::<(String, Vec<u8>)>(conn) 452 }) 453 + .await 454 + .expect("Failed to cache rev")?; 455 for row in result { 456 let mut cache_guard = self.cache.write().await; 457 cache_guard.set(Cid::from_str(&row.0)?, row.1) ··· 464 return Ok(()); 465 } 466 let did: String = self.did.clone(); 0 467 use rsky_pds::schema::pds::repo_block::dsl as RepoBlockSchema; 468 469 let cid_strings: Vec<String> = cids.into_iter().map(|c| c.to_string()).collect(); 470 + self.db 471 + .interact(move |conn| { 472 + delete(RepoBlockSchema::repo_block) 473 + .filter(RepoBlockSchema::did.eq(did)) 474 + .filter(RepoBlockSchema::cid.eq_any(cid_strings)) 475 + .execute(conn) 476 + }) 477 + .await 478 + .expect("Failed to delete many")?; 479 Ok(()) 480 } 481 482 pub async fn get_root_detailed(&self) -> Result<CidAndRev> { 483 let did: String = self.did.clone(); 0 484 use rsky_pds::schema::pds::repo_root::dsl as RepoRootSchema; 485 486 + let res = self 487 + .db 488 + .interact(move |conn| { 489 RepoRootSchema::repo_root 490 .filter(RepoRootSchema::did.eq(did)) 491 .select(models::RepoRoot::as_select()) 492 .first(conn) 493 }) 494 + .await 495 + .expect("Failed to get root")?; 496 497 Ok(CidAndRev { 498 cid: Cid::from_str(&res.cid)?,

+56 -24

src/auth.rs

··· 5 }; 6 use axum::{extract::FromRequestParts, http::StatusCode}; 7 use base64::Engine as _; 0 8 use sha2::{Digest as _, Sha256}; 9 10 - use crate::{AppState, Error, error::ErrorMessage}; 11 12 /// Request extractor for authenticated users. 13 /// If specified in an API endpoint, this guarantees the API can only be called ··· 129 130 // Extract subject (DID) 131 if let Some(did) = claims.get("sub").and_then(serde_json::Value::as_str) { 132 - let _status = sqlx::query_scalar!(r#"SELECT status FROM accounts WHERE did = ?"#, did) 133 - .fetch_one(&state.db) 0 0 0 0 0 0 0 0 0 134 .await 135 .with_context(|| format!("failed to query account {did}")) 136 .context("should fetch account status")?; ··· 326 327 let timestamp = chrono::Utc::now().timestamp(); 328 0 0 0 329 // Check if JTI has been used before 330 - let jti_used = 331 - sqlx::query_scalar!(r#"SELECT COUNT(*) FROM oauth_used_jtis WHERE jti = ?"#, jti) 332 - .fetch_one(&state.db) 333 - .await 334 - .context("failed to check JTI")?; 0 0 0 0 0 0 335 336 if jti_used > 0 { 337 return Err(Error::with_status( ··· 347 .and_then(serde_json::Value::as_i64) 348 .unwrap_or_else(|| timestamp.checked_add(60).unwrap_or(timestamp)); 349 350 - _ = sqlx::query!( 351 - r#" 352 - INSERT INTO oauth_used_jtis (jti, issuer, created_at, expires_at) 353 - VALUES (?, ?, ?, ?) 354 - "#, 355 - jti, 356 - calculated_thumbprint, // Use thumbprint as issuer identifier 357 - timestamp, 358 - exp 359 - ) 360 - .execute(&state.db) 361 - .await 362 - .context("failed to store JTI")?; 0 0 0 0 363 364 // Extract subject (DID) from access token 365 - if let Some(did) = claims.get("sub").and_then(|v| v.as_str()) { 366 - let _status = sqlx::query_scalar!(r#"SELECT status FROM accounts WHERE did = ?"#, did) 367 - .fetch_one(&state.db) 0 0 0 0 0 0 0 0 0 368 .await 369 .with_context(|| format!("failed to query account {did}")) 370 .context("should fetch account status")?;

··· 5 }; 6 use axum::{extract::FromRequestParts, http::StatusCode}; 7 use base64::Engine as _; 8 + use diesel::prelude::*; 9 use sha2::{Digest as _, Sha256}; 10 11 + use crate::{AppState, Error, db::DbConn, error::ErrorMessage}; 12 13 /// Request extractor for authenticated users. 14 /// If specified in an API endpoint, this guarantees the API can only be called ··· 130 131 // Extract subject (DID) 132 if let Some(did) = claims.get("sub").and_then(serde_json::Value::as_str) { 133 + // Convert SQLx query to Diesel query 134 + use crate::schema::accounts::dsl as AccountSchema; 135 + 136 + let _status = state 137 + .db 138 + .run(move |conn| { 139 + AccountSchema::accounts 140 + .filter(AccountSchema::did.eq(did.to_string())) 141 + .select(AccountSchema::status) 142 + .first::<String>(conn) 143 + }) 144 .await 145 .with_context(|| format!("failed to query account {did}")) 146 .context("should fetch account status")?; ··· 336 337 let timestamp = chrono::Utc::now().timestamp(); 338 339 + // Convert SQLx JTI check to Diesel 340 + use crate::schema::oauth_used_jtis::dsl as JtiSchema; 341 + 342 // Check if JTI has been used before 343 + let jti_string = jti.to_string(); 344 + let jti_used = state 345 + .db 346 + .run(move |conn| { 347 + JtiSchema::oauth_used_jtis 348 + .filter(JtiSchema::jti.eq(jti_string)) 349 + .count() 350 + .get_result::<i64>(conn) 351 + }) 352 + .await 353 + .context("failed to check JTI")?; 354 355 if jti_used > 0 { 356 return Err(Error::with_status( ··· 366 .and_then(serde_json::Value::as_i64) 367 .unwrap_or_else(|| timestamp.checked_add(60).unwrap_or(timestamp)); 368 369 + // Convert SQLx INSERT to Diesel 370 + let jti_str = jti.to_string(); 371 + let thumbprint_str = calculated_thumbprint.to_string(); 372 + state 373 + .db 374 + .run(move |conn| { 375 + diesel::insert_into(JtiSchema::oauth_used_jtis) 376 + .values(( 377 + JtiSchema::jti.eq(jti_str), 378 + JtiSchema::issuer.eq(thumbprint_str), 379 + JtiSchema::created_at.eq(timestamp), 380 + JtiSchema::expires_at.eq(exp), 381 + )) 382 + .execute(conn) 383 + }) 384 + .await 385 + .context("failed to store JTI")?; 386 387 // Extract subject (DID) from access token 388 + if let Some(did) = claims.get("sub").and_then(|v| v.as_str) { 389 + // Convert SQLx query to Diesel 390 + use crate::schema::accounts::dsl as AccountSchema; 391 + 392 + let _status = state 393 + .db 394 + .run(move |conn| { 395 + AccountSchema::accounts 396 + .filter(AccountSchema::did.eq(did.to_string())) 397 + .select(AccountSchema::status) 398 + .first::<String>(conn) 399 + }) 400 .await 401 .with_context(|| format!("failed to query account {did}")) 402 .context("should fetch account status")?;

+12 -23

src/db.rs

··· 1 use anyhow::Result; 2 - use diesel::prelude::*; 3 - use dotenvy::dotenv; 4 - use rocket_sync_db_pools::database; 5 - use std::env; 6 - use std::fmt::{Debug, Formatter}; 7 - 8 - #[database("sqlite_db")] 9 - pub struct DbConn(SqliteConnection); 10 - 11 - impl Debug for DbConn { 12 - fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result { 13 - todo!() 14 - } 15 - } 16 17 #[tracing::instrument(skip_all)] 18 - pub fn establish_connection_for_sequencer() -> Result<SqliteConnection> { 19 - dotenv().ok(); 20 - tracing::debug!("Establishing database connection for Sequencer"); 21 - let database_url = env::var("BLUEPDS_DB").unwrap_or("sqlite://data/sqlite.db".into()); 22 - let db = SqliteConnection::establish(&database_url).map_err(|error| { 23 - let context = format!("Error connecting to {database_url:?}"); 24 - anyhow::Error::new(error).context(context) 25 - })?; 26 - Ok(db) 0 0 27 }

··· 1 use anyhow::Result; 2 + use deadpool_diesel::sqlite::{Manager, Pool, Runtime}; 0 0 0 0 0 0 0 0 0 0 0 0 0 3 4 #[tracing::instrument(skip_all)] 5 + /// Establish a connection to the database 6 + /// Takes a database URL as an argument (like "sqlite://data/sqlite.db") 7 + pub(crate) fn establish_pool(database_url: &str) -> Result<Pool> { 8 + tracing::debug!("Establishing database connection"); 9 + let manager = Manager::new(database_url, Runtime::Tokio1); 10 + let pool = Pool::builder(manager) 11 + .max_size(8) 12 + .build() 13 + .expect("should be able to create connection pool"); 14 + tracing::debug!("Database connection established"); 15 + Ok(pool) 16 }

+11 -4

src/endpoints/repo/apply_writes.rs

··· 1 //! Apply a batch transaction of repository creates, updates, and deletes. Requires auth, implemented by PDS. 2 use crate::{ 3 - AppState, Db, Error, Result, SigningKey, 4 - actor_store::ActorStore, 5 - actor_store::sql_blob::BlobStoreSql, 6 auth::AuthenticatedUser, 7 config::AppConfig, 8 error::ErrorMessage, ··· 66 State(skey): State<SigningKey>, 67 State(config): State<AppConfig>, 68 State(db): State<Db>, 0 69 State(fhp): State<FirehoseProducer>, 70 Json(input): Json<ApplyWritesInput>, 71 ) -> Result<Json<repo::apply_writes::Output>> { ··· 156 None => None, 157 }; 158 159 - let mut actor_store = ActorStore::new(did.clone(), BlobStoreSql::new(did.clone(), db), db); 0 0 0 0 0 0 0 160 161 let commit = actor_store 162 .process_writes(writes.clone(), swap_commit_cid)

··· 1 //! Apply a batch transaction of repository creates, updates, and deletes. Requires auth, implemented by PDS. 2 use crate::{ 3 + ActorPools, AppState, Db, Error, Result, SigningKey, 4 + actor_store::{ActorStore, sql_blob::BlobStoreSql}, 0 5 auth::AuthenticatedUser, 6 config::AppConfig, 7 error::ErrorMessage, ··· 65 State(skey): State<SigningKey>, 66 State(config): State<AppConfig>, 67 State(db): State<Db>, 68 + State(db_actors): State<std::collections::HashMap<String, ActorPools>>, 69 State(fhp): State<FirehoseProducer>, 70 Json(input): Json<ApplyWritesInput>, 71 ) -> Result<Json<repo::apply_writes::Output>> { ··· 156 None => None, 157 }; 158 159 + let actor_db = db_actors 160 + .get(did) 161 + .ok_or_else(|| anyhow!("Actor DB not found"))?; 162 + let mut actor_store = ActorStore::new( 163 + did.clone(), 164 + BlobStoreSql::new(did.clone(), actor_db.blob), 165 + actor_db.repo, 166 + ); 167 168 let commit = actor_store 169 .process_writes(writes.clone(), swap_commit_cid)

+88 -26

src/main.rs

··· 37 use clap::Parser; 38 use clap_verbosity_flag::{InfoLevel, Verbosity, log::LevelFilter}; 39 use config::AppConfig; 0 0 40 use diesel::prelude::*; 41 - use diesel::r2d2::{self, ConnectionManager}; 42 - use diesel_migrations::{EmbeddedMigrations, MigrationHarness, embed_migrations}; 43 #[expect(clippy::pub_use, clippy::useless_attribute)] 44 pub use error::Error; 45 use figment::{Figment, providers::Format as _}; ··· 68 pub type Result<T> = std::result::Result<T, Error>; 69 /// The reqwest client type with middleware. 70 pub type Client = reqwest_middleware::ClientWithMiddleware; 71 - /// The database connection pool. 72 - pub type Db = r2d2::Pool<ConnectionManager<SqliteConnection>>; 73 /// The Azure credential type. 74 pub type Cred = Arc<dyn TokenCredential>; 75 ··· 132 verbosity: Verbosity<InfoLevel>, 133 } 134 0 0 0 0 0 0 0 0 0 0 0 0 0 135 #[expect(clippy::arbitrary_source_item_ordering, reason = "arbitrary")] 136 #[derive(Clone, FromRef)] 137 struct AppState { ··· 139 config: AppConfig, 140 /// The Azure credential. 141 cred: Cred, 142 - /// The database connection pool. 143 - db: Db, 0 0 144 145 /// The HTTP client with middleware. 146 client: Client, ··· 291 #[expect( 292 clippy::cognitive_complexity, 293 clippy::too_many_lines, 0 294 reason = "main function has high complexity" 295 )] 296 async fn run() -> anyhow::Result<()> { ··· 388 let cred = azure_identity::DefaultAzureCredential::new() 389 .context("failed to create Azure credential")?; 390 391 - // Create a database connection manager and pool 392 - let manager = ConnectionManager::<SqliteConnection>::new(&config.db); 393 - let db = r2d2::Pool::builder() 394 - .build(manager) 395 - .context("failed to create database connection pool")?; 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 396 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 397 // Apply pending migrations 398 - let conn = &mut db 399 - .get() 400 - .context("failed to get database connection for migrations")?; 401 - conn.run_pending_migrations(MIGRATIONS) 402 - .expect("should be able to run migrations"); 403 404 let (_fh, fhp) = firehose::spawn(client.clone(), config.clone()); 405 ··· 422 .with_state(AppState { 423 cred, 424 config: config.clone(), 425 - db: db.clone(), 0 426 client: client.clone(), 427 simple_client, 428 firehose: fhp, ··· 435 436 // Determine whether or not this was the first startup (i.e. no accounts exist and no invite codes were created). 437 // If so, create an invite code and share it via the console. 438 - let conn = &mut db.get().context("failed to get database connection")?; 439 440 #[derive(QueryableByName)] 441 struct TotalCount { ··· 443 total_count: i32, 444 } 445 446 - let result = diesel::sql_query( 447 - "SELECT (SELECT COUNT(*) FROM accounts) + (SELECT COUNT(*) FROM invites) AS total_count", 448 - ) 449 - .get_result::<TotalCount>(conn) 450 - .context("failed to query database")?; 0 0 0 0 0 0 0 0 451 452 let c = result.total_count; 453 ··· 455 if c == 0 { 456 let uuid = Uuid::new_v4().to_string(); 457 458 - diesel::sql_query( 0 0 459 "INSERT INTO invites (id, did, count, created_at) VALUES (?, NULL, 1, datetime('now'))", 460 ) 461 - .bind::<diesel::sql_types::Text, _>(uuid.clone()) 462 .execute(conn) 463 - .context("failed to create new invite code")?; 0 0 464 465 // N.B: This is a sensitive message, so we're bypassing `tracing` here and 466 // logging it directly to console.

··· 37 use clap::Parser; 38 use clap_verbosity_flag::{InfoLevel, Verbosity, log::LevelFilter}; 39 use config::AppConfig; 40 + use db::establish_pool; 41 + use deadpool_diesel::sqlite::Pool; 42 use diesel::prelude::*; 43 + use diesel_migrations::{EmbeddedMigrations, embed_migrations}; 0 44 #[expect(clippy::pub_use, clippy::useless_attribute)] 45 pub use error::Error; 46 use figment::{Figment, providers::Format as _}; ··· 69 pub type Result<T> = std::result::Result<T, Error>; 70 /// The reqwest client type with middleware. 71 pub type Client = reqwest_middleware::ClientWithMiddleware; 0 0 72 /// The Azure credential type. 73 pub type Cred = Arc<dyn TokenCredential>; 74 ··· 131 verbosity: Verbosity<InfoLevel>, 132 } 133 134 + struct ActorPools { 135 + repo: Pool, 136 + blob: Pool, 137 + } 138 + impl Clone for ActorPools { 139 + fn clone(&self) -> Self { 140 + Self { 141 + repo: self.repo.clone(), 142 + blob: self.blob.clone(), 143 + } 144 + } 145 + } 146 + 147 #[expect(clippy::arbitrary_source_item_ordering, reason = "arbitrary")] 148 #[derive(Clone, FromRef)] 149 struct AppState { ··· 151 config: AppConfig, 152 /// The Azure credential. 153 cred: Cred, 154 + /// The main database connection pool. Used for common PDS data, like invite codes. 155 + db: Pool, 156 + /// Actor-specific database connection pools. Hashed by DID. 157 + db_actors: std::collections::HashMap<String, ActorPools>, 158 159 /// The HTTP client with middleware. 160 client: Client, ··· 305 #[expect( 306 clippy::cognitive_complexity, 307 clippy::too_many_lines, 308 + unused_qualifications, 309 reason = "main function has high complexity" 310 )] 311 async fn run() -> anyhow::Result<()> { ··· 403 let cred = azure_identity::DefaultAzureCredential::new() 404 .context("failed to create Azure credential")?; 405 406 + // Create a database connection manager and pool for the main database. 407 + let pool = 408 + establish_pool(&config.db).context("failed to establish database connection pool")?; 409 + // Create a dictionary of database connection pools for each actor. 410 + let mut actor_pools = std::collections::HashMap::new(); 411 + // let mut actor_blob_pools = std::collections::HashMap::new(); 412 + // We'll determine actors by looking in the data/repo dir for .db files. 413 + let mut actor_dbs = tokio::fs::read_dir(&config.repo.path) 414 + .await 415 + .context("failed to read repo directory")?; 416 + while let Some(entry) = actor_dbs 417 + .next_entry() 418 + .await 419 + .context("failed to read repo dir")? 420 + { 421 + let path = entry.path(); 422 + if path.extension().and_then(|s| s.to_str()) == Some("db") { 423 + let did = path 424 + .file_stem() 425 + .and_then(|s| s.to_str()) 426 + .context("failed to get actor DID")?; 427 + let did = Did::from_str(did).expect("should be able to parse actor DID"); 428 429 + // Create a new database connection manager and pool for the actor. 430 + // The path for the SQLite connection needs to look like "sqlite://data/repo/<actor>.db" 431 + let path_repo = format!("sqlite://{}", path.display()); 432 + let actor_repo_pool = 433 + establish_pool(&path_repo).context("failed to create database connection pool")?; 434 + // Create a new database connection manager and pool for the actor blobs. 435 + // The path for the SQLite connection needs to look like "sqlite://data/blob/<actor>.db" 436 + let path_blob = path_repo.replace("repo", "blob"); 437 + let actor_blob_pool = 438 + establish_pool(&path_blob).context("failed to create database connection pool")?; 439 + actor_pools.insert( 440 + did.to_string(), 441 + ActorPools { 442 + repo: actor_repo_pool, 443 + blob: actor_blob_pool, 444 + }, 445 + ); 446 + } 447 + } 448 // Apply pending migrations 449 + // let conn = pool.get().await?; 450 + // conn.run_pending_migrations(MIGRATIONS) 451 + // .expect("should be able to run migrations"); 0 0 452 453 let (_fh, fhp) = firehose::spawn(client.clone(), config.clone()); 454 ··· 471 .with_state(AppState { 472 cred, 473 config: config.clone(), 474 + db: pool.clone(), 475 + db_actors: actor_pools.clone(), 476 client: client.clone(), 477 simple_client, 478 firehose: fhp, ··· 485 486 // Determine whether or not this was the first startup (i.e. no accounts exist and no invite codes were created). 487 // If so, create an invite code and share it via the console. 488 + let conn = pool.get().await.context("failed to get db connection")?; 489 490 #[derive(QueryableByName)] 491 struct TotalCount { ··· 493 total_count: i32, 494 } 495 496 + // let result = diesel::sql_query( 497 + // "SELECT (SELECT COUNT(*) FROM accounts) + (SELECT COUNT(*) FROM invites) AS total_count", 498 + // ) 499 + // .get_result::<TotalCount>(conn) 500 + // .context("failed to query database")?; 501 + let result = conn.interact(move |conn| { 502 + diesel::sql_query( 503 + "SELECT (SELECT COUNT(*) FROM accounts) + (SELECT COUNT(*) FROM invites) AS total_count", 504 + ) 505 + .get_result::<TotalCount>(conn) 506 + }) 507 + .await 508 + .expect("should be able to query database")?; 509 510 let c = result.total_count; 511 ··· 513 if c == 0 { 514 let uuid = Uuid::new_v4().to_string(); 515 516 + let uuid_clone = uuid.clone(); 517 + conn.interact(move |conn| { 518 + diesel::sql_query( 519 "INSERT INTO invites (id, did, count, created_at) VALUES (?, NULL, 1, datetime('now'))", 520 ) 521 + .bind::<diesel::sql_types::Text, _>(uuid_clone) 522 .execute(conn) 523 + .context("failed to create new invite code") 524 + .expect("should be able to create invite code") 525 + }); 526 527 // N.B: This is a sensitive message, so we're bypassing `tracing` here and 528 // logging it directly to console.

+1 -1

src/tests.rs

··· 222 let opts = SqliteConnectOptions::from_str(&config.db) 223 .context("failed to parse database options")? 224 .create_if_missing(true); 225 - let db = SqlitePool::connect_with(opts).await?; 226 227 sqlx::migrate!() 228 .run(&db)

··· 222 let opts = SqliteConnectOptions::from_str(&config.db) 223 .context("failed to parse database options")? 224 .create_if_missing(true); 225 + let db = SqliteDbConn::connect_with(opts).await?; 226 227 sqlx::migrate!() 228 .run(&db)