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 56)

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

    let config = SharedMemoryConfig::default();
    let transport = SharedMemoryTransport::create_server(SERVICE_NAME, config)?;
    let msg_transport = Arc::new(MessageTransportAdapter::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(msg_transport).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 58-63)

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

    let config = SharedMemoryConfig::default();
    let transport = SharedMemoryTransport::create_server(SERVICE_NAME, config)?;
    let msg_transport = Arc::new(MessageTransportAdapter::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(msg_transport).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 handle_message<T: MessageTransport<C>>( &self, message: Message<C>, transport: &T, ) -> Option<Message<C>>

pub async fn serve<T: MessageTransport<C>>( &self, transport: Arc<T>, ) -> Result<()>

Examples found in repository

examples/rpc_client_server.rs (line 77)

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

    let config = SharedMemoryConfig::default();
    let transport = SharedMemoryTransport::create_server(SERVICE_NAME, config)?;
    let msg_transport = Arc::new(MessageTransportAdapter::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(msg_transport).await?;

    Ok(())
}

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

pub fn handler_count(&self) -> usize

Examples found in repository

examples/rpc_client_server.rs (line 74)

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

    let config = SharedMemoryConfig::default();
    let transport = SharedMemoryTransport::create_server(SERVICE_NAME, config)?;
    let msg_transport = Arc::new(MessageTransportAdapter::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(msg_transport).await?;

    Ok(())
}

Trait Implementations

impl Default for RpcServer<BincodeCodec>

fn default() -> Self

Returns the “default value” for a type.