Struct async_nats::client::Client
source · pub struct Client { /* private fields */ }
Expand description
Client is a Cloneable
handle to NATS connection.
Client should not be created directly. Instead, one of two methods can be used:
crate::connect and crate::ConnectOptions::connect
Implementations§
source§impl Client
impl Client
sourcepub fn server_info(&self) -> ServerInfo
pub fn server_info(&self) -> ServerInfo
Returns last received info from the server.
§Examples
let client = async_nats::connect("demo.nats.io").await?;
println!("info: {:?}", client.server_info());
sourcepub fn is_server_compatible(&self, major: i64, minor: i64, patch: i64) -> bool
pub fn is_server_compatible(&self, major: i64, minor: i64, patch: i64) -> bool
Returns true if the server version is compatible with the version components.
This has to be used with caution, as it is not guaranteed that the server that client is connected to is the same version that the one that is a JetStream meta/stream/consumer leader, especially across leafnodes.
§Examples
let client = async_nats::connect("demo.nats.io").await?;
assert!(client.is_server_compatible(2, 8, 4));
sourcepub async fn publish<S: ToSubject>(
&self,
subject: S,
payload: Bytes,
) -> Result<(), PublishError>
pub async fn publish<S: ToSubject>( &self, subject: S, payload: Bytes, ) -> Result<(), PublishError>
sourcepub async fn publish_with_headers<S: ToSubject>(
&self,
subject: S,
headers: HeaderMap,
payload: Bytes,
) -> Result<(), PublishError>
pub async fn publish_with_headers<S: ToSubject>( &self, subject: S, headers: HeaderMap, payload: Bytes, ) -> Result<(), PublishError>
Publish a Message with headers to a given subject.
§Examples
use std::str::FromStr;
let client = async_nats::connect("demo.nats.io").await?;
let mut headers = async_nats::HeaderMap::new();
headers.insert(
"X-Header",
async_nats::HeaderValue::from_str("Value").unwrap(),
);
client
.publish_with_headers("events.data", headers, "payload".into())
.await?;
sourcepub async fn publish_with_reply<S: ToSubject, R: ToSubject>(
&self,
subject: S,
reply: R,
payload: Bytes,
) -> Result<(), PublishError>
pub async fn publish_with_reply<S: ToSubject, R: ToSubject>( &self, subject: S, reply: R, payload: Bytes, ) -> Result<(), PublishError>
Publish a Message to a given subject, with specified response subject to which the subscriber can respond. This method does not await for the response.
§Examples
let client = async_nats::connect("demo.nats.io").await?;
client
.publish_with_reply("events.data", "reply_subject", "payload".into())
.await?;
sourcepub async fn publish_with_reply_and_headers<S: ToSubject, R: ToSubject>(
&self,
subject: S,
reply: R,
headers: HeaderMap,
payload: Bytes,
) -> Result<(), PublishError>
pub async fn publish_with_reply_and_headers<S: ToSubject, R: ToSubject>( &self, subject: S, reply: R, headers: HeaderMap, payload: Bytes, ) -> Result<(), PublishError>
Publish a Message to a given subject with headers and specified response subject to which the subscriber can respond. This method does not await for the response.
§Examples
use std::str::FromStr;
let client = async_nats::connect("demo.nats.io").await?;
let mut headers = async_nats::HeaderMap::new();
client
.publish_with_reply_and_headers("events.data", "reply_subject", headers, "payload".into())
.await?;
sourcepub async fn request<S: ToSubject>(
&self,
subject: S,
payload: Bytes,
) -> Result<Message, RequestError>
pub async fn request<S: ToSubject>( &self, subject: S, payload: Bytes, ) -> Result<Message, RequestError>
Sends the request with headers.
§Examples
let client = async_nats::connect("demo.nats.io").await?;
let response = client.request("service", "data".into()).await?;
sourcepub async fn request_with_headers<S: ToSubject>(
&self,
subject: S,
headers: HeaderMap,
payload: Bytes,
) -> Result<Message, RequestError>
pub async fn request_with_headers<S: ToSubject>( &self, subject: S, headers: HeaderMap, payload: Bytes, ) -> Result<Message, RequestError>
Sends the request with headers.
§Examples
let client = async_nats::connect("demo.nats.io").await?;
let mut headers = async_nats::HeaderMap::new();
headers.insert("Key", "Value");
let response = client
.request_with_headers("service", headers, "data".into())
.await?;
sourcepub async fn send_request<S: ToSubject>(
&self,
subject: S,
request: Request,
) -> Result<Message, RequestError>
pub async fn send_request<S: ToSubject>( &self, subject: S, request: Request, ) -> Result<Message, RequestError>
sourcepub fn new_inbox(&self) -> String
pub fn new_inbox(&self) -> String
Create a new globally unique inbox which can be used for replies.
§Examples
let reply = nc.new_inbox();
let rsub = nc.subscribe(reply).await?;
sourcepub async fn subscribe<S: ToSubject>(
&self,
subject: S,
) -> Result<Subscriber, SubscribeError>
pub async fn subscribe<S: ToSubject>( &self, subject: S, ) -> Result<Subscriber, SubscribeError>
sourcepub async fn queue_subscribe<S: ToSubject>(
&self,
subject: S,
queue_group: String,
) -> Result<Subscriber, SubscribeError>
pub async fn queue_subscribe<S: ToSubject>( &self, subject: S, queue_group: String, ) -> Result<Subscriber, SubscribeError>
Subscribes to a subject with a queue group to receive messages.
§Examples
use futures::StreamExt;
let client = async_nats::connect("demo.nats.io").await?;
let mut subscription = client.queue_subscribe("events.>", "queue".into()).await?;
while let Some(message) = subscription.next().await {
println!("received message: {:?}", message);
}
sourcepub async fn flush(&self) -> Result<(), FlushError>
pub async fn flush(&self) -> Result<(), FlushError>
Flushes the internal buffer ensuring that all messages are sent.
§Examples
let client = async_nats::connect("demo.nats.io").await?;
client.flush().await?;
sourcepub fn connection_state(&self) -> State
pub fn connection_state(&self) -> State
Returns the current state of the connection.
§Examples
let client = async_nats::connect("demo.nats.io").await?;
println!("connection state: {}", client.connection_state());
sourcepub async fn force_reconnect(&self) -> Result<(), ReconnectError>
pub async fn force_reconnect(&self) -> Result<(), ReconnectError>
Forces the client to reconnect.
Keep in mind that client will reconnect automatically if the connection is lost and this
method does not have to be used in normal circumstances.
However, if you want to force the client to reconnect, for example to re-trigger
the auth-callback
, or manually rebalance connections, this method can be useful.
This method does not wait for connection to be re-established.
§Examples
let client = async_nats::connect("demo.nats.io").await?;
client.force_reconnect().await?;
Trait Implementations§
source§impl Sink<PublishMessage> for Client
impl Sink<PublishMessage> for Client
source§type Error = Error<PublishErrorKind>
type Error = Error<PublishErrorKind>
source§fn poll_ready(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Result<(), Self::Error>>
fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>
Sink
to receive a value. Read moresource§fn start_send(
self: Pin<&mut Self>,
msg: PublishMessage,
) -> Result<(), Self::Error>
fn start_send( self: Pin<&mut Self>, msg: PublishMessage, ) -> Result<(), Self::Error>
poll_ready
which returned Poll::Ready(Ok(()))
. Read moreAuto Trait Implementations§
impl Freeze for Client
impl !RefUnwindSafe for Client
impl Send for Client
impl Sync for Client
impl Unpin for Client
impl !UnwindSafe for Client
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T, Item> SinkExt<Item> for T
impl<T, Item> SinkExt<Item> for T
source§fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F>
fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F>
source§fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, Item, U, St, F>
fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, Item, U, St, F>
source§fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F>
fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F>
source§fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E>
fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E>
Into
trait. Read moresource§fn buffer(self, capacity: usize) -> Buffer<Self, Item>where
Self: Sized,
fn buffer(self, capacity: usize) -> Buffer<Self, Item>where
Self: Sized,
source§fn flush(&mut self) -> Flush<'_, Self, Item>where
Self: Unpin,
fn flush(&mut self) -> Flush<'_, Self, Item>where
Self: Unpin,
source§fn send(&mut self, item: Item) -> Send<'_, Self, Item>where
Self: Unpin,
fn send(&mut self, item: Item) -> Send<'_, Self, Item>where
Self: Unpin,
source§fn feed(&mut self, item: Item) -> Feed<'_, Self, Item>where
Self: Unpin,
fn feed(&mut self, item: Item) -> Feed<'_, Self, Item>where
Self: Unpin,
source§fn send_all<'a, St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St>
fn send_all<'a, St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St>
source§fn right_sink<Si1>(self) -> Either<Si1, Self>
fn right_sink<Si1>(self) -> Either<Si1, Self>
source§fn poll_ready_unpin(
&mut self,
cx: &mut Context<'_>,
) -> Poll<Result<(), Self::Error>>where
Self: Unpin,
fn poll_ready_unpin(
&mut self,
cx: &mut Context<'_>,
) -> Poll<Result<(), Self::Error>>where
Self: Unpin,
Sink::poll_ready
on Unpin
sink types.source§fn start_send_unpin(&mut self, item: Item) -> Result<(), Self::Error>where
Self: Unpin,
fn start_send_unpin(&mut self, item: Item) -> Result<(), Self::Error>where
Self: Unpin,
Sink::start_send
on Unpin
sink types.