Caches, Flush and Ping

For performance reasons, most if not all, of the client libraries will buffer outgoing data so that bigger chunks can be written to the network at one time. This may be as simple as a byte buffer that stores a few messages before being pushed to the network.

These buffers do not hold messages forever, generally they are designed to hold messages in high throughput scenarios, while still providing good latency in low throughput situations.

It is the libraries job to make sure messages flow in a high performance manner. But there may be times when an application needs to know that a message has “hit the wire.” In this case, applications can use a flush call to tell the library to move data through the system.

Go

  1. nc, err := nats.Connect("demo.nats.io")
  2. if err != nil {
  3.     log.Fatal(err)
  4. }
  5. defer nc.Close()
  7. // Just to not collide using the demo server with other users.
  8. subject := nats.NewInbox()
  10. if err := nc.Publish(subject, []byte("All is Well")); err != nil {
  11.     log.Fatal(err)
  12. }
  13. // Sends a PING and wait for a PONG from the server, up to the given timeout.
  14. // This gives guarantee that the server has processed the above message.
  15. if err := nc.FlushTimeout(time.Second); err != nil {
  16.     log.Fatal(err)
  17. }

Java

  1. Connection nc = Nats.connect("nats://demo.nats.io:4222");
  3. nc.publish("updates", "All is Well".getBytes(StandardCharsets.UTF_8));
  4. nc.flush(Duration.ofSeconds(1)); // Flush the message queue
  6. nc.close();

JavaScript

  1. const start = Date.now();
  2. nc.flush().then(() => {
  3.   t.log("round trip completed in", Date.now() - start, "ms");
  4. });

Python

  1. nc = NATS()
  3. await nc.connect(servers=["nats://demo.nats.io:4222"])
  5. await nc.publish("updates", b'All is Well')
  7. # Sends a PING and wait for a PONG from the server, up to the given timeout.
  8. # This gives guarantee that the server has processed above message.
  9. await nc.flush(timeout=1)

Ruby

  1. require 'nats/client'
  2. require 'fiber'
  4. NATS.start(servers:["nats://127.0.0.1:4222"]) do |nc|
  5.   nc.subscribe("updates") do |msg|
  6.     puts msg
  7.   end
  9.   nc.publish("updates", "All is Well")
  11.   nc.flush do
  12.     # Sends a PING and wait for a PONG from the server, up to the given timeout.
  13.     # This gives guarantee that the server has processed above message at this point.
  14.   end
  15. end

C

  1. natsConnection      *conn      = NULL;
  2. natsStatus          s          = NATS_OK;
  4. s = natsConnection_ConnectTo(&conn, NATS_DEFAULT_URL);
  6. // Send a request and wait for up to 1 second
  7. if (s == NATS_OK)
  8.     s = natsConnection_PublishString(conn, "foo", "All is Well");
  10. // Sends a PING and wait for a PONG from the server, up to the given timeout.
  11. // This gives guarantee that the server has processed the above message.
  12. if (s == NATS_OK)
  13.     s = natsConnection_FlushTimeout(conn, 1000);
  15. (...)
  17. // Destroy objects that were created
  18. natsConnection_Destroy(conn);

{% endtabs %}

Flush and Ping/Pong

Many of the client libraries use the PING/PONG interaction built into the NATS protocol to ensure that flush pushed all of the buffered messages to the server. When an application calls flush, most libraries will put a PING on the outgoing queue of messages, and wait for the server to respond with a PONG before saying that the flush was successful.

Even though the client may use PING/PONG for flush, pings sent this way do not count towards max outgoing pings.