Including a Reply Subject

The optional reply-to field when publishing a message can be used on the receiving side to respond. The reply-to subject is often called an inbox, and most libraries may provide a method for generating unique inbox subjects. Most libraries also provide for the request-reply pattern with a single call. For example to send a request to the subject time, with no content for the messages, you might:

Go

  1. nc, err := nats.Connect("demo.nats.io")
  2. if err != nil {
  3.     log.Fatal(err)
  4. }
  5. defer nc.Close()
  7. // Create a unique subject name for replies.
  8. uniqueReplyTo := nats.NewInbox()
  10. // Listen for a single response
  11. sub, err := nc.SubscribeSync(uniqueReplyTo)
  12. if err != nil {
  13.     log.Fatal(err)
  14. }
  16. // Send the request.
  17. // If processing is synchronous, use Request() which returns the response message.
  18. if err := nc.PublishRequest("time", uniqueReplyTo, nil); err != nil {
  19.     log.Fatal(err)
  20. }
  22. // Read the reply
  23. msg, err := sub.NextMsg(time.Second)
  24. if err != nil {
  25.     log.Fatal(err)
  26. }
  28. // Use the response
  29. log.Printf("Reply: %s", msg.Data)

Java

  1. Connection nc = Nats.connect("nats://demo.nats.io:4222");
  3. // Create a unique subject name
  4. String uniqueReplyTo = NUID.nextGlobal();
  6. // Listen for a single response
  7. Subscription sub = nc.subscribe(uniqueReplyTo);
  8. sub.unsubscribe(1);
  10. // Send the request
  11. nc.publish("time", uniqueReplyTo, null);
  13. // Read the reply
  14. Message msg = sub.nextMessage(Duration.ofSeconds(1));
  16. // Use the response
  17. System.out.println(new String(msg.getData(), StandardCharsets.UTF_8));
  19. // Close the connection
  20. nc.close();

JavaScript

  1. // set up a subscription to process the request
  2. const sc = StringCodec();
  3. nc.subscribe("time", {
  4.   callback: (_err, msg) => {
  5.     msg.respond(sc.encode(new Date().toLocaleTimeString()));
  6.   },
  7. });
  9. // create a subscription subject that the responding send replies to
  10. const inbox = createInbox();
  11. const sub = nc.subscribe(inbox, {
  12.   max: 1,
  13.   callback: (_err, msg) => {
  14.     t.log(`the time is ${sc.decode(msg.data)}`);
  15.   },
  16. });
  18. nc.publish("time", Empty, { reply: inbox });

Python

  1. nc = NATS()
  3. future = asyncio.Future()
  5. async def sub(msg):
  6.   nonlocal future
  7.   future.set_result(msg)
  9. await nc.connect(servers=["nats://demo.nats.io:4222"])
  10. await nc.subscribe("time", cb=sub)
  12. unique_reply_to = nc.new_inbox()
  13. await nc.publish("time", b'', unique_reply_to)
  15. # Use the response
  16. msg = await asyncio.wait_for(future, 1)
  17. print("Reply:", msg)

Ruby

  1. require 'nats/client'
  2. require 'fiber'
  4. NATS.start(servers:["nats://127.0.0.1:4222"]) do |nc|
  5.   Fiber.new do
  6.     f = Fiber.current
  8.     nc.subscribe("time") do |msg, reply|
  9.       f.resume msg
  10.     end
  12.     nc.publish("time", 'example', NATS.create_inbox)
  14.     # Use the response
  15.     msg = Fiber.yield
  16.     puts "Reply: #{msg}"
  18.   end.resume
  19. end

C

  1. natsConnection      *conn      = NULL;
  2. natsStatus          s          = NATS_OK;
  4. s = natsConnection_ConnectTo(&conn, NATS_DEFAULT_URL);
  5. // Publish a message and provide a reply subject
  6. if (s == NATS_OK)
  7.     s = natsConnection_PublishRequestString(conn, "request", "reply", "this is the request");
  9. (...)
  11. // Destroy objects that were created
  12. natsConnection_Destroy(conn);

{% endtabs %}