Struct nats::Connection [−][src]
pub struct Connection(_);
Expand description
A NATS connection.
Implementations
pub fn create_stream<S>(&self, stream_config: S) -> Result<StreamInfo> where
StreamConfig: From<S>,
pub fn create_stream<S>(&self, stream_config: S) -> Result<StreamInfo> where
StreamConfig: From<S>,
Create a JetStream
stream.
Requires the jetstream
feature.
Update a JetStream
stream.
Requires the jetstream
feature.
pub fn stream_names(&self) -> PagedIterator<'_, String>ⓘNotable traits for PagedIterator<'a, T>impl<'a, T> Iterator for PagedIterator<'a, T> where
T: DeserializeOwned + Debug, type Item = Result<T>;
pub fn stream_names(&self) -> PagedIterator<'_, String>ⓘNotable traits for PagedIterator<'a, T>impl<'a, T> Iterator for PagedIterator<'a, T> where
T: DeserializeOwned + Debug, type Item = Result<T>;
impl<'a, T> Iterator for PagedIterator<'a, T> where
T: DeserializeOwned + Debug, type Item = Result<T>;
List all JetStream
stream names. If you also want stream information,
use the list_streams
method instead.
Requires the jetstream
feature.
pub fn list_streams(&self) -> PagedIterator<'_, StreamInfo>ⓘNotable traits for PagedIterator<'a, T>impl<'a, T> Iterator for PagedIterator<'a, T> where
T: DeserializeOwned + Debug, type Item = Result<T>;
pub fn list_streams(&self) -> PagedIterator<'_, StreamInfo>ⓘNotable traits for PagedIterator<'a, T>impl<'a, T> Iterator for PagedIterator<'a, T> where
T: DeserializeOwned + Debug, type Item = Result<T>;
impl<'a, T> Iterator for PagedIterator<'a, T> where
T: DeserializeOwned + Debug, type Item = Result<T>;
List all JetStream
streams.
Requires the jetstream
feature.
pub fn list_consumers<S>(
&self,
stream: S
) -> Result<PagedIterator<'_, ConsumerInfo>> where
S: AsRef<str>,
pub fn list_consumers<S>(
&self,
stream: S
) -> Result<PagedIterator<'_, ConsumerInfo>> where
S: AsRef<str>,
List JetStream
consumers for a stream.
Requires the jetstream
feature.
Query JetStream
stream information.
Requires the jetstream
feature.
Purge JetStream
stream messages.
Requires the jetstream
feature.
Delete message in a JetStream
stream.
Requires the jetstream
feature.
Delete JetStream
stream.
Requires the jetstream
feature.
pub fn create_consumer<S, C>(&self, stream: S, cfg: C) -> Result<Consumer> where
S: AsRef<str>,
ConsumerConfig: From<C>,
pub fn create_consumer<S, C>(&self, stream: S, cfg: C) -> Result<Consumer> where
S: AsRef<str>,
ConsumerConfig: From<C>,
Create a JetStream
consumer.
Requires the jetstream
feature.
Delete a JetStream
consumer.
Requires the jetstream
feature.
pub fn consumer_info<S, C>(
&self,
stream: S,
consumer: C
) -> Result<ConsumerInfo> where
S: AsRef<str>,
C: AsRef<str>,
pub fn consumer_info<S, C>(
&self,
stream: S,
consumer: C
) -> Result<ConsumerInfo> where
S: AsRef<str>,
C: AsRef<str>,
Query JetStream
consumer information.
Requires the jetstream
feature.
Query JetStream
account information.
Requires the jetstream
feature.
Create a queue subscription for the given NATS connection.
Example
let sub = nc.queue_subscribe("foo", "production")?;
Publish a message on the given subject with a reply subject for responses.
Example
let reply = nc.new_inbox(); let rsub = nc.subscribe(&reply)?; nc.publish_request("foo", &reply, "Help me!")?;
Create a new globally unique inbox which can be used for replies.
Example
let reply = nc.new_inbox(); let rsub = nc.subscribe(&reply)?;
Publish a message on the given subject as a request and receive the response.
Example
let resp = nc.request("foo", "Help me?")?;
Publish a message on the given subject as a request and receive the response. This call will return after the timeout duration if no response is received.
Example
let resp = nc.request_timeout("foo", "Help me?", std::time::Duration::from_secs(2))?;
Publish a message on the given subject as a request and allow multiple responses.
Example
for msg in nc.request_multi("foo", "Help")?.iter().take(1) {}
Flush a NATS connection by sending a PING
protocol and waiting for the
responding PONG
. Will fail with TimedOut
if the server does not
respond with in 10 seconds. Will fail with NotConnected
if the
server is not currently connected. Will fail with BrokenPipe
if
the connection to the server is lost.
Example
nc.flush()?;
Flush a NATS connection by sending a PING
protocol and waiting for the
responding PONG
. Will fail with TimedOut
if the server takes
longer than this duration to respond. Will fail with NotConnected
if the server is not currently connected. Will fail with
BrokenPipe
if the connection to the server is lost.
Example
nc.flush()?;
Close a NATS connection. All clones of
this Connection
will also be closed,
as the backing IO threads are shared.
If the client is currently connected to a server, the outbound write buffer will be flushed in the process of shutting down.
Example
nc.close();
Calculates the round trip time between this client and the server,
if the server is currently connected. Fails with TimedOut
if
the server takes more than 10 seconds to respond.
Example
println!("server rtt: {:?}", nc.rtt());
Returns the client IP as known by the server. Supported as of server version 2.1.6.
Example
println!("ip: {:?}", nc.client_ip());
Returns the client ID as known by the most recently connected server.
Example
println!("ip: {:?}", nc.client_id());
Send an unsubscription for all subs then flush the connection, allowing any unprocessed messages to be handled by a handler function if one is configured.
After the flush returns, we know that a round-trip to the server has happened after it received our unsubscription, so we shut down the subscriber afterwards.
A similar method exists for the Subscription
struct which will drain
a single Subscription
without shutting down the entire connection
afterward.
Example
let received = Arc::new(AtomicBool::new(false)); let received_2 = received.clone(); nc.subscribe("test.drain")?.with_handler(move |m| { received_2.store(true, SeqCst); Ok(()) }); nc.publish("test.drain", "message")?; nc.drain()?; assert!(received.load(SeqCst));
Publish a message which may have a reply subject or headers set.
Example
let sub = nc.subscribe("foo.headers")?; let headers = [("header1", "value1"), ("header2", "value2")].iter().collect(); let reply_to = None; nc.publish_with_reply_or_headers("foo.headers", reply_to, Some(&headers), "Hello World!")?; nc.flush()?; let message = sub.next_timeout(std::time::Duration::from_secs(2)).unwrap(); assert_eq!(message.headers.unwrap().len(), 2);
Returns the maximum payload size the most recently connected server will accept.
Example
let nc = nats::connect("demo.nats.io")?; println!("max payload: {:?}", nc.max_payload());
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Connection
impl Send for Connection
impl Sync for Connection
impl Unpin for Connection
impl !UnwindSafe for Connection
Blanket Implementations
Mutably borrows from an owned value. Read more
type Output = T
type Output = T
Should always be Self