Struct ServiceClient 

pub struct ServiceClient<T> { /* private fields */ }

Client for this service.

Generic over T: ClientTransport. For gRPC (HTTP/2), use Http2Connection — it has honest poll_ready and composes with tower::balance for multi-connection load balancing. For Connect over HTTP/1.1 (or unknown protocol), use HttpClient.

Example (gRPC / HTTP/2)

use connectrpc::client::{Http2Connection, ClientConfig};
use connectrpc::Protocol;

let uri: http::Uri = "http://localhost:8080".parse()?;
let conn = Http2Connection::connect_plaintext(uri.clone()).await?.shared(1024);
let config = ClientConfig::new(uri).with_protocol(Protocol::Grpc);

let client = ServiceClient::new(conn, config);
let response = client.subscribe(request).await?;

Example (Connect / HTTP/1.1 or ALPN)

use connectrpc::client::{HttpClient, ClientConfig};

let http = HttpClient::plaintext();  // cleartext http:// only
let config = ClientConfig::new("http://localhost:8080".parse()?);

let client = ServiceClient::new(http, config);
let response = client.subscribe(request).await?;

Working with the response

Unary calls return UnaryResponse<OwnedView<FooView>>. The OwnedView derefs to the view, so field access is zero-copy:

let resp = client.subscribe(request).await?.into_view();
let name: &str = resp.name;  // borrow into the response buffer

If you need the owned struct (e.g. to store or pass by value), use into_owned():

let owned = client.subscribe(request).await?.into_owned();

Implementations

impl<T> ServiceClient<T>

where T: ClientTransport, <T::ResponseBody as Body>::Error: Display,

pub fn new(transport: T, config: ClientConfig) -> Self

Create a new client with the given transport and configuration.

pub fn config(&self) -> &ClientConfig

Get the client configuration.

pub fn config_mut(&mut self) -> &mut ClientConfig

Get a mutable reference to the client configuration.

pub async fn subscribe( &self, request: SubscribeRequest, ) -> Result<ServerStream<T::ResponseBody, SubscribeResponseView<'static>>, ConnectError>

Call the Subscribe RPC. Sends a request to /sql.v1.Service/Subscribe.

pub async fn subscribe_with_options( &self, request: SubscribeRequest, options: CallOptions, ) -> Result<ServerStream<T::ResponseBody, SubscribeResponseView<'static>>, ConnectError>

Call the Subscribe RPC with explicit per-call options. Options override ClientConfig defaults.

pub async fn query( &self, request: QueryRequest, ) -> Result<UnaryResponse<OwnedView<QueryResponseView<'static>>>, ConnectError>

Call the Query RPC. Sends a request to /sql.v1.Service/Query.

pub async fn query_with_options( &self, request: QueryRequest, options: CallOptions, ) -> Result<UnaryResponse<OwnedView<QueryResponseView<'static>>>, ConnectError>

Call the Query RPC with explicit per-call options. Options override ClientConfig defaults.

pub async fn tables( &self, request: TablesRequest, ) -> Result<UnaryResponse<OwnedView<TablesResponseView<'static>>>, ConnectError>

Call the Tables RPC. Sends a request to /sql.v1.Service/Tables.

pub async fn tables_with_options( &self, request: TablesRequest, options: CallOptions, ) -> Result<UnaryResponse<OwnedView<TablesResponseView<'static>>>, ConnectError>

Call the Tables RPC with explicit per-call options. Options override ClientConfig defaults.

Trait Implementations

impl<T: Clone> Clone for ServiceClient<T>

fn clone(&self) -> ServiceClient<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.