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 TestBindDurableDeliverSubject()
{
Context.RunInJsServer(c =>
{
CreateDefaultTestStream(c);
IJetStream js = c.CreateJetStreamContext();
IJetStreamManagement jsm = c.CreateJetStreamManagementContext();
// create a durable push subscriber - has deliver subject
ConsumerConfiguration ccDurPush = ConsumerConfiguration.Builder()
.WithDurable(Durable(1))
.WithDeliverSubject(Deliver(1))
.Build();
jsm.AddOrUpdateConsumer(STREAM, ccDurPush);
// create a durable pull subscriber - notice no deliver subject
ConsumerConfiguration ccDurPull = ConsumerConfiguration.Builder()
.WithDurable(Durable(2))
.Build();
jsm.AddOrUpdateConsumer(STREAM, ccDurPull);
// try to pull subscribe against a push durable
NATSJetStreamClientException e = Assert.Throws <NATSJetStreamClientException>(
() => js.PullSubscribe(SUBJECT, PullSubscribeOptions.Builder().WithDurable(Durable(1)).Build()));
Assert.Contains(JsSubConsumerAlreadyConfiguredAsPush.Id, e.Message);
// try to pull bind against a push durable
e = Assert.Throws <NATSJetStreamClientException>(
() => js.PullSubscribe(SUBJECT, PullSubscribeOptions.BindTo(STREAM, Durable(1))));
Assert.Contains(JsSubConsumerAlreadyConfiguredAsPush.Id, e.Message);
// this one is okay
IJetStreamPullSubscription sub = js.PullSubscribe(SUBJECT, PullSubscribeOptions.Builder().WithDurable(Durable(2)).Build());
sub.Unsubscribe(); // so I can re-use the durable
// try to push subscribe against a pull durable
e = Assert.Throws <NATSJetStreamClientException>(
() => js.PushSubscribeSync(SUBJECT, PushSubscribeOptions.Builder().WithDurable(Durable(2)).Build()));
Assert.Contains(JsSubConsumerAlreadyConfiguredAsPull.Id, e.Message);
// try to push bind against a pull durable
e = Assert.Throws <NATSJetStreamClientException>(
() => js.PushSubscribeSync(SUBJECT, PushSubscribeOptions.BindTo(STREAM, Durable(2))));
Assert.Contains(JsSubConsumerAlreadyConfiguredAsPull.Id, e.Message);
// this one is okay
js.PushSubscribeSync(SUBJECT, PushSubscribeOptions.Builder().WithDurable(Durable(1)).Build());
});
}
private void SubscribeOk(IJetStream js, IJetStreamManagement jsm, string fs, string ss)
{
int i = Rndm.Next(); // just want a unique number
SetupConsumer(jsm, i, fs);
js.PushSubscribeSync(ss, ConsumerConfiguration.Builder().WithDurable(Durable(i)).BuildPushSubscribeOptions()).Unsubscribe();
}
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 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 ChangeExPush(IJetStream js, ConsumerConfiguration.ConsumerConfigurationBuilder builder, String changedField)
{
NATSJetStreamClientException e = Assert.Throws <NATSJetStreamClientException>(
() => js.PushSubscribeSync(SUBJECT, PushSubscribeOptions.Builder().WithConfiguration(builder.Build()).Build()));
_ChangeEx(e, changedField);
}
public void TestJetStreamPushDurableSubSync()
{
Context.RunInJsServer(c =>
{
// create the stream.
CreateDefaultTestStream(c);
// Create our JetStream context.
IJetStream js = c.CreateJetStreamContext();
IJetStreamManagement jsm = c.CreateJetStreamManagementContext();
// publish some messages
JsPublish(js, SUBJECT, 1, 5);
// Build our subscription options normally
PushSubscribeOptions optionsSync1 = PushSubscribeOptions.Builder()
.WithDurable(Durable(1))
.WithDeliverSubject(Deliver(1))
.Build();
_testPushDurableSubSync(Durable(1), Deliver(1), c, () => js.PushSubscribeSync(SUBJECT, optionsSync1));
// bind long form
jsm.AddOrUpdateConsumer(STREAM,
ConsumerConfiguration.Builder()
.WithDurable(Durable(2))
.WithDeliverSubject(Deliver(2))
.Build());
PushSubscribeOptions options2 = PushSubscribeOptions.Builder()
.WithStream(STREAM)
.WithDurable(Durable(2))
.WithBind(true)
.Build();
_testPushDurableSubSync(Durable(2), Deliver(2), c, () => js.PushSubscribeSync(null, options2));
// bind short form
jsm.AddOrUpdateConsumer(STREAM,
ConsumerConfiguration.Builder()
.WithDurable(Durable(3))
.WithDeliverSubject(Deliver(3))
.Build());
PushSubscribeOptions options3 = PushSubscribeOptions.BindTo(STREAM, Durable(3));
_testPushDurableSubSync(Durable(3), Deliver(3), c, () => js.PushSubscribeSync(null, options3));
});
}
private void SubscribeEx(IJetStream js, IJetStreamManagement jsm, string fs, string ss)
{
int i = Rndm.Next(); // just want a unique number
SetupConsumer(jsm, i, fs);
NATSJetStreamClientException e = Assert.Throws <NATSJetStreamClientException>(
() => js.PushSubscribeSync(ss, ConsumerConfiguration.Builder().WithDurable(Durable(i)).BuildPushSubscribeOptions()));
Assert.Contains(JsSubSubjectDoesNotMatchFilter.Id, e.Message);
}
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 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 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));
});
}
public void TestJetStreamSubscribeErrors()
{
Context.RunInJsServer(c =>
{
IJetStream js = c.CreateJetStreamContext();
// stream not found
PushSubscribeOptions psoInvalidStream = PushSubscribeOptions.Builder().WithStream(STREAM).Build();
Assert.Throws <NATSJetStreamException>(() => js.PushSubscribeSync(SUBJECT, psoInvalidStream));
void AssertThrowsForSubject(Func <object> testCode)
{
ArgumentException ae = Assert.Throws <ArgumentException>(testCode);
Assert.StartsWith("Subject", ae.Message);
}
void AssertThrowsForQueue(Func <object> testCode)
{
ArgumentException ae = Assert.Throws <ArgumentException>(testCode);
Assert.StartsWith("Queue", ae.Message);
}
void AssertThrowsForHandler(Func <object> testCode)
{
ArgumentNullException ae = Assert.Throws <ArgumentNullException>(testCode);
Assert.Equal("Handler", ae.ParamName);
}
// subject
AssertThrowsForSubject(() => js.PushSubscribeSync(HasSpace));
AssertThrowsForSubject(() => js.PushSubscribeSync(null, (PushSubscribeOptions)null));
AssertThrowsForSubject(() => js.PushSubscribeSync(HasSpace, Plain));
AssertThrowsForSubject(() => js.PushSubscribeSync(null, Plain, null));
AssertThrowsForSubject(() => js.PushSubscribeAsync(HasSpace, null, false));
AssertThrowsForSubject(() => js.PushSubscribeAsync(HasSpace, null, false, null));
AssertThrowsForSubject(() => js.PushSubscribeAsync(HasSpace, Plain, null, false));
AssertThrowsForSubject(() => js.PushSubscribeAsync(HasSpace, Plain, null, false, null));
// queue
AssertThrowsForQueue(() => js.PushSubscribeSync(Plain, HasSpace));
AssertThrowsForQueue(() => js.PushSubscribeSync(Plain, HasSpace, null));
AssertThrowsForQueue(() => js.PushSubscribeAsync(Plain, HasSpace, null, false));
AssertThrowsForQueue(() => js.PushSubscribeAsync(Plain, HasSpace, null, false, null));
// handler
AssertThrowsForHandler(() => js.PushSubscribeAsync(Plain, null, false));
AssertThrowsForHandler(() => js.PushSubscribeAsync(Plain, null, false, null));
AssertThrowsForHandler(() => js.PushSubscribeAsync(Plain, Plain, null, false));
AssertThrowsForHandler(() => js.PushSubscribeAsync(Plain, Plain, null, false, null));
});
}
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);
});
}
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 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 void TestMoreCreateSubscriptionErrors()
{
Context.RunInJsServer(c =>
{
// Create our JetStream context.
IJetStream js = c.CreateJetStreamContext();
NATSJetStreamClientException e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT));
Assert.Contains(JsSubNoMatchingStreamForSubject.Id, e.Message);
// create the stream.
CreateDefaultTestStream(c);
// general pull push validation
ConsumerConfiguration ccPush = ConsumerConfiguration.Builder().WithDurable("pulldur").WithDeliverGroup("cantHave").Build();
PullSubscribeOptions pullCantHaveDlvrGrp = PullSubscribeOptions.Builder().WithConfiguration(ccPush).Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PullSubscribe(SUBJECT, pullCantHaveDlvrGrp));
Assert.Contains(JsSubPullCantHaveDeliverGroup.Id, e.Message);
ccPush = ConsumerConfiguration.Builder().WithDurable("pulldur").WithDeliverSubject("cantHave").Build();
PullSubscribeOptions pullCantHaveDlvrSub = PullSubscribeOptions.Builder().WithConfiguration(ccPush).Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PullSubscribe(SUBJECT, pullCantHaveDlvrSub));
Assert.Contains(JsSubPullCantHaveDeliverSubject.Id, e.Message);
ccPush = ConsumerConfiguration.Builder().WithMaxPullWaiting(1).Build();
PushSubscribeOptions pushSo = PushSubscribeOptions.Builder().WithConfiguration(ccPush).Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, pushSo));
Assert.Contains(JsSubPushCantHaveMaxPullWaiting.Id, e.Message);
ccPush = ConsumerConfiguration.Builder().WithMaxPullWaiting(-1).Build();
pushSo = PushSubscribeOptions.Builder().WithConfiguration(ccPush).Build();
js.PushSubscribeSync(SUBJECT, pushSo);
ccPush = ConsumerConfiguration.Builder().WithMaxBatch(1).Build();
pushSo = PushSubscribeOptions.Builder().WithConfiguration(ccPush).Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, pushSo));
ccPush = ConsumerConfiguration.Builder().WithMaxBatch(-1).Build();
pushSo = PushSubscribeOptions.Builder().WithConfiguration(ccPush).Build();
js.PushSubscribeSync(SUBJECT, pushSo);
Assert.Contains(JsSubPushCantHaveMaxBatch.Id, e.Message);
ccPush = ConsumerConfiguration.Builder().WithMaxBytes(1).Build();
pushSo = PushSubscribeOptions.Builder().WithConfiguration(ccPush).Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, pushSo));
ccPush = ConsumerConfiguration.Builder().WithMaxBytes(-1).Build();
pushSo = PushSubscribeOptions.Builder().WithConfiguration(ccPush).Build();
js.PushSubscribeSync(SUBJECT, pushSo);
Assert.Contains(JsSubPushCantHaveMaxBytes.Id, e.Message);
// create some consumers
PushSubscribeOptions psoDurNoQ = PushSubscribeOptions.Builder().WithDurable("durNoQ").Build();
js.PushSubscribeSync(SUBJECT, psoDurNoQ);
PushSubscribeOptions psoDurYesQ = PushSubscribeOptions.Builder().WithDurable("durYesQ").Build();
js.PushSubscribeSync(SUBJECT, "yesQ", psoDurYesQ);
// already bound
e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, psoDurNoQ));
Assert.Contains(JsSubConsumerAlreadyBound.Id, e.Message);
// queue match
PushSubscribeOptions qmatch = PushSubscribeOptions.Builder()
.WithDurable("qmatchdur").WithDeliverGroup("qmatchq").Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, "qnotmatch", qmatch));
Assert.Contains(JsSubQueueDeliverGroupMismatch.Id, e.Message);
// queue vs config
e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, "notConfigured", psoDurNoQ));
Assert.Contains(JsSubExistingConsumerNotQueue.Id, e.Message);
PushSubscribeOptions psoNoVsYes = PushSubscribeOptions.Builder().WithDurable("durYesQ").Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, psoNoVsYes));
Assert.Contains(JsSubExistingConsumerIsQueue.Id, e.Message);
PushSubscribeOptions psoYesVsNo = PushSubscribeOptions.Builder().WithDurable("durYesQ").Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, "qnotmatch", psoYesVsNo));
Assert.Contains(JsSubExistingQueueDoesNotMatchRequestedQueue.Id, e.Message);
// flow control heartbeat push / pull
ConsumerConfiguration ccFc = ConsumerConfiguration.Builder().WithDurable("ccFcDur").WithFlowControl(1000).Build();
ConsumerConfiguration ccHb = ConsumerConfiguration.Builder().WithDurable("ccHbDur").WithIdleHeartbeat(1000).Build();
PullSubscribeOptions psoPullCcFc = PullSubscribeOptions.Builder().WithConfiguration(ccFc).Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PullSubscribe(SUBJECT, psoPullCcFc));
Assert.Contains(JsSubFcHbNotValidPull.Id, e.Message);
PullSubscribeOptions psoPullCcHb = PullSubscribeOptions.Builder().WithConfiguration(ccHb).Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PullSubscribe(SUBJECT, psoPullCcHb));
Assert.Contains(JsSubFcHbNotValidPull.Id, e.Message);
PushSubscribeOptions psoPushCcFc = PushSubscribeOptions.Builder().WithConfiguration(ccFc).Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, "cantHaveQ", psoPushCcFc));
Assert.Contains(JsSubFcHbHbNotValidQueue.Id, e.Message);
PushSubscribeOptions psoPushCcHb = PushSubscribeOptions.Builder().WithConfiguration(ccHb).Build();
e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, "cantHaveQ", psoPushCcHb));
Assert.Contains(JsSubFcHbHbNotValidQueue.Id, e.Message);
});
}
private void ChangeOkPush(IJetStream js, ConsumerConfiguration.ConsumerConfigurationBuilder builder)
{
js.PushSubscribeSync(SUBJECT, PushSubscribeOptions.Builder().WithConfiguration(builder.Build()).Build()).Unsubscribe();
}
public void TestConsumerIsNotModified()
{
Context.RunInJsServer(c =>
{
CreateDefaultTestStream(c);
IJetStreamManagement jsm = c.CreateJetStreamManagementContext();
// test with config in issue 105
ConsumerConfiguration cc = ConsumerConfiguration.Builder()
.WithDescription("desc")
.WithAckPolicy(AckPolicy.Explicit)
.WithDeliverPolicy(DeliverPolicy.All)
.WithDeliverSubject(Deliver(1))
.WithDeliverGroup(Queue(1))
.WithDurable(Durable(1))
.WithMaxAckPending(65000)
.WithMaxDeliver(5)
.WithReplayPolicy(ReplayPolicy.Instant)
.Build();
jsm.AddOrUpdateConsumer(STREAM, cc);
IJetStream js = c.CreateJetStreamContext();
PushSubscribeOptions pushOpts = PushSubscribeOptions.BindTo(STREAM, Durable(1));
js.PushSubscribeSync(SUBJECT, Queue(1), pushOpts); // should not throw an error
// testing numerics
cc = ConsumerConfiguration.Builder()
.WithDeliverPolicy(DeliverPolicy.ByStartSequence)
.WithDeliverSubject(Deliver(21))
.WithDurable(Durable(21))
.WithStartSequence(42)
.WithMaxDeliver(43)
.WithRateLimitBps(44)
.WithMaxAckPending(45)
.Build();
jsm.AddOrUpdateConsumer(STREAM, cc);
pushOpts = PushSubscribeOptions.BindTo(STREAM, Durable(21));
js.PushSubscribeSync(SUBJECT, pushOpts); // should not throw an error
cc = ConsumerConfiguration.Builder()
.WithDurable(Durable(22))
.WithMaxPullWaiting(46)
.Build();
jsm.AddOrUpdateConsumer(STREAM, cc);
PullSubscribeOptions pullOpts = PullSubscribeOptions.BindTo(STREAM, Durable(22));
js.PullSubscribe(SUBJECT, pullOpts); // should not throw an error
// testing DateTime
cc = ConsumerConfiguration.Builder()
.WithDeliverPolicy(DeliverPolicy.ByStartTime)
.WithDeliverSubject(Deliver(3))
.WithDurable(Durable(3))
.WithStartTime(DateTime.Now.AddHours(1))
.Build();
jsm.AddOrUpdateConsumer(STREAM, cc);
pushOpts = PushSubscribeOptions.BindTo(STREAM, Durable(3));
js.PushSubscribeSync(SUBJECT, pushOpts); // should not throw an error
// testing boolean and duration
cc = ConsumerConfiguration.Builder()
.WithDeliverSubject(Deliver(4))
.WithDurable(Durable(4))
.WithFlowControl(1000)
.WithHeadersOnly(true)
.WithAckWait(2000)
.Build();
jsm.AddOrUpdateConsumer(STREAM, cc);
pushOpts = PushSubscribeOptions.BindTo(STREAM, Durable(4));
js.PushSubscribeSync(SUBJECT, pushOpts); // should not throw an error
// testing enums
cc = ConsumerConfiguration.Builder()
.WithDeliverSubject(Deliver(5))
.WithDurable(Durable(5))
.WithDeliverPolicy(DeliverPolicy.Last)
.WithAckPolicy(AckPolicy.None)
.WithReplayPolicy(ReplayPolicy.Original)
.Build();
jsm.AddOrUpdateConsumer(STREAM, cc);
pushOpts = PushSubscribeOptions.BindTo(STREAM, Durable(5));
js.PushSubscribeSync(SUBJECT, pushOpts); // should not throw an error
});
}
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);
}
}
private static void SubPush(Context ctx, IConnection c, Stats stats, int id)
{
IJetStream js = c.CreateJetStreamContext(ctx.GetJetStreamOptions());
IJetStreamPushSyncSubscription sub;
if (ctx.Action.IsQueue)
{
// if we don't do this, multiple threads will try to make the same consumer because
// when they start, the consumer does not exist. So force them do it one at a time.
lock (QueueLock)
{
sub = js.PushSubscribeSync(ctx.Subject, ctx.QueueName,
ConsumerConfiguration.Builder()
.WithAckPolicy(ctx.AckPolicy)
.WithAckWait(Duration.OfSeconds(ctx.AckWaitSeconds))
.WithDeliverGroup(ctx.QueueName)
.BuildPushSubscribeOptions());
}
}
else
{
sub = js.PushSubscribeSync(ctx.Subject,
ConsumerConfiguration.Builder()
.WithAckPolicy(ctx.AckPolicy)
.WithAckWait(Duration.OfSeconds(ctx.AckWaitSeconds))
.BuildPushSubscribeOptions());
}
int rcvd = 0;
Msg lastUnAcked = null;
int unAckedCount = 0;
int unReported = 0;
string label = ctx.GetLabel(id);
InterlockedLong counter = ctx.GetSubscribeCounter(ctx.GetSubDurable(id));
while (counter.Read() < ctx.MessageCount)
{
try
{
stats.Start();
Msg m = sub.NextMessage(1000);
long hold = stats.Elapsed();
long received = DateTimeOffset.Now.ToUnixTimeMilliseconds();
stats.AcceptHold(hold);
stats.Count(m, received);
counter.Increment();
if ((lastUnAcked = AckMaybe(ctx, stats, m, ++unAckedCount)) == null)
{
unAckedCount = 0;
}
unReported = ReportMaybe(label, ctx, ++rcvd, ++unReported, "Messages Read");
}
catch (NATSTimeoutException)
{
// normal timeout
long hold = stats.Elapsed();
AcceptHoldOnceStarted(label, stats, rcvd, hold);
}
}
if (lastUnAcked != null)
{
_ack(stats, lastUnAcked);
}
Report(label, rcvd, "Finished Reading Messages");
}
public void TestBindErrors()
{
Context.RunInJsServer(c =>
{
CreateDefaultTestStream(c);
IJetStream js = c.CreateJetStreamContext();
PushSubscribeOptions pushso = PushSubscribeOptions.BindTo(STREAM, DURABLE);
NATSJetStreamClientException e = Assert.Throws <NATSJetStreamClientException>(() => js.PushSubscribeSync(SUBJECT, pushso));
Assert.Contains(JsSubConsumerNotFoundRequiredInBind.Id, e.Message);
PullSubscribeOptions pullso = PullSubscribeOptions.BindTo(STREAM, DURABLE);
e = Assert.Throws <NATSJetStreamClientException>(() => js.PullSubscribe(SUBJECT, pullso));
Assert.Contains(JsSubConsumerNotFoundRequiredInBind.Id, e.Message);
});
}
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 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 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 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 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 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);
});
}