public void TestPublishNoAck() { Context.RunInJsServer(c => { CreateDefaultTestStream(c); JetStreamOptions jso = JetStreamOptions.Builder().WithPublishNoAck(true).Build(); IJetStream js = c.CreateJetStreamContext(jso); string data1 = "noackdata1"; string data2 = "noackdata2"; PublishAck pa = js.Publish(SUBJECT, Encoding.ASCII.GetBytes(data1)); Assert.Null(pa); Task <PublishAck> task = js.PublishAsync(SUBJECT, Encoding.ASCII.GetBytes(data2)); Assert.Null(task.Result); IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(SUBJECT); Msg m = sub.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal(data1, Encoding.ASCII.GetString(m.Data)); m = sub.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal(data2, Encoding.ASCII.GetString(m.Data)); }); }
private void _testPushDurableSubSync(string durable, string deliverSubject, IConnection nc, PushSyncSubSupplier supplier) { IJetStreamPushSyncSubscription sub = supplier.Invoke(); AssertSubscription(sub, STREAM, durable, deliverSubject, false); // read what is available IList <Msg> messages = ReadMessagesAck(sub); int total = messages.Count; ValidateRedAndTotal(5, messages.Count, 5, total); // read again, nothing should be there messages = ReadMessagesAck(sub); total += messages.Count; ValidateRedAndTotal(0, messages.Count, 5, total); sub.Unsubscribe(); nc.Flush(1000); // flush outgoing communication with/to the server // re-subscribe sub = supplier.Invoke(); nc.Flush(1000); // flush outgoing communication with/to the server // read again, nothing should be there messages = ReadMessagesAck(sub); total += messages.Count; ValidateRedAndTotal(0, messages.Count, 5, total); sub.Unsubscribe(); nc.Flush(1000); // flush outgoing communication with/to the server }
public void TestQueueSubWorkflow() { Context.RunInJsServer(c => { // create the stream. CreateDefaultTestStream(c); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); // Setup the subscribers // - the PushSubscribeOptions can be re-used since all the subscribers are the same // - use a concurrent integer to track all the messages received // - have a list of subscribers and threads so I can track them PushSubscribeOptions pso = PushSubscribeOptions.Builder().WithDurable(DURABLE).Build(); InterlockedLong allReceived = new InterlockedLong(); IList <JsQueueSubscriber> subscribers = new List <JsQueueSubscriber>(); IList <Thread> subThreads = new List <Thread>(); for (int id = 1; id <= 3; id++) { // setup the subscription IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(SUBJECT, QUEUE, pso); // create and track the runnable JsQueueSubscriber qs = new JsQueueSubscriber(100, js, sub, allReceived); subscribers.Add(qs); // create, track and start the thread Thread t = new Thread(qs.Run); subThreads.Add(t); t.Start(); } c.Flush(DefaultTimeout); // flush outgoing communication with/to the server // create and start the publishing Thread pubThread = new Thread(new JsPublisher(js, 100).Run); pubThread.Start(); // wait for all threads to finish pubThread.Join(5000); foreach (Thread t in subThreads) { t.Join(5000); } ISet <string> uniqueDatas = new HashSet <string>(); // count int count = 0; foreach (JsQueueSubscriber qs in subscribers) { int r = qs.received; Assert.True(r > 0); count += r; foreach (string s in qs.datas) { Assert.True(uniqueDatas.Add(s)); } } Assert.Equal(100, count); }); }
public JsQueueSubscriber(int id, int msgCount, IJetStream js, IJetStreamPushSyncSubscription sub, InterlockedLong allReceived) { this.id = id; this.msgCount = msgCount; this.sub = sub; this.allReceived = allReceived; received = 0; datas = new List <string>(); }
public static void Main(string[] args) { ArgumentHelper helper = new ArgumentHelperBuilder("JetStream Publish Vs Core Publish", args, Usage) .DefaultStream("js-or-core-stream") .DefaultSubject("js-or-core-subject") .Build(); try { using (IConnection c = new ConnectionFactory().CreateConnection(helper.MakeOptions())) { // Create a JetStreamManagement context. IJetStreamManagement jsm = c.CreateJetStreamManagementContext(); // Use the utility to create a stream stored in memory. JsUtils.CreateStreamExitWhenExists(jsm, helper.Stream, helper.Subject); // create a JetStream context IJetStream js = c.CreateJetStreamContext(); // Regular Nats publish is straightforward c.Publish(helper.Subject, Encoding.ASCII.GetBytes("regular-message")); // A JetStream publish allows you to set publish options // that a regular publish does not. // A JetStream publish returns an ack of the publish. There // is no ack in a regular message. Msg msg = new Msg(helper.Subject, Encoding.ASCII.GetBytes("js-message")); PublishAck pa = js.Publish(msg); Console.WriteLine(pa); // set up the subscription IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(helper.Subject); c.Flush(500); // flush outgoing communication with/to the server // Both messages appear in the stream as JetStream messages msg = sub.NextMessage(500); msg.Ack(); Console.WriteLine("Received Data: '" + Encoding.ASCII.GetString(msg.Data) + "'\n Meta: " + msg.MetaData); msg = sub.NextMessage(500); msg.Ack(); Console.WriteLine("Received Data: '" + Encoding.ASCII.GetString(msg.Data) + "'\n Meta: " + msg.MetaData); // delete the stream since we are done with it. jsm.DeleteStream(helper.Stream); } } catch (Exception ex) { helper.ReportException(ex); } }
public void TestPushSyncFlowControl() { InterlockedInt fcps = new InterlockedInt(); Action <Options> optionsModifier = opts => { opts.FlowControlProcessedEventHandler = (sender, args) => { fcps.Increment(); }; }; Context.RunInJsServer(new TestServerInfo(TestSeedPorts.AutoPort.Increment()), optionsModifier, c => { // create the stream. CreateDefaultTestStream(c); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); byte[] data = new byte[8192]; int MSG_COUNT = 1000; for (int x = 100_000; x < MSG_COUNT + 100_000; x++) { byte[] fill = Encoding.ASCII.GetBytes("" + x); Array.Copy(fill, 0, data, 0, 6); js.Publish(new Msg(SUBJECT, data)); } InterlockedInt count = new InterlockedInt(); HashSet <string> set = new HashSet <string>(); ConsumerConfiguration cc = ConsumerConfiguration.Builder().WithFlowControl(1000).Build(); PushSubscribeOptions pso = PushSubscribeOptions.Builder().WithConfiguration(cc).Build(); IJetStreamPushSyncSubscription ssub = js.PushSubscribeSync(SUBJECT, pso); for (int x = 0; x < MSG_COUNT; x++) { Msg msg = ssub.NextMessage(1000); byte[] fill = new byte[6]; Array.Copy(msg.Data, 0, fill, 0, 6); string id = Encoding.ASCII.GetString(fill); if (set.Add(id)) { count.Increment(); } msg.Ack(); } Assert.Equal(MSG_COUNT, count.Read()); Assert.True(fcps.Read() > 0); }); }
public void TestJetStreamPushEphemeral(string deliverSubject) { Context.RunInJsServer(c => { // create the stream. CreateDefaultTestStream(c); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); // publish some messages JsPublish(js, SUBJECT, 1, 5); // Build our subscription options. PushSubscribeOptions options = PushSubscribeOptions.Builder() .WithDeliverSubject(deliverSubject) .Build(); // Subscription 1 IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(SUBJECT, options); AssertSubscription(sub, STREAM, null, deliverSubject, false); c.Flush(DefaultTimeout); // flush outgoing communication with/to the server IList <Msg> messages1 = ReadMessagesAck(sub); int total = messages1.Count; ValidateRedAndTotal(5, messages1.Count, 5, total); // read again, nothing should be there IList <Msg> messages0 = ReadMessagesAck(sub); total += messages0.Count; ValidateRedAndTotal(0, messages0.Count, 5, total); sub.Unsubscribe(); // Subscription 2 sub = js.PushSubscribeSync(SUBJECT, options); c.Flush(DefaultTimeout); // flush outgoing communication with/to the server // read what is available, same messages IList <Msg> messages2 = ReadMessagesAck(sub); total = messages2.Count; ValidateRedAndTotal(5, messages2.Count, 5, total); // read again, nothing should be there messages0 = ReadMessagesAck(sub); total += messages0.Count; ValidateRedAndTotal(0, messages0.Count, 5, total); AssertSameMessages(messages1, messages2); }); }
public void TestPublishVarieties() { Context.RunInJsServer(c => { CreateDefaultTestStream(c); IJetStream js = c.CreateJetStreamContext(); PublishAck pa = js.Publish(SUBJECT, DataBytes(1)); AssertPublishAck(pa, 1); Msg msg = new Msg(SUBJECT, DataBytes(2)); pa = js.Publish(msg); AssertPublishAck(pa, 2); PublishOptions po = PublishOptions.Builder().Build(); pa = js.Publish(SUBJECT, DataBytes(3), po); AssertPublishAck(pa, 3); msg = new Msg(SUBJECT, DataBytes(4)); pa = js.Publish(msg, po); AssertPublishAck(pa, 4); pa = js.Publish(SUBJECT, null); AssertPublishAck(pa, 5); msg = new Msg(SUBJECT); pa = js.Publish(msg); AssertPublishAck(pa, 6); pa = js.Publish(SUBJECT, null, po); AssertPublishAck(pa, 7); msg = new Msg(SUBJECT); pa = js.Publish(msg, po); AssertPublishAck(pa, 8); IJetStreamPushSyncSubscription s = js.PushSubscribeSync(SUBJECT); AssertNextMessage(s, Data(1)); AssertNextMessage(s, Data(2)); AssertNextMessage(s, Data(3)); AssertNextMessage(s, Data(4)); AssertNextMessage(s, null); // 5 AssertNextMessage(s, null); // 6 AssertNextMessage(s, null); // 7 AssertNextMessage(s, null); // 8 // bad subject Assert.Throws <NATSNoRespondersException>(() => js.Publish(Subject(999), null)); }); }
private void AssertNextMessage(IJetStreamPushSyncSubscription s, string data) { Msg m = s.NextMessage(DefaultTimeout); Assert.NotNull(m); if (data == null) { Assert.NotNull(m.Data); Assert.Empty(m.Data); } else { Assert.Equal(data, Encoding.ASCII.GetString(m.Data)); } }
public void TestOrderedConsumerSync() { Console.SetOut(new ConsoleWriter(output)); Context.RunInJsServer(c => { // Setup IJetStream js = c.CreateJetStreamContext(); string subject = Subject(111); CreateMemoryStream(c, Stream(111), subject); // Get this in place before any subscriptions are made JetStream.PushMessageManagerFactoryImpl = (conn, so, cc, queueMode, syncMode) => new OrderedTestDropSimulator(conn, so, cc, queueMode, syncMode); // The options will be used in various ways PushSubscribeOptions pso = PushSubscribeOptions.Builder().WithOrdered(true).Build(); // Test queue exception NATSJetStreamClientException e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(subject, QUEUE, pso)); Assert.Contains(JsSubOrderedNotAllowOnQueues.Id, e.Message); // Setup sync subscription IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(subject, pso); Thread.Sleep(1000); // Published messages will be intercepted by the OrderedTestDropSimulator JsPublish(js, subject, 101, 6); ulong streamSeq = 1; while (streamSeq < 7) { Msg m = sub.NextMessage(1000); if (m != null) { Assert.Equal(streamSeq, m.MetaData.StreamSequence); Assert.Equal(ExpectedConSeqNums[streamSeq - 1], m.MetaData.ConsumerSequence); ++streamSeq; } } sub.Unsubscribe(); EnsureNotBound(sub); }); }
private void VisitSubject(string subject, DeliverPolicy deliverPolicy, bool headersOnly, bool ordered, Action <Msg> action) { PushSubscribeOptions pso = PushSubscribeOptions.Builder() .WithOrdered(ordered) .WithConfiguration( ConsumerConfiguration.Builder() .WithAckPolicy(AckPolicy.None) .WithDeliverPolicy(deliverPolicy) .WithHeadersOnly(headersOnly) .Build()) .Build(); IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(subject, pso); try { bool lastTimedOut = false; ulong pending = sub.GetConsumerInformation().CalculatedPending; while (pending > 0) // no need to loop if nothing pending { try { Msg m = sub.NextMessage(js.Timeout); action.Invoke(m); if (--pending == 0) { return; } lastTimedOut = false; } catch (NATSTimeoutException) { if (lastTimedOut) { return; // two timeouts in a row is enough } lastTimedOut = true; } } } finally { sub.Unsubscribe(); } }
public void TestGetConsumerInfoFromSubscription() { Context.RunInJsServer(c => { CreateDefaultTestStream(c); IJetStream js = c.CreateJetStreamContext(); IJetStreamPushSyncSubscription psync = js.PushSubscribeSync(SUBJECT); ConsumerInfo ci = psync.GetConsumerInformation(); Assert.Equal(STREAM, ci.Stream); PullSubscribeOptions pso = PullSubscribeOptions.Builder().WithDurable(DURABLE).Build(); IJetStreamPullSubscription pull = js.PullSubscribe(SUBJECT, pso); ci = pull.GetConsumerInformation(); Assert.Equal(STREAM, ci.Stream); }); }
public void TestDontAutoAckIfUserAcks() { string mockAckReply = "mock-ack-reply."; Context.RunInJsServer(c => { CreateMemoryStream(c, STREAM, SUBJECT, mockAckReply + "*"); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); // publish some messages JsPublish(js, SUBJECT, 2); // 1. auto ack true CountdownEvent latch = new CountdownEvent(2); bool flag = true; // create our message handler, does not ack void Handler(object sender, MsgHandlerEventArgs args) { if (flag) { args.Message.Reply = mockAckReply + "user"; args.Message.Ack(); flag = false; } args.Message.Reply = mockAckReply + "system"; latch.Signal(); } // subscribe using the handler, auto ack true js.PushSubscribeAsync(SUBJECT, Handler, true); // wait for messages to arrive using the countdown latch. latch.Wait(); IJetStreamPushSyncSubscription ssub = js.PushSubscribeSync(mockAckReply + "*"); Msg m = ssub.NextMessage(1000); Assert.Equal(mockAckReply + "user", m.Subject); m = ssub.NextMessage(1000); Assert.Equal(mockAckReply + "system", m.Subject); }); }
public void TestPublishAsyncVarieties() { Context.RunInJsServer(c => { CreateDefaultTestStream(c); IJetStream js = c.CreateJetStreamContext(); IList <Task <PublishAck> > tasks = new List <Task <PublishAck> >(); tasks.Add(js.PublishAsync(SUBJECT, DataBytes(1))); Msg msg = new Msg(SUBJECT, DataBytes(2)); tasks.Add(js.PublishAsync(msg)); PublishOptions po = PublishOptions.Builder().Build(); tasks.Add(js.PublishAsync(SUBJECT, DataBytes(3), po)); msg = new Msg(SUBJECT, DataBytes(4)); tasks.Add(js.PublishAsync(msg, po)); IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(SUBJECT); IList <Msg> list = ReadMessagesAck(sub); AssertContainsMessagesExact(list, 4); IList <ulong> seqnos = new List <ulong> { 1, 2, 3, 4 }; foreach (var task in tasks) { AssertContainsPublishAck(task.Result, seqnos); } AssertTaskException(js.PublishAsync(Subject(999), null)); AssertTaskException(js.PublishAsync(new Msg(Subject(999)))); PublishOptions pox = PublishOptions.Builder().WithExpectedLastMsgId(MessageId(999)).Build(); AssertTaskException(js.PublishAsync(Subject(999), null, pox)); AssertTaskException(js.PublishAsync(new Msg(Subject(999)), pox)); }); }
public void TestMessageWithHeadersOnly() { Context.RunInJsServer(c => { // create the stream. CreateDefaultTestStream(c); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); MsgHeader h = new MsgHeader(); h["foo"] = "bar"; js.Publish(new Msg(SUBJECT, h, DataBytes(1))); // Build our subscription options. PushSubscribeOptions options = ConsumerConfiguration.Builder() .WithHeadersOnly(true).BuildPushSubscribeOptions(); IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(SUBJECT, options); c.Flush(DefaultTimeout); // flush outgoing communication with/to the server Msg m = sub.NextMessage(1000); Assert.Empty(m.Data); Assert.True(m.HasHeaders); Assert.Equal("bar", m.Header["foo"]); Assert.Equal("6", m.Header[JetStreamConstants.MsgSizeHeader]); sub.Unsubscribe(); // without headers only sub = js.PushSubscribeSync(SUBJECT); c.Flush(DefaultTimeout); // flush outgoing communication with/to the server m = sub.NextMessage(1000); Assert.Equal(6, m.Data.Length); Assert.True(m.HasHeaders); Assert.Equal("bar", m.Header["foo"]); Assert.Null(m.Header[JetStreamConstants.MsgSizeHeader]); }); }
public void TestAckReplySyncCoverage() { Context.RunInJsServer(c => { // create the stream. CreateDefaultTestStream(c); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(SUBJECT); c.Flush(DefaultTimeout); // flush outgoing communication with/to the server JsPublish(js, SUBJECT, "COVERAGE", 1); Msg message = sub.NextMessage(1000); Assert.NotNull(message); message.Reply = "$JS.ACK.stream.LS0k4eeN.1.1.1.1627472530542070600.0"; Assert.Throws <NATSNoRespondersException>(() => message.AckSync(1000)); }); }
public static void Main(string[] args) { ArgumentHelper helper = new ArgumentHelperBuilder("NATS JetStream Push Subscribe Bind Durable", args, Usage) .DefaultStream("example-stream") .DefaultSubject("example-subject") .DefaultDurable("bind-durable") .DefaultDeliverSubject("bind-deliver") .DefaultCount(0, true) // true indicated 0 means unlimited .Build(); int count = helper.Count < 1 ? int.MaxValue : helper.Count; try { using (IConnection c = new ConnectionFactory().CreateConnection(helper.MakeOptions())) { // The stream (and data) must exist JsUtils.ExitIfStreamNotExists(c, helper.Stream); // The durable consumer must already exist. Usually it would be made in configuration // or via the NATS CLI but we are making it here. // Important: The consumer must have a deliver subject when made this way or it will be // understood to be a pull consumer by the server. // NOTE: If you ran this example already, the consumer will have been created // This is not a problem if it is exactly the same. Most ConsumerConfiguration // properties are not modifiable once created. ConsumerConfiguration cc = ConsumerConfiguration.Builder() .WithDurable(helper.Durable) .WithDeliverSubject(helper.DeliverSubject) .Build(); c.CreateJetStreamManagementContext().AddOrUpdateConsumer(helper.Stream, cc); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); // bind subscribe to the stream - either variety will work // V1. Version designed specifically for this purpose. PushSubscribeOptions so = PushSubscribeOptions.BindTo(helper.Stream, helper.Durable); // V2. optional long form // PushSubscribeOptions so = PushSubscribeOptions.Builder() // .WithBind(true) // .WithStream(helper.Stream) // .WithDurable(helper.Durable) // .Build(); // Subscribe synchronously, then just wait for messages. IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(helper.Subject, so); c.Flush(5000); int red = 0; while (count > 0) { try { Msg msg = sub.NextMessage(1000); Console.WriteLine("\nMessage Received:"); if (msg.HasHeaders) { Console.WriteLine(" Headers:"); foreach (string key in msg.Header.Keys) { foreach (string value in msg.Header.GetValues(key)) { Console.WriteLine($" {key}: {value}"); } } } Console.WriteLine(" Subject: {0}\n Data: {1}\n", msg.Subject, Encoding.UTF8.GetString(msg.Data)); Console.WriteLine(" " + msg.MetaData); // Because this is a synchronous subscriber, there's no auto-ack. // The default Consumer Configuration AckPolicy is Explicit // so we need to ack the message or it'll be redelivered. msg.Ack(); ++red; --count; } catch (NATSTimeoutException) // timeout means there are no messages available { count = 0; // ran out of messages } } Console.WriteLine("\n" + red + " message(s) were received.\n"); sub.Unsubscribe(); c.Flush(5000); } } catch (Exception ex) { helper.ReportException(ex); } }
public void TestDeliveryPolicy() { Context.RunInJsServer(c => { IJetStreamManagement jsm = c.CreateJetStreamManagementContext(); IJetStream js = c.CreateJetStreamContext(); CreateMemoryStream(jsm, STREAM, SUBJECT_STAR); string subjectA = SubjectDot("A"); string subjectB = SubjectDot("B"); js.Publish(subjectA, DataBytes(1)); js.Publish(subjectA, DataBytes(2)); Thread.Sleep(1500); js.Publish(subjectA, DataBytes(3)); js.Publish(subjectB, DataBytes(91)); js.Publish(subjectB, DataBytes(92)); // DeliverPolicy.All PushSubscribeOptions pso = PushSubscribeOptions.Builder() .WithConfiguration(ConsumerConfiguration.Builder().WithDeliverPolicy(DeliverPolicy.All).Build()) .Build(); IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(subjectA, pso); Msg m1 = sub.NextMessage(1000); AssertMessage(m1, 1); Msg m2 = sub.NextMessage(1000); AssertMessage(m2, 2); Msg m3 = sub.NextMessage(1000); AssertMessage(m3, 3); // DeliverPolicy.Last pso = PushSubscribeOptions.Builder() .WithConfiguration(ConsumerConfiguration.Builder().WithDeliverPolicy(DeliverPolicy.Last).Build()) .Build(); sub = js.PushSubscribeSync(subjectA, pso); Msg m = sub.NextMessage(1000); AssertMessage(m, 3); AssertNoMoreMessages(sub); // DeliverPolicy.New - No new messages between subscribe and next message pso = PushSubscribeOptions.Builder() .WithConfiguration(ConsumerConfiguration.Builder().WithDeliverPolicy(DeliverPolicy.New).Build()) .Build(); sub = js.PushSubscribeSync(subjectA, pso); AssertNoMoreMessages(sub); // DeliverPolicy.New - New message between subscribe and next message sub = js.PushSubscribeSync(subjectA, pso); js.Publish(subjectA, DataBytes(4)); m = sub.NextMessage(1000); AssertMessage(m, 4); // DeliverPolicy.ByStartSequence pso = PushSubscribeOptions.Builder() .WithConfiguration(ConsumerConfiguration.Builder() .WithDeliverPolicy(DeliverPolicy.ByStartSequence) .WithStartSequence(3) .Build()) .Build(); sub = js.PushSubscribeSync(subjectA, pso); m = sub.NextMessage(1000); AssertMessage(m, 3); m = sub.NextMessage(1000); AssertMessage(m, 4); // DeliverPolicy.ByStartTime pso = PushSubscribeOptions.Builder() .WithConfiguration(ConsumerConfiguration.Builder() .WithDeliverPolicy(DeliverPolicy.ByStartTime) .WithStartTime(m3.MetaData.Timestamp.AddSeconds(-1)) .Build()) .Build(); sub = js.PushSubscribeSync(subjectA, pso); m = sub.NextMessage(1000); AssertMessage(m, 3); m = sub.NextMessage(1000); AssertMessage(m, 4); // DeliverPolicy.LastPerSubject pso = PushSubscribeOptions.Builder() .WithConfiguration(ConsumerConfiguration.Builder() .WithDeliverPolicy(DeliverPolicy.LastPerSubject) .WithFilterSubject(subjectA) .Build()) .Build(); sub = js.PushSubscribeSync(subjectA, pso); m = sub.NextMessage(1000); AssertMessage(m, 4); // DeliverPolicy.ByStartSequence with a deleted record PublishAck pa4 = js.Publish(subjectA, DataBytes(4)); PublishAck pa5 = js.Publish(subjectA, DataBytes(5)); js.Publish(subjectA, DataBytes(6)); jsm.DeleteMessage(STREAM, pa4.Seq); jsm.DeleteMessage(STREAM, pa5.Seq); pso = ConsumerConfiguration.Builder() .WithDeliverPolicy(DeliverPolicy.ByStartSequence) .WithStartSequence(pa4.Seq) .BuildPushSubscribeOptions(); sub = js.PushSubscribeSync(subjectA, pso); m = sub.NextMessage(1000); AssertMessage(m, 6); }); }
public void TestAcks() { Context.RunInJsServer(c => { // create the stream. CreateDefaultTestStream(c); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); ConsumerConfiguration cc = ConsumerConfiguration.Builder().WithAckWait(1500).Build(); // Build our subscription options. PushSubscribeOptions options = PushSubscribeOptions.Builder() .WithConfiguration(cc) .Build(); IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(SUBJECT, options); c.Flush(DefaultTimeout); // flush outgoing communication with/to the server // TERM JsPublish(js, SUBJECT, "TERM", 1); Msg m = sub.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal("TERM1", Encoding.ASCII.GetString(m.Data)); m.Term(); AssertNoMoreMessages(sub); // Ack Wait timeout JsPublish(js, SUBJECT, "WAIT", 1); m = sub.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal("WAIT1", Encoding.ASCII.GetString(m.Data)); Thread.Sleep(2000); m.Ack(); m = sub.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal("WAIT1", Encoding.ASCII.GetString(m.Data)); // In Progress JsPublish(js, SUBJECT, "PRO", 1); m = sub.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal("PRO1", Encoding.ASCII.GetString(m.Data)); m.InProgress(); Thread.Sleep(750); m.InProgress(); Thread.Sleep(750); m.InProgress(); Thread.Sleep(750); m.InProgress(); Thread.Sleep(750); m.Ack(); AssertNoMoreMessages(sub); // ACK Sync JsPublish(js, SUBJECT, "ACKSYNC", 1); m = sub.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal("ACKSYNC1", Encoding.ASCII.GetString(m.Data)); m.AckSync(DefaultTimeout); AssertNoMoreMessages(sub); // NAK JsPublish(js, SUBJECT, "NAK", 1); m = sub.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal("NAK1", Encoding.ASCII.GetString(m.Data)); m.Nak(); m = sub.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal("NAK1", Encoding.ASCII.GetString(m.Data)); m.Ack(); AssertNoMoreMessages(sub); JsPublish(js, SUBJECT, "NAK", 2, 1); m = sub.NextMessage(1000); Assert.NotNull(m); Assert.Equal("NAK2", Encoding.ASCII.GetString(m.Data)); m.NakWithDelay(3000); Assert.Throws <NATSTimeoutException>(() => sub.NextMessage(500)); m = sub.NextMessage(3000); Assert.NotNull(m); Assert.Equal("NAK2", Encoding.ASCII.GetString(m.Data)); m.Ack(); Assert.Throws <NATSTimeoutException>(() => sub.NextMessage(500)); JsPublish(js, SUBJECT, "NAK", 3, 1); m = sub.NextMessage(1000); Assert.NotNull(m); Assert.Equal("NAK3", Encoding.ASCII.GetString(m.Data)); m.NakWithDelay(Duration.OfSeconds(3)); // coverage to use both nakWithDelay Assert.Throws <NATSTimeoutException>(() => sub.NextMessage(500)); m = sub.NextMessage(3000); Assert.NotNull(m); Assert.Equal("NAK3", Encoding.ASCII.GetString(m.Data)); m.Ack(); Assert.Throws <NATSTimeoutException>(() => sub.NextMessage(500)); }); }
public void TestHandlerAutoAck() { Context.RunInJsServer(c => { // create the stream. CreateDefaultTestStream(c); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); // publish some messages JsPublish(js, SUBJECT, 10); // 1. auto ack true CountdownEvent latch1 = new CountdownEvent(10); int handlerReceived1 = 0; // create our message handler, does not ack void Handler1(object sender, MsgHandlerEventArgs args) { handlerReceived1++; latch1.Signal(); } // subscribe using the handler, auto ack true PushSubscribeOptions pso1 = PushSubscribeOptions.Builder() .WithDurable(Durable(1)).Build(); IJetStreamPushAsyncSubscription asub = js.PushSubscribeAsync(SUBJECT, Handler1, true, pso1); // wait for messages to arrive using the countdown latch. latch1.Wait(); Assert.Equal(10, handlerReceived1); asub.Unsubscribe(); // check that all the messages were read by the durable IJetStreamPushSyncSubscription ssub = js.PushSubscribeSync(SUBJECT, pso1); AssertNoMoreMessages(ssub); // 2. auto ack false CountdownEvent latch2 = new CountdownEvent(10); int handlerReceived2 = 0; // create our message handler, also does not ack void Handler2(object sender, MsgHandlerEventArgs args) { handlerReceived2++; latch2.Signal(); } // subscribe using the handler, auto ack false ConsumerConfiguration cc = ConsumerConfiguration.Builder().WithAckWait(500).Build(); PushSubscribeOptions pso2 = PushSubscribeOptions.Builder() .WithDurable(Durable(2)).WithConfiguration(cc).Build(); asub = js.PushSubscribeAsync(SUBJECT, Handler2, false, pso2); // wait for messages to arrive using the countdown latch. latch2.Wait(); Assert.Equal(10, handlerReceived2); Thread.Sleep(2000); // just give it time for the server to realize the messages are not ack'ed asub.Unsubscribe(); // check that we get all the messages again ssub = js.PushSubscribeSync(SUBJECT, pso2); Assert.Equal(10, ReadMessagesAck(ssub).Count); }); }
public static void Main(string[] args) { ArgumentHelper helper = new ArgumentHelperBuilder("NATS JetStream Push Subscribe Queue Durable", args, Usage) .DefaultStream("qdur-stream") .DefaultSubject("qdur-subject") .DefaultQueue("qdur-queue") .DefaultDurable("qdur-durable") .DefaultDeliverSubject("qdur-deliver") .DefaultCount(100) .DefaultSubsCount(5) .Build(); try { using (IConnection c = new ConnectionFactory().CreateConnection(helper.MakeOptions())) { // Create a JetStreamManagement context. IJetStreamManagement jsm = c.CreateJetStreamManagementContext(); // Use the utility to create a stream stored in memory. JsUtils.CreateStreamExitWhenExists(jsm, helper.Stream, helper.Subject); IJetStream js = c.CreateJetStreamContext(); Console.WriteLine(); // create the consumer ahead of time ConsumerConfiguration cc = ConsumerConfiguration.Builder() .WithDurable(helper.Durable) .WithDeliverSubject(helper.DeliverSubject) .WithDeliverGroup(helper.Queue) .Build(); jsm.AddOrUpdateConsumer(helper.Stream, cc); // we will just bind to that consumer PushSubscribeOptions pso = PushSubscribeOptions.BindTo(helper.Stream, helper.Durable); InterlockedLong allReceived = new InterlockedLong(); IList <JsQueueSubscriber> subscribers = new List <JsQueueSubscriber>(); IList <Thread> subThreads = new List <Thread>(); for (int id = 1; id <= helper.SubsCount; id++) { // setup the subscription IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(helper.Subject, helper.Queue, pso); // create and track the runnable JsQueueSubscriber qs = new JsQueueSubscriber(id, 100, js, sub, allReceived); subscribers.Add(qs); // create, track and start the thread Thread t = new Thread(qs.Run); subThreads.Add(t); t.Start(); } c.Flush(500); // flush outgoing communication with/to the server // create and start the publishing Thread pubThread = new Thread(() => { for (int x = 1; x <= helper.Count; x++) { js.Publish(helper.Subject, Encoding.ASCII.GetBytes("Data # " + x)); } }); pubThread.Start(); // wait for all threads to finish pubThread.Join(10000); foreach (Thread t in subThreads) { t.Join(10000); } foreach (JsQueueSubscriber qs in subscribers) { qs.Report(); } Console.WriteLine(); // delete the stream since we are done with it. jsm.DeleteStream(helper.Stream); } } catch (Exception ex) { helper.ReportException(ex); } }
public void TestFilterSubjectEphemeral() { Context.RunInJsServer(c => { // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); string subjectWild = SUBJECT + ".*"; string subjectA = SUBJECT + ".A"; string subjectB = SUBJECT + ".B"; // create the stream. CreateMemoryStream(c, STREAM, subjectWild); JsPublish(js, subjectA, 1); JsPublish(js, subjectB, 1); JsPublish(js, subjectA, 1); JsPublish(js, subjectB, 1); // subscribe to the wildcard ConsumerConfiguration cc = ConsumerConfiguration.Builder().WithAckPolicy(AckPolicy.None).Build(); PushSubscribeOptions pso = PushSubscribeOptions.Builder().WithConfiguration(cc).Build(); IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(subjectWild, pso); c.Flush(1000); Msg m = sub.NextMessage(1000); Assert.Equal(subjectA, m.Subject); Assert.Equal(1U, m.MetaData.StreamSequence); m = sub.NextMessage(1000); Assert.Equal(subjectB, m.Subject); Assert.Equal(2U, m.MetaData.StreamSequence); m = sub.NextMessage(1000); Assert.Equal(subjectA, m.Subject); Assert.Equal(3U, m.MetaData.StreamSequence); m = sub.NextMessage(1000); Assert.Equal(subjectB, m.Subject); Assert.Equal(4U, m.MetaData.StreamSequence); // subscribe to A cc = ConsumerConfiguration.Builder().WithFilterSubject(subjectA).WithAckPolicy(AckPolicy.None).Build(); pso = PushSubscribeOptions.Builder().WithConfiguration(cc).Build(); sub = js.PushSubscribeSync(subjectWild, pso); c.Flush(1000); m = sub.NextMessage(1000); Assert.Equal(subjectA, m.Subject); Assert.Equal(1U, m.MetaData.StreamSequence); m = sub.NextMessage(1000); Assert.Equal(subjectA, m.Subject); Assert.Equal(3U, m.MetaData.StreamSequence); Assert.Throws <NATSTimeoutException>(() => sub.NextMessage(1000)); // subscribe to B cc = ConsumerConfiguration.Builder().WithFilterSubject(subjectB).WithAckPolicy(AckPolicy.None).Build(); pso = PushSubscribeOptions.Builder().WithConfiguration(cc).Build(); sub = js.PushSubscribeSync(subjectWild, pso); c.Flush(1000); m = sub.NextMessage(1000); Assert.Equal(subjectB, m.Subject); Assert.Equal(2U, m.MetaData.StreamSequence); m = sub.NextMessage(1000); Assert.Equal(subjectB, m.Subject); Assert.Equal(4U, m.MetaData.StreamSequence); Assert.Throws <NATSTimeoutException>(() => sub.NextMessage(1000)); }); }
public void TestJetStreamSubscribe() { Context.RunInJsServer(c => { IJetStream js = c.CreateJetStreamContext(); IJetStreamManagement jsm = c.CreateJetStreamManagementContext(); CreateDefaultTestStream(jsm); JsPublish(js); // default ephemeral subscription. IJetStreamPushSyncSubscription s = js.PushSubscribeSync(SUBJECT); Msg m = s.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal(DATA, Encoding.UTF8.GetString(m.Data)); IList <String> names = jsm.GetConsumerNames(STREAM); Assert.Equal(1, names.Count); // default subscribe options // ephemeral subscription. s = js.PushSubscribeSync(SUBJECT, PushSubscribeOptions.Builder().Build()); m = s.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal(DATA, Encoding.UTF8.GetString(m.Data)); names = jsm.GetConsumerNames(STREAM); Assert.Equal(2, names.Count); // set the stream PushSubscribeOptions pso = PushSubscribeOptions.Builder() .WithStream(STREAM).WithDurable(DURABLE).Build(); s = js.PushSubscribeSync(SUBJECT, pso); m = s.NextMessage(DefaultTimeout); Assert.NotNull(m); Assert.Equal(DATA, Encoding.UTF8.GetString(m.Data)); names = jsm.GetConsumerNames(STREAM); Assert.Equal(3, names.Count); // coverage js.PushSubscribeSync(SUBJECT); js.PushSubscribeSync(SUBJECT, (PushSubscribeOptions)null); js.PushSubscribeSync(SUBJECT, QUEUE, null); js.PushSubscribeAsync(SUBJECT, (o, a) => {}, false); js.PushSubscribeAsync(SUBJECT, (o, a) => {}, false, null); js.PushSubscribeAsync(SUBJECT, QUEUE, (o, a) => {}, false, null); // bind with w/o subject jsm.AddOrUpdateConsumer(STREAM, ConsumerConfiguration.Builder() .WithDurable(Durable(101)) .WithDeliverSubject(Deliver(101)) .Build()); PushSubscribeOptions psoBind = PushSubscribeOptions.BindTo(STREAM, Durable(101)); js.PushSubscribeSync(null, psoBind).Unsubscribe(); js.PushSubscribeSync("", psoBind).Unsubscribe(); js.PushSubscribeAsync(null, (o, a) => { }, false, psoBind).Unsubscribe(); js.PushSubscribeAsync("", (o, a) => { }, false, psoBind); jsm.AddOrUpdateConsumer(STREAM, ConsumerConfiguration.Builder() .WithDurable(Durable(102)) .WithDeliverSubject(Deliver(102)) .WithDeliverGroup(Queue(102)) .Build()); psoBind = PushSubscribeOptions.BindTo(STREAM, Durable(102)); js.PushSubscribeSync(null, Queue(102), psoBind).Unsubscribe(); js.PushSubscribeSync("", Queue(102), psoBind).Unsubscribe(); js.PushSubscribeAsync(null, Queue(102), (o, a) => { }, false, psoBind).Unsubscribe(); js.PushSubscribeAsync("", Queue(102), (o, a) => { }, false, psoBind); }); }
public static void Main(string[] args) { ArgumentHelper helper = new ArgumentHelperBuilder("NATS JetStream Push Subscribe Bind Durable", args, Usage) .DefaultStream("fs-stream") .DefaultSubject("fs-subject") .Build(); string subjectWild = helper.Subject + ".*"; string subjectA = helper.Subject + ".A"; string subjectB = helper.Subject + ".B"; try { using (IConnection c = new ConnectionFactory().CreateConnection(helper.MakeOptions())) { // Create a JetStreamManagement context. IJetStreamManagement jsm = c.CreateJetStreamManagementContext(); // Use the utility to create a stream stored in memory. JsUtils.CreateStreamExitWhenExists(jsm, helper.Stream, subjectWild); // Create our JetStream context to publish and receive JetStream messages. IJetStream js = c.CreateJetStreamContext(); JsUtils.Publish(js, subjectA, 1); JsUtils.Publish(js, subjectB, 1); JsUtils.Publish(js, subjectA, 1); JsUtils.Publish(js, subjectB, 1); // 1. create a subscription that subscribes to the wildcard subject ConsumerConfiguration cc = ConsumerConfiguration.Builder() .WithAckPolicy(AckPolicy.None) // don't want to worry about acking messages. .Build(); PushSubscribeOptions pso = PushSubscribeOptions.Builder() .WithConfiguration(cc) .Build(); IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(subjectWild, pso); c.Flush(5000); Msg m = sub.NextMessage(1000); Console.WriteLine("\n1A1. Message should be from '" + subjectA + "', Sequence #1. " + "It was: '" + m.Subject + "', Seq #" + m.MetaData.StreamSequence); m = sub.NextMessage(1000); Console.WriteLine("1B2. Message should be from '" + subjectB + "', Sequence #2. " + "It was: '" + m.Subject + "', Seq #" + m.MetaData.StreamSequence); m = sub.NextMessage(1000); Console.WriteLine("1A3. Message should be from '" + subjectA + "', Sequence #3. " + "It was: '" + m.Subject + "', Seq #" + m.MetaData.StreamSequence); m = sub.NextMessage(1000); Console.WriteLine("1B4. Message should be from '" + subjectB + "', Sequence #4. " + "It was: '" + m.Subject + "', Seq #" + m.MetaData.StreamSequence); // 2. create a subscription that subscribes only to the A subject cc = ConsumerConfiguration.Builder() .WithAckPolicy(AckPolicy.None) // don't want to worry about acking messages. .WithFilterSubject(subjectA) .Build(); pso = PushSubscribeOptions.Builder() .WithConfiguration(cc) .Build(); sub = js.PushSubscribeSync(subjectWild, pso); c.Flush(5000); m = sub.NextMessage(1000); Console.WriteLine("\n2A1. Message should be from '" + subjectA + "', Sequence #1. " + "It was: '" + m.Subject + "', Seq #" + m.MetaData.StreamSequence); m = sub.NextMessage(1000); Console.WriteLine("2A3. Message should be from '" + subjectA + "', Sequence #3. " + "It was: '" + m.Subject + "', Seq #" + m.MetaData.StreamSequence); try { sub.NextMessage(1000); Console.WriteLine("2x. NOPE! Should not have gotten here"); } catch (NATSTimeoutException) // timeout means there are no messages available { Console.WriteLine("2x. There was no message available."); } // 3. create a subscription that subscribes only to the A subject cc = ConsumerConfiguration.Builder() .WithAckPolicy(AckPolicy.None) // don't want to worry about acking messages. .WithFilterSubject(subjectB) .Build(); pso = PushSubscribeOptions.Builder() .WithConfiguration(cc) .Build(); sub = js.PushSubscribeSync(subjectWild, pso); c.Flush(5000); m = sub.NextMessage(1000); Console.WriteLine("\n3A2. Message should be from '" + subjectB + "', Sequence #2. " + "It was: '" + m.Subject + "', Seq #" + m.MetaData.StreamSequence); m = sub.NextMessage(1000); Console.WriteLine("3A4. Message should be from '" + subjectB + "', Sequence #4. " + "It was: '" + m.Subject + "', Seq #" + m.MetaData.StreamSequence); try { sub.NextMessage(1000); Console.WriteLine("3x. NOPE! Should not have gotten here"); } catch (NATSTimeoutException) // timeout means there are no messages available { Console.WriteLine("3x. There was no message available."); } Console.WriteLine(); // delete the stream since we are done with it. jsm.DeleteStream(helper.Stream); } } catch (Exception ex) { helper.ReportException(ex); } }
public static void Main(string[] args) { ArgumentHelper helper = new ArgumentHelperBuilder("Push Subscribe Basic Sync", args, Usage) .DefaultStream("example-stream") .DefaultSubject("example-subject") .DefaultCount(0, true) // true indicated 0 means unlimited // .DefaultDurable("push-sub-basic-sync-durable") .Build(); int count = helper.Count < 1 ? int.MaxValue : helper.Count; try { using (IConnection c = new ConnectionFactory().CreateConnection(helper.MakeOptions())) { // The stream (and data) must exist JsUtils.ExitIfStreamNotExists(c, helper.Stream); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); // Build our subscription options. // * A push subscription means the server will "push" us messages. // * Durable means the server will remember where we are if we use that name. // * Durable can by null or empty, the builder treats them the same. // * The stream name is not technically required. If it is not provided, the // code building the subscription will look it up by making a request to the server. // If you know the stream name, you might as well supply it and save a trip to the server. PushSubscribeOptions so = PushSubscribeOptions.Builder() .WithStream(helper.Stream) .WithDurable(helper.Durable) // it's okay if this is null, the builder handles it .Build(); // Subscribe synchronously, then just wait for messages. IJetStreamPushSyncSubscription sub = js.PushSubscribeSync(helper.Subject, so); c.Flush(5000); int red = 0; while (count > 0) { try { Msg msg = sub.NextMessage(1000); Console.WriteLine("\nMessage Received:"); if (msg.HasHeaders) { Console.WriteLine(" Headers:"); foreach (string key in msg.Header.Keys) { foreach (string value in msg.Header.GetValues(key)) { Console.WriteLine($" {key}: {value}"); } } } Console.WriteLine(" Subject: {0}\n Data: {1}\n", msg.Subject, Encoding.UTF8.GetString(msg.Data)); Console.WriteLine(" " + msg.MetaData); // Because this is a synchronous subscriber, there's no auto-ack. // The default Consumer Configuration AckPolicy is Explicit // so we need to ack the message or it'll be redelivered. msg.Ack(); ++red; --count; } catch (NATSTimeoutException) // timeout means there are no messages available { count = 0; // ran out of messages } } Console.WriteLine("\n" + red + " message(s) were received.\n"); sub.Unsubscribe(); c.Flush(5000); } } catch (Exception ex) { helper.ReportException(ex); } }
public static void Main(string[] args) { ArgumentHelper helper = new ArgumentHelperBuilder("NATS JetStream Push Subscribe Bind Durable", args, Usage) .DefaultStream("fs-stream") .DefaultSubject("fs-subject") .Build(); string subjectNoAck = helper.Subject + "noack"; string subjectAck = helper.Subject + "ack"; string deliverNoAck = helper.DeliverSubject + "noack"; string deliverAck = helper.DeliverSubject + "ack"; try { using (IConnection c = new ConnectionFactory().CreateConnection(helper.MakeOptions())) { // Create a JetStreamManagement context. IJetStreamManagement jsm = c.CreateJetStreamManagementContext(); // Use the utility to create a stream stored in memory. JsUtils.CreateStreamExitWhenExists(jsm, helper.Stream, subjectNoAck, subjectAck); // Create our JetStream context. IJetStream js = c.CreateJetStreamContext(); // The server uses the delivery subject as both an inbox for a JetStream subscription // and as a core nats messages subject. // BUT BE CAREFUL. THIS IS STILL A JETSTREAM SUBJECT AND ALL MESSAGES // ADHERE TO THE ACK POLICY // NoAck 1. Set up the noAck consumer / deliver subject configuration ConsumerConfiguration cc = ConsumerConfiguration.Builder() .WithAckPolicy(AckPolicy.None) .WithAckWait(1000) .Build(); PushSubscribeOptions pso = PushSubscribeOptions.Builder() .WithDeliverSubject(deliverNoAck) .WithConfiguration(cc) .Build(); // NoAck 2. Set up the JetStream and core subscriptions // Notice the JetStream subscribes to the real subject // and the core subscribes to the delivery subject // Order matters, you must do the JetStream subscribe first // But you also must make sure the core sub is made // before messages are published IJetStreamPushSyncSubscription jsSub = js.PushSubscribeSync(subjectNoAck, pso); c.Flush(5000); ISyncSubscription coreSub = c.SubscribeSync(deliverNoAck); // NoAck 3. JsUtils.Publish to the real subject JsUtils.Publish(js, subjectNoAck, "A", 1); // NoAck 4. Read the message with the js no ack subscription. No need to ack Msg msg = jsSub.NextMessage(1000); PrintMessage("\nNoAck 4. Read w/JetStream sub", msg); // NoAck 5. Read the message with the core subscription on the // no ack deliver subject. Since this message is a JetStream // message we could ack. But we don't have to since the consumer // was setup as AckPolicy None msg = coreSub.NextMessage(1000); PrintMessage("NoAck 5. Read w/core sub", msg); // NoAck 6. Thread.Sleep longer than the ack wait period to check and make sure the // message is not replayed Thread.Sleep(1100); try { coreSub.NextMessage(1000); Console.WriteLine("NoAck 6. NOPE! Should not have gotten here"); } catch (NATSTimeoutException) // timeout means there are no messages available { Console.WriteLine("NoAck 6. Read w/core sub.\nAck Policy is none so no replay even though message was not Ack'd.\nThere was no message available."); } // Ack 1. Set up the Ack consumer / deliver subject configuration cc = ConsumerConfiguration.Builder() .WithAckPolicy(AckPolicy.Explicit) .WithAckWait(1000) .Build(); pso = PushSubscribeOptions.Builder() .WithDeliverSubject(deliverAck) .WithConfiguration(cc) .Build(); // Ack 2. Set up the JetStream and core subscriptions jsSub = js.PushSubscribeSync(subjectAck, pso); c.Flush(5000); coreSub = c.SubscribeSync(deliverAck); // Ack 3. JsUtils.Publish to the real subject JsUtils.Publish(js, subjectAck, "B", 1); // Ack 4. Read the message with the js no ack subscription. No need to ack msg = jsSub.NextMessage(1000); PrintMessage("\nAck 4. Read w/JetStream sub", msg); // Ack 5. Read the message with the core subscription on the // ack deliver subject. // Even though it is read on a core subscription // it still is a JetStream message. Don't ack this time msg = coreSub.NextMessage(1000); PrintMessage("Ack 5. Read w/core sub", msg); // Ack 6. Thread.Sleep longer than the ack wait period to check and // see that the message is re-delivered. Ack this time. Thread.Sleep(1100); msg = coreSub.NextMessage(1000); msg.Ack(); PrintMessage("Ack 6. Read w/core sub.\nWasn't Ack'd after step 'Ack 5.' so message was replayed.", msg); // Ack 7. Thread.Sleep longer than the ack wait period. The message // is not re-delivered this time Thread.Sleep(1100); try { coreSub.NextMessage(1000); Console.WriteLine("Ack 7. NOPE! Should not have gotten here"); } catch (NATSTimeoutException) // timeout means there are no messages available { Console.WriteLine("Ack 7. Read w/core sub.\nMessage received by core sub in step 'Ack 6.' was JetStream so it was Ack'd and therefore not replayed.\nThere was no message available.", msg); } // delete the stream since we are done with it. jsm.DeleteStream(helper.Stream); } } catch (Exception ex) { helper.ReportException(ex); } }