Struct RpcServer 

pub struct RpcServer<'a> { /* private fields */ }

Server side of the shared-memory RPC protocol.

Polls the request region (offset 0) for incoming calls, dispatches them via the provided RpcHandler, and writes responses to the response region (offset 32768).

Example

use grafos_rpc::{RpcHandler, RpcServer};
use grafos_std::error::{FabricError, Result};
use grafos_std::mem::MemBuilder;

struct Echo;
impl RpcHandler for Echo {
    fn handle(&self, _method_id: u32, payload: &[u8]) -> Result<Vec<u8>> {
        Ok(payload.to_vec())
    }
}

let lease = MemBuilder::new().min_bytes(65536).acquire()?;
let server = RpcServer::new(&lease);

// In your event loop:
// let handled = server.poll_once(&Echo)?;

Implementations

impl<'a> RpcServer<'a>

pub fn new(lease: &'a MemLease) -> Self

Create a new RPC server backed by the given memory lease.

pub fn poll_once<H: RpcHandler>(&self, handler: &H) -> Result<bool>

Poll for and handle a single request.

Reads the request region. If a request with status REQUEST_READY is present:

1. Sets status to PROCESSING.
2. Calls handler.handle(method_id, payload).
3. Writes RESPONSE_READY (or ERROR) to the response region.
4. Clears the request region to EMPTY.
5. Returns Ok(true).

If no request is pending, returns Ok(false) without side effects.

pub fn serve_n<H: RpcHandler>( &self, handler: &H, max_iterations: u64, ) -> Result<u64>

Serve requests in a loop for up to max_iterations polls.

Returns the number of requests actually handled (i.e. the number of times poll_once returned Ok(true)).

This is a convenience for testing where you know a fixed number of calls will arrive. In production, call poll_once from your own event loop.