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);
}
}
