Struct GradientSyncService 

pub struct GradientSyncService { /* private fields */ }

gRPC-style service that streams gradient chunks to clients as they arrive from peers.

The service wraps a BlockStore so that concurrent sync sessions can safely share the same block store without requiring access to the full Node type (which lives in the ipfrs crate and cannot be referenced from ipfrs-interface without a circular dependency).

Usage

use ipfrs_interface::gradient_sync::{GradientSyncRequest, GradientSyncService};
use ipfrs_storage::{BlockStoreConfig, SledBlockStore};
use ipfrs_tensorlogic::gradient::arrow_ipc::store_gradient_as_arrow;
use std::sync::Arc;

let config = BlockStoreConfig { path: std::env::temp_dir().join("grad"), cache_size: 64 * 1024 * 1024 };
let store = Arc::new(SledBlockStore::new(config)?);
let service = GradientSyncService::new(store);

let gradient: Vec<f32> = (0u32..256).map(|i| i as f32 * 0.01).collect();
let local_gradient = store_gradient_as_arrow(&gradient)?;

let request = GradientSyncRequest {
    session_id: "round-1".to_string(),
    local_gradient,
    min_peers: 0,
    timeout_secs: 30,
};

let (tx, mut rx) = tokio::sync::mpsc::channel(64);
service.sync_gradients(request, tx).await?;

while let Some(chunk) = rx.recv().await {
    println!("received chunk {}/{}", chunk.chunk_index + 1, chunk.total_chunks);
}

Implementations

impl GradientSyncService

pub fn new(store: Arc<dyn BlockStore>) -> Self

Create a new service backed by store.

pub async fn sync_gradients( &self, request: GradientSyncRequest, chunk_tx: Sender<GradientChunkResponse>, ) -> Result<()>

Start a gradient sync session and stream chunks via chunk_tx.

Workflow

1. Decode request.local_gradient from Arrow IPC.
2. Commit the local gradient to the block store via DistributedGradientAccumulator::commit_local.
3. Poll for peer gradients (stubbed — no live network in this layer).
4. Push one GradientChunkResponse per local chunk onto chunk_tx so that the caller can observe streaming behaviour end-to-end.

When full peer-to-peer transport is wired up at the ipfrs crate level, step 3 would await actual peer CIDs from the GossipSub GRADIENT_SYNC event loop.