Struct PooledAsyncBackend 

pub struct PooledAsyncBackend { /* private fields */ }

Pooled async storage backend with resource management

This backend wraps AsyncSledBackend with a semaphore-based pool that:

• Limits concurrent operations to prevent resource exhaustion
• Provides backpressure when the pool is saturated
• Collects metrics on pool utilization
• Implements timeouts to prevent indefinite blocking

Examples

use llm_memory_graph::storage::{PooledAsyncBackend, PoolConfig};
use std::path::Path;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = PoolConfig::new()
        .with_max_concurrent(50)
        .with_timeout(3000);

    let backend = PooledAsyncBackend::open(Path::new("./data/db"), config).await?;

    // Get pool metrics
    let metrics = backend.metrics();
    println!("Active operations: {}", metrics.active_operations);

    Ok(())
}

Implementations

impl PooledAsyncBackend

pub async fn open(path: &Path, config: PoolConfig) -> Result<Self>

Open a pooled async backend

Examples

use llm_memory_graph::storage::{PooledAsyncBackend, PoolConfig};
use std::path::Path;

let backend = PooledAsyncBackend::open(
    Path::new("./data/db"),
    PoolConfig::default()
).await?;

pub fn metrics(&self) -> PoolMetricsSnapshot

Get current pool metrics

pub fn config(&self) -> &PoolConfig

Get pool configuration

pub fn available_permits(&self) -> usize

Get number of available permits

Trait Implementations

impl AsyncStorageBackend for PooledAsyncBackend

fn store_node<'life0, 'life1, 'async_trait>( &'life0 self, node: &'life1 Node, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store a node in the backend asynchronously

fn get_node<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Node>>> + Send + 'async_trait>>

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

Retrieve a node by ID asynchronously

fn delete_node<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Delete a node asynchronously

fn store_edge<'life0, 'life1, 'async_trait>( &'life0 self, edge: &'life1 Edge, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store an edge asynchronously

fn get_edge<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 EdgeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Edge>>> + Send + 'async_trait>>

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

Retrieve an edge by ID asynchronously

fn delete_edge<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 EdgeId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Delete an edge asynchronously

fn get_session_nodes<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Node>>> + Send + 'async_trait>>

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

Get all nodes in a session asynchronously

fn get_outgoing_edges<'life0, 'life1, 'async_trait>( &'life0 self, node_id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Edge>>> + Send + 'async_trait>>

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

Get all edges from a node asynchronously

fn get_incoming_edges<'life0, 'life1, 'async_trait>( &'life0 self, node_id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Edge>>> + Send + 'async_trait>>

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

Get all edges to a node asynchronously

fn flush<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Flush any pending writes asynchronously

fn stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<StorageStats>> + Send + 'async_trait>>

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

Get storage statistics asynchronously

fn store_nodes_batch<'life0, 'life1, 'async_trait>( &'life0 self, nodes: &'life1 [Node], ) -> Pin<Box<dyn Future<Output = Result<Vec<NodeId>>> + Send + 'async_trait>>

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

Batch store multiple nodes asynchronously for improved performance

fn store_edges_batch<'life0, 'life1, 'async_trait>( &'life0 self, edges: &'life1 [Edge], ) -> Pin<Box<dyn Future<Output = Result<Vec<EdgeId>>> + Send + 'async_trait>>

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

Batch store multiple edges asynchronously for improved performance

fn get_session_nodes_stream( &self, session_id: &SessionId, ) -> Pin<Box<dyn Stream<Item = Result<Node>> + Send + '_>>

Stream nodes from a session for memory-efficient iteration over large result sets

fn count_session_nodes<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

Count nodes in a session without loading them into memory