Struct async_nats::client::Client

pub struct Client { /* private fields */ }

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

impl Client

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());

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.

Examples

let client = async_nats::connect("demo.nats.io").await?;
assert!(client.is_server_compatible(2, 8, 4));

pub async fn publish<S: ToSubject>( &self, subject: S, payload: Bytes ) -> Result<(), PublishError>

Publish a Message to a given subject.

Examples

let client = async_nats::connect("demo.nats.io").await?;
client.publish("events.data", "payload".into()).await?;

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?;

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?;

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?;

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?;

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?;

pub async fn send_request<S: ToSubject>( &self, subject: S, request: Request ) -> Result<Message, RequestError>

Sends the request created by the Request.

Examples

let client = async_nats::connect("demo.nats.io").await?;
let request = async_nats::Request::new().payload("data".into());
let response = client.send_request("service", request).await?;

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?;

pub async fn subscribe<S: ToSubject>( &self, subject: S ) -> Result<Subscriber, SubscribeError>

Subscribes to a subject to receive messages.

Examples

use futures::StreamExt;
let client = async_nats::connect("demo.nats.io").await?;
let mut subscription = client.subscribe("events.>").await?;
while let Some(message) = subscription.next().await {
    println!("received message: {:?}", message);
}

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);
}

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?;

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());

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ServiceExt for Client

Available on crate feature service only.

type Output = Pin<Box<dyn Future<Output = Result<Service, Box<dyn Error + Sync + Send>>> + Send>>

fn add_service(&self, config: Config) -> Self::Output

Adds a Service instance.

fn service_builder(&self) -> ServiceBuilder

Returns Service instance builder.