pub struct RpcClient<T, C: Codec = BincodeCodec>where
T: MessageTransport<C>,{ /* private fields */ }Implementations§
Source§impl<T: MessageTransport<BincodeCodec> + 'static> RpcClient<T, BincodeCodec>
impl<T: MessageTransport<BincodeCodec> + 'static> RpcClient<T, BincodeCodec>
Sourcepub fn new(transport: T) -> Self
pub fn new(transport: T) -> Self
Examples found in repository?
examples/rpc_client_server.rs (line 88)
82async fn run_client() -> Result<(), Box<dyn std::error::Error>> {
83 println!("[Client] Connecting to RPC server");
84
85 let transport = SharedMemoryTransport::connect_client(SERVICE_NAME)?;
86 let msg_transport = MessageTransportAdapter::new(transport);
87
88 let client = RpcClient::new(msg_transport);
89 let _handle = client.start();
90
91 println!("[Client] Connected!\n");
92
93 println!("[Client] Calling add(10, 32)");
94 let resp: AddResponse = client.call("add", &AddRequest { a: 10, b: 32 }).await?;
95 println!("[Client] Result: {}\n", resp.result);
96
97 println!("[Client] Calling add(100, 200)");
98 let resp: AddResponse = client.call("add", &AddRequest { a: 100, b: 200 }).await?;
99 println!("[Client] Result: {}\n", resp.result);
100
101 println!("[Client] Calling echo(\"Hello, RPC!\")");
102 let resp: EchoResponse = client
103 .call(
104 "echo",
105 &EchoRequest {
106 message: "Hello, RPC!".to_string(),
107 },
108 )
109 .await?;
110 println!(
111 "[Client] Result: message=\"{}\", length={}\n",
112 resp.message, resp.length
113 );
114
115 println!("[Client] Calling unknown method");
116 let result: Result<(), _> = client.call("unknown", &()).await;
117 match result {
118 Ok(_) => println!("[Client] Unexpected success"),
119 Err(e) => println!("[Client] Got expected error: {}\n", e),
120 }
121
122 client.close().await?;
123 println!("[Client] Done!");
124
125 Ok(())
126}pub fn with_timeout(transport: T, default_timeout: Duration) -> Self
Source§impl<T, C> RpcClient<T, C>
impl<T, C> RpcClient<T, C>
pub fn with_codec(transport: T, codec: C) -> Self
pub fn with_codec_and_timeout( transport: T, codec: C, default_timeout: Duration, ) -> Self
Sourcepub fn start(&self) -> RpcClientHandle
pub fn start(&self) -> RpcClientHandle
Examples found in repository?
examples/rpc_client_server.rs (line 89)
82async fn run_client() -> Result<(), Box<dyn std::error::Error>> {
83 println!("[Client] Connecting to RPC server");
84
85 let transport = SharedMemoryTransport::connect_client(SERVICE_NAME)?;
86 let msg_transport = MessageTransportAdapter::new(transport);
87
88 let client = RpcClient::new(msg_transport);
89 let _handle = client.start();
90
91 println!("[Client] Connected!\n");
92
93 println!("[Client] Calling add(10, 32)");
94 let resp: AddResponse = client.call("add", &AddRequest { a: 10, b: 32 }).await?;
95 println!("[Client] Result: {}\n", resp.result);
96
97 println!("[Client] Calling add(100, 200)");
98 let resp: AddResponse = client.call("add", &AddRequest { a: 100, b: 200 }).await?;
99 println!("[Client] Result: {}\n", resp.result);
100
101 println!("[Client] Calling echo(\"Hello, RPC!\")");
102 let resp: EchoResponse = client
103 .call(
104 "echo",
105 &EchoRequest {
106 message: "Hello, RPC!".to_string(),
107 },
108 )
109 .await?;
110 println!(
111 "[Client] Result: message=\"{}\", length={}\n",
112 resp.message, resp.length
113 );
114
115 println!("[Client] Calling unknown method");
116 let result: Result<(), _> = client.call("unknown", &()).await;
117 match result {
118 Ok(_) => println!("[Client] Unexpected success"),
119 Err(e) => println!("[Client] Got expected error: {}\n", e),
120 }
121
122 client.close().await?;
123 println!("[Client] Done!");
124
125 Ok(())
126}pub fn transport(&self) -> Arc<T>
pub fn stream_manager(&self) -> Arc<StreamManager<C>>
Sourcepub async fn call<Req, Resp>(&self, method: &str, request: &Req) -> Result<Resp>where
Req: Serialize,
Resp: for<'de> Deserialize<'de>,
pub async fn call<Req, Resp>(&self, method: &str, request: &Req) -> Result<Resp>where
Req: Serialize,
Resp: for<'de> Deserialize<'de>,
Examples found in repository?
examples/rpc_client_server.rs (line 94)
82async fn run_client() -> Result<(), Box<dyn std::error::Error>> {
83 println!("[Client] Connecting to RPC server");
84
85 let transport = SharedMemoryTransport::connect_client(SERVICE_NAME)?;
86 let msg_transport = MessageTransportAdapter::new(transport);
87
88 let client = RpcClient::new(msg_transport);
89 let _handle = client.start();
90
91 println!("[Client] Connected!\n");
92
93 println!("[Client] Calling add(10, 32)");
94 let resp: AddResponse = client.call("add", &AddRequest { a: 10, b: 32 }).await?;
95 println!("[Client] Result: {}\n", resp.result);
96
97 println!("[Client] Calling add(100, 200)");
98 let resp: AddResponse = client.call("add", &AddRequest { a: 100, b: 200 }).await?;
99 println!("[Client] Result: {}\n", resp.result);
100
101 println!("[Client] Calling echo(\"Hello, RPC!\")");
102 let resp: EchoResponse = client
103 .call(
104 "echo",
105 &EchoRequest {
106 message: "Hello, RPC!".to_string(),
107 },
108 )
109 .await?;
110 println!(
111 "[Client] Result: message=\"{}\", length={}\n",
112 resp.message, resp.length
113 );
114
115 println!("[Client] Calling unknown method");
116 let result: Result<(), _> = client.call("unknown", &()).await;
117 match result {
118 Ok(_) => println!("[Client] Unexpected success"),
119 Err(e) => println!("[Client] Got expected error: {}\n", e),
120 }
121
122 client.close().await?;
123 println!("[Client] Done!");
124
125 Ok(())
126}pub async fn call_with_timeout<Req, Resp>(
&self,
method: &str,
request: &Req,
timeout: Duration,
) -> Result<Resp>where
Req: Serialize,
Resp: for<'de> Deserialize<'de>,
pub async fn call_server_stream<Req, Resp>(
&self,
method: &str,
request: &Req,
) -> Result<StreamReceiver<Resp, C>>where
Req: Serialize,
Resp: for<'de> Deserialize<'de>,
pub async fn notify<Req: Serialize>( &self, method: &str, request: &Req, ) -> Result<()>
pub async fn call_raw(&self, method: &str, payload: Vec<u8>) -> Result<Vec<u8>>
pub async fn call_raw_with_timeout( &self, method: &str, payload: Vec<u8>, timeout: Duration, ) -> Result<Vec<u8>>
pub fn is_connected(&self) -> bool
pub fn active_streams(&self) -> usize
Sourcepub async fn close(&self) -> Result<()>
pub async fn close(&self) -> Result<()>
Examples found in repository?
examples/rpc_client_server.rs (line 122)
82async fn run_client() -> Result<(), Box<dyn std::error::Error>> {
83 println!("[Client] Connecting to RPC server");
84
85 let transport = SharedMemoryTransport::connect_client(SERVICE_NAME)?;
86 let msg_transport = MessageTransportAdapter::new(transport);
87
88 let client = RpcClient::new(msg_transport);
89 let _handle = client.start();
90
91 println!("[Client] Connected!\n");
92
93 println!("[Client] Calling add(10, 32)");
94 let resp: AddResponse = client.call("add", &AddRequest { a: 10, b: 32 }).await?;
95 println!("[Client] Result: {}\n", resp.result);
96
97 println!("[Client] Calling add(100, 200)");
98 let resp: AddResponse = client.call("add", &AddRequest { a: 100, b: 200 }).await?;
99 println!("[Client] Result: {}\n", resp.result);
100
101 println!("[Client] Calling echo(\"Hello, RPC!\")");
102 let resp: EchoResponse = client
103 .call(
104 "echo",
105 &EchoRequest {
106 message: "Hello, RPC!".to_string(),
107 },
108 )
109 .await?;
110 println!(
111 "[Client] Result: message=\"{}\", length={}\n",
112 resp.message, resp.length
113 );
114
115 println!("[Client] Calling unknown method");
116 let result: Result<(), _> = client.call("unknown", &()).await;
117 match result {
118 Ok(_) => println!("[Client] Unexpected success"),
119 Err(e) => println!("[Client] Got expected error: {}\n", e),
120 }
121
122 client.close().await?;
123 println!("[Client] Done!");
124
125 Ok(())
126}Trait Implementations§
Auto Trait Implementations§
impl<T, C> Freeze for RpcClient<T, C>where
C: Freeze,
impl<T, C = BincodeCodec> !RefUnwindSafe for RpcClient<T, C>
impl<T, C> Send for RpcClient<T, C>
impl<T, C> Sync for RpcClient<T, C>
impl<T, C> Unpin for RpcClient<T, C>where
C: Unpin,
impl<T, C = BincodeCodec> !UnwindSafe for RpcClient<T, C>
Blanket Implementations§
§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more