Struct RpcServer 

pub struct RpcServer<C: Codec = BincodeCodec> { /* private fields */ }

Implementations

impl RpcServer<BincodeCodec>

pub fn new() -> Self

Examples found in repository

examples/rpc_client_server.rs (line 58)

async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
    println!("[Server] Starting RPC server");

    let config = SharedMemoryConfig::default();
    let transport = SharedMemoryFrameTransport::create_server(SERVICE_NAME, config)?;
    let channel = Arc::new(MessageChannelAdapter::new(transport));

    let server = RpcServer::new();

    server.register_typed("add", |req: AddRequest| async move {
        println!("[Server] add({}, {})", req.a, req.b);
        Ok(AddResponse {
            result: req.a + req.b,
        })
    });

    server.register_typed("echo", |req: EchoRequest| async move {
        println!("[Server] echo(\"{}\")", req.message);
        let len = req.message.len();
        Ok(EchoResponse {
            message: req.message,
            length: len,
        })
    });

    println!("[Server] Registered {} handlers", server.handler_count());
    println!("[Server] Waiting for requests\n");

    server.serve(channel).await?;

    Ok(())
}

impl<C: Codec + Clone + Default + 'static> RpcServer<C>

pub fn with_codec(codec: C) -> Self

pub fn register(&self, handler: Arc<dyn Handler<C>>)

pub fn register_fn<F, Fut>(&self, method: impl Into<String>, func: F)

where F: Fn(Message<C>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Message<C>>> + Send + 'static,

pub fn register_typed<Req, Resp, F, Fut>( &self, method: impl Into<String>, func: F, )

where Req: for<'de> Deserialize<'de> + Send + Sync + 'static, Resp: Serialize + Send + Sync + 'static, F: Fn(Req) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Resp>> + Send + 'static,

Examples found in repository

examples/rpc_client_server.rs (lines 60-65)

async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
    println!("[Server] Starting RPC server");

    let config = SharedMemoryConfig::default();
    let transport = SharedMemoryFrameTransport::create_server(SERVICE_NAME, config)?;
    let channel = Arc::new(MessageChannelAdapter::new(transport));

    let server = RpcServer::new();

    server.register_typed("add", |req: AddRequest| async move {
        println!("[Server] add({}, {})", req.a, req.b);
        Ok(AddResponse {
            result: req.a + req.b,
        })
    });

    server.register_typed("echo", |req: EchoRequest| async move {
        println!("[Server] echo(\"{}\")", req.message);
        let len = req.message.len();
        Ok(EchoResponse {
            message: req.message,
            length: len,
        })
    });

    println!("[Server] Registered {} handlers", server.handler_count());
    println!("[Server] Waiting for requests\n");

    server.serve(channel).await?;

    Ok(())
}

pub fn register_stream<Req, Item, F, S>( &self, method: impl Into<String>, func: F, )

where Req: for<'de> Deserialize<'de> + Send + Sync + 'static, Item: Serialize + Send + Sync + 'static, S: Stream<Item = Result<Item>> + Send + 'static, F: Fn(Req) -> S + Send + Sync + 'static,

pub fn register_stream_fn<F, Fut>(&self, method: impl Into<String>, func: F)

where F: Fn(Message<C>, ServerStreamSender<C>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

pub async fn serve<T: MessageChannel<C> + 'static>( &self, transport: Arc<T>, ) -> Result<()>

Serve requests concurrently, dispatching each message in its own tokio task.

Examples found in repository

examples/rpc_client_server.rs (line 79)

async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
    println!("[Server] Starting RPC server");

    let config = SharedMemoryConfig::default();
    let transport = SharedMemoryFrameTransport::create_server(SERVICE_NAME, config)?;
    let channel = Arc::new(MessageChannelAdapter::new(transport));

    let server = RpcServer::new();

    server.register_typed("add", |req: AddRequest| async move {
        println!("[Server] add({}, {})", req.a, req.b);
        Ok(AddResponse {
            result: req.a + req.b,
        })
    });

    server.register_typed("echo", |req: EchoRequest| async move {
        println!("[Server] echo(\"{}\")", req.message);
        let len = req.message.len();
        Ok(EchoResponse {
            message: req.message,
            length: len,
        })
    });

    println!("[Server] Registered {} handlers", server.handler_count());
    println!("[Server] Waiting for requests\n");

    server.serve(channel).await?;

    Ok(())
}

pub async fn serve_sequential<T: MessageChannel<C> + 'static>( &self, transport: Arc<T>, ) -> Result<()>

Serve requests sequentially, processing one message at a time.

This preserves strict one-at-a-time message processing for cases where ordering guarantees or single-threaded handler execution is required.

pub fn spawn_handler<T: MessageChannel<C> + 'static>( &self, transport: T, ) -> ServerHandle

pub fn handler_count(&self) -> usize

Examples found in repository

examples/rpc_client_server.rs (line 76)

async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
    println!("[Server] Starting RPC server");

    let config = SharedMemoryConfig::default();
    let transport = SharedMemoryFrameTransport::create_server(SERVICE_NAME, config)?;
    let channel = Arc::new(MessageChannelAdapter::new(transport));

    let server = RpcServer::new();

    server.register_typed("add", |req: AddRequest| async move {
        println!("[Server] add({}, {})", req.a, req.b);
        Ok(AddResponse {
            result: req.a + req.b,
        })
    });

    server.register_typed("echo", |req: EchoRequest| async move {
        println!("[Server] echo(\"{}\")", req.message);
        let len = req.message.len();
        Ok(EchoResponse {
            message: req.message,
            length: len,
        })
    });

    println!("[Server] Registered {} handlers", server.handler_count());
    println!("[Server] Waiting for requests\n");

    server.serve(channel).await?;

    Ok(())
}

Trait Implementations

impl Default for RpcServer<BincodeCodec>

fn default() -> Self

Returns the “default value” for a type.