Struct MultiRelayBlobService 

pub struct MultiRelayBlobService<S: BlobStorage> {
    relay_services: Arc<RwLock<HashMap<KeyId, Arc<dyn BlobStore>>>>,
    storage: Arc<S>,
}

Multi-relay blob service that manages blob uploads across multiple relays and tracks upload status using persistent storage

Fields

relay_services: Arc<RwLock<HashMap<KeyId, Arc<dyn BlobStore>>>>

Map of relay ID to blob service for that relay (thread-safe)

storage: Arc<S>

Storage for tracking blob upload status

Implementations

impl<S: BlobStorage> MultiRelayBlobService<S>

pub fn new(storage: Arc<S>) -> Self

Create a new multi-relay blob service

pub fn new_with_relays( storage: Arc<S>, relay_services: impl IntoIterator<Item = (KeyId, Arc<dyn BlobStore>)>, ) -> Self

pub async fn add_relay(&self, relay_id: KeyId, service: Arc<dyn BlobStore>)

Add a relay blob service

pub async fn remove_relay(&self, relay_id: &KeyId) -> Option<Arc<dyn BlobStore>>

Remove a relay blob service

pub async fn get_relay_ids(&self) -> Vec<KeyId>

Get all configured relay IDs

pub async fn is_blob_uploaded_to_relay( &self, blob_hash: &BlobId, relay_id: &KeyId, ) -> Result<bool, BlobError>

Check if a blob has been uploaded to a specific relay

pub async fn get_blob_upload_status( &self, blob_hash: &BlobId, ) -> Result<Vec<BlobUploadStatus>, BlobError>

Get upload status for a blob across all relays

pub async fn upload_blob_to_relay( &self, blob: &[u8], relay_id: &KeyId, ) -> Result<BlobId, BlobError>

Upload a blob to a specific relay and track the upload

async fn upload_blob_to_single_relay_and_mark_as_uploaded( blob: &[u8], service: Arc<dyn BlobStore>, relay_id: &KeyId, storage: Arc<S>, ) -> Result<BlobId, BlobError>

pub async fn upload_blob_to_all_relays( &self, blob: &[u8], ) -> Result<HashMap<KeyId, Result<BlobId, BlobError>>, BlobError>

Upload a blob to all configured relays (in parallel)

pub async fn upload_blob_to_missing_relays( &self, blob: &[u8], ) -> Result<HashMap<KeyId, Result<BlobId, BlobError>>, BlobError>

Upload a blob to relays where it hasn’t been uploaded yet (in parallel)

pub async fn download_blob_from_any_relay( &self, blob_hash: &BlobId, ) -> Result<Vec<u8>, BlobError>

Download a blob from any available relay (tries relays in order)

pub async fn get_relay_blob_stats( &self, relay_id: &KeyId, ) -> Result<(u64, u64), BlobError>

Get statistics about blob uploads for a specific relay

pub async fn remove_blob_records( &self, blob_hash: &BlobId, ) -> Result<u64, BlobError>

Remove blob upload records (when blob is deleted)

Trait Implementations

impl<S: BlobStorage> BlobStore for MultiRelayBlobService<S>

fn get_blob<'life0, 'life1, 'async_trait>( &'life0 self, blob_id: &'life1 BlobId, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, BlobError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Download a blob from any available relay

fn upload_blob<'life0, 'life1, 'async_trait>( &'life0 self, blob: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<BlobId, BlobError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Upload a blob to all configured relays