Rust-NATS
Rust-NATS is a Rust client library for the NATS message queue.
The crate is called nats and can be added as a dependency using Cargo:
[dependencies]
nats = "*"Rust -stable, -beta and -nightly are supported.
The library was designed to be robust. It doesn't use any usafe code, it never
calls panic!() and failed commands are automatically retried on different
cluster nodes.
It provides a simple low-level interface that makes it easy to send/receive messages over Rust channels if needed.
Connecting
Single-node client connection:
extern crate nats;
use nats::*;
let client = Client::new("nats://user:[email protected]").unwrap();The username and password are optional.
Connecting to a cluster:
let cluster = vec!("nats://user:[email protected]", "nats://127.0.0.2");
let mut client = nats::Client::new(cluster).unwrap();By default, commands are sent in fire-and-forget mode. In order to wait for an acknowledgment after each command, the synchronous ("verbose") mode can be turned on:
client.set_synchronous(true);The client name can also be customized:
client.set_name("app");Publishing messages
client.publish("subject.test", "test".as_bytes()).unwrap();In order to use NATS for RPC, the Client.make_request() function creates an
ephemeral subject ("inbox"), subscribes to it, schedules the removal of the
subscription after the first received message, publishes the initial request,
and returns the inbox subject name:
let inbox = client.make_request("subject.rpc", "test".as_bytes()).unwrap();Subscribing to subjects
Client.subscribe() adds a subscription to a subject, with an optional group:
let s1 = client.subscribe("subject", None).unwrap();
let s2 = client.subscribe("subject.*", Some("app")).unwrap();With group membership, a given message will be only delivered to one client in the group.
Client.unsubscribe() removes a subscription:
client.unsubscribe(s1).unwrap();Or to remove it after n messages have been received:
client.unsubscribe_after(s1, n).unwrap();Receiving events
Client.wait() waits for a new event, and transparently responds to server
PING requests.
let event = client.wait();This returns an Event structure:
pub struct Event {
pub subject: String,
pub channel: Channel,
pub msg: Vec<u8>,
pub inbox: Option<String>
}Alternatively, events can be received using an iterator:
for event in client.events() {
...
}TLS
Build and set TLSConfig before connect:
use std::fs::File;
use std::io::Read;
use self::nats::openssl; // use re-exported openssl crate
// Load root certificate
let mut file = File::open("./configs/certs/ca.pem").unwrap();
let mut contents = vec![];
file.read_to_end(&mut contents).unwrap();
let cert = openssl::x509::X509::from_pem(&contents).unwrap();
// Load client certificate
let mut file = File::open("./configs/certs/client.crt").unwrap();
let mut contents = vec![];
file.read_to_end(&mut contents).unwrap();
let client_cert = openssl::x509::X509::from_pem(&contents).unwrap();
// Load client key
let mut file = File::open("./configs/certs/client.key").unwrap();
let mut contents = vec![];
file.read_to_end(&mut contents).unwrap();
let client_key = openssl::pkey::PKey::private_key_from_pem(&contents).unwrap();
let mut builder = nats::TlsConfigBuilder::new().unwrap();
// Set root certificate
builder.add_root_certificate(cert).unwrap();
// Set client certificate
builder.add_client_certificate(&client_cert, &client_key).unwrap();
let tls_config = builder.build();
let mut client = nats::Client::new("nats://localhost:4222").unwrap();
client.set_tls_config(tls_config);