Struct ShardServer 

pub struct ShardServer { /* private fields */ }

Server implementation for a shard.

ShardServer wraps a ShardedColony and implements the ShardService trait, allowing remote clients to interact with the shard via tarpc RPC.

Thread Safety

The server uses Arc<RwLock<ShardedColony>> to allow safe concurrent access from multiple RPC handler tasks.

Example

use phago_distributed::rpc::server::ShardServer;
use phago_distributed::shard::ShardedColony;

let shard = Arc::new(RwLock::new(ShardedColony::new(...)));
let server = ShardServer::new(shard);
server.serve("127.0.0.1:8080".parse().unwrap()).await?;

Implementations

impl ShardServer

pub fn new(shard: Arc<RwLock<ShardedColony>>) -> Self

Create a new shard server.

Arguments

• shard - The sharded colony to serve

pub async fn start(self, addr: SocketAddr) -> Result<(), Error>

Start serving on the given address.

This method listens for incoming connections and spawns a task for each client to handle their requests concurrently.

Arguments

• addr - The socket address to bind to

Errors

Returns an error if the server fails to bind to the address.

Trait Implementations

impl Clone for ShardServer

fn clone(&self) -> ShardServer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ShardService for ShardServer

async fn ingest_document( self, _ctx: Context, doc: Document, ) -> RpcResult<DocumentId>

Ingest a document into this shard.

async fn tick_phase( self, _ctx: Context, phase: TickPhase, tick: u64, ) -> RpcResult<PhaseResult>

Execute a tick phase on this shard.

async fn local_query( self, _ctx: Context, req: LocalQueryRequest, ) -> RpcResult<LocalQueryResult>

Execute a local query (part of distributed query).

async fn get_term_frequencies( self, _ctx: Context, terms: Vec<String>, ) -> RpcResult<HashMap<String, u64>>

Get term frequencies for global DF computation.

async fn get_node( self, _ctx: Context, id: NodeId, ) -> RpcResult<Option<NodeData>>

Fetch a node’s full data (for ghost node resolution).

async fn health_check(self, _ctx: Context) -> RpcResult<ShardHealth>

Health check.

async fn resolve_ghost_nodes( self, _ctx: Context, node_ids: Vec<NodeId>, ) -> RpcResult<Vec<GhostNode>>

Resolve cross-shard edges by fetching ghost node data.

async fn get_neighbors( self, _ctx: Context, node_id: NodeId, ) -> RpcResult<Vec<NodeId>>

Get the list of nodes connected to a given node.

async fn receive_signals( self, _ctx: Context, signals: Vec<CrossShardSignal>, ) -> RpcResult<()>

Receive cross-shard signals during the Exchange phase.

fn serve(self) -> ServeShardService<Self>

Returns a serving function to use with InFlightRequest::execute.