public static void Main(string[] args)
{
ArgumentHelper helper = new ArgumentHelperBuilder("Pull Subscription using primitive Expires In", args, Usage)
.DefaultStream("fetch-stream")
.DefaultSubject("fetch-subject")
.DefaultDurable("fetch-durable")
.DefaultCount(15)
.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 our JetStream context.
IJetStream js = c.CreateJetStreamContext();
// Start publishing the messages, don't wait for them to finish, simulating an outside producer.
JsUtils.PublishInBackground(js, helper.Subject, "fetch-message", helper.Count);
// Build our consumer configuration and subscription options.
// make sure the ack wait is sufficient to handle the reading and processing of the batch.
// Durable is REQUIRED for pull based subscriptions
ConsumerConfiguration cc = ConsumerConfiguration.Builder()
.WithAckWait(2500)
.Build();
PullSubscribeOptions pullOptions = PullSubscribeOptions.Builder()
.WithDurable(helper.Durable) // required
.WithConfiguration(cc)
.Build();
// subscribe
IJetStreamPullSubscription sub = js.PullSubscribe(helper.Subject, pullOptions);
c.Flush(1000);
int red = 0;
while (red < helper.Count)
{
IList <Msg> list = sub.Fetch(10, 1000);
foreach (Msg m in list)
{
Console.WriteLine($"{++red}. Message: {m}");
m.Ack();
}
}
// 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("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 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 static void Main(string[] args)
{
ArgumentHelper helper = new ArgumentHelperBuilder("Pull Subscription using primitive Expires In", args, Usage)
.DefaultStream("fetch-uc-stream")
.DefaultSubject("fetch-uc-subject")
.DefaultDurable("fetch-uc-durable")
.DefaultCount(15)
.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 our JetStream context.
IJetStream js = c.CreateJetStreamContext();
// Build our consumer configuration and subscription options.
// make sure the ack wait is sufficient to handle the reading and processing of the batch.
// Durable is REQUIRED for pull based subscriptions
ConsumerConfiguration cc = ConsumerConfiguration.Builder()
.WithAckWait(2500)
.Build();
PullSubscribeOptions pullOptions = PullSubscribeOptions.Builder()
.WithDurable(helper.Durable) // required
.WithConfiguration(cc)
.Build();
// 0.1 Initialize. subscription
// 0.2 Flush outgoing communication with/to the server, useful when app is both JsUtils.Publishing and subscribing.
Console.WriteLine("\n----------\n0. Initialize the subscription and pull.");
IJetStreamPullSubscription sub = js.PullSubscribe(helper.Subject, pullOptions);
c.Flush(1000);
// 1. Fetch, but there are no messages yet.
// - Read the messages, get them all (0)
Console.WriteLine("----------\n1. There are no messages yet");
IList <Msg> messages = sub.Fetch(10, 3000);
JsUtils.Report(messages);
foreach (Msg m in messages)
{
m.Ack();
}
Console.WriteLine("We should have received 0 total messages, we received: " + messages.Count);
// 2. Publish 10 messages
// - Fetch messages, get 10
Console.WriteLine("----------\n2. Publish 10 which satisfies the batch");
JsUtils.Publish(js, helper.Subject, "A", 10);
messages = sub.Fetch(10, 3000);
JsUtils.Report(messages);
foreach (Msg m in messages)
{
m.Ack();
}
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 3. Publish 20 messages
// - Fetch messages, only get 10
Console.WriteLine("----------\n3. Publish 20 which is larger than the batch size.");
JsUtils.Publish(js, helper.Subject, "B", 20);
messages = sub.Fetch(10, 3000);
JsUtils.Report(messages);
foreach (Msg m in messages)
{
m.Ack();
}
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 4. There are still messages left from the last
// - Fetch messages, get 10
Console.WriteLine("----------\n4. Get the rest of the JsUtils.Publish.");
messages = sub.Fetch(10, 3000);
JsUtils.Report(messages);
foreach (Msg m in messages)
{
m.Ack();
}
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 5. Publish 5 messages
// - Fetch messages, get 5
// - Since there are less than batch size we only get what the server has.
Console.WriteLine("----------\n5. Publish 5 which is less than batch size.");
JsUtils.Publish(js, helper.Subject, "C", 5);
messages = sub.Fetch(10, 3000);
JsUtils.Report(messages);
foreach (Msg m in messages)
{
m.Ack();
}
Console.WriteLine("We should have received 5 total messages, we received: " + messages.Count);
// 6. Publish 15 messages
// - Fetch messages, only get 10
Console.WriteLine("----------\n6. Publish 15 which is more than the batch size.");
JsUtils.Publish(js, helper.Subject, "D", 15);
messages = sub.Fetch(10, 3000);
JsUtils.Report(messages);
foreach (Msg m in messages)
{
m.Ack();
}
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 7. There are 5 messages left
// - Fetch messages, only get 5
Console.WriteLine("----------\n7. There are 5 messages left.");
messages = sub.Fetch(10, 3000);
JsUtils.Report(messages);
foreach (Msg m in messages)
{
m.Ack();
}
Console.WriteLine("We should have received 5 messages, we received: " + messages.Count);
// 8. Read but don't ack.
// - Fetch messages, get 10, but either take too long to ack them or don't ack them
Console.WriteLine("----------\n8. Fetch but don't ack.");
JsUtils.Publish(js, helper.Subject, "E", 10);
messages = sub.Fetch(10, 3000);
JsUtils.Report(messages);
Console.WriteLine("We should have received 10 message, we received: " + messages.Count);
Thread.Sleep(3000); // longer than the ackWait
// 9. Fetch messages,
// - get the 10 messages we didn't ack
Console.WriteLine("----------\n9. Fetch, get the messages we did not ack.");
messages = sub.Fetch(10, 3000);
JsUtils.Report(messages);
foreach (Msg m in messages)
{
m.Ack();
}
Console.WriteLine("We should have received 10 message, we received: " + messages.Count);
Console.WriteLine("----------\n");
// 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("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("Pull Subscription using primitive Expires In, Use Cases", args, Usage)
.DefaultStream("expires-in-uc-stream")
.DefaultSubject("expires-in-uc-subject")
.DefaultDurable("expires-in-uc-durable")
.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 our JetStream context.
IJetStream js = c.CreateJetStreamContext();
// Build our subscription options. Durable is REQUIRED for pull based subscriptions
PullSubscribeOptions pullOptions = PullSubscribeOptions.Builder()
.WithDurable(helper.Durable) // required
.Build();
// 0.1 Initialize. subscription
// 0.2 Flush outgoing communication with/to the server, useful when app is both JsUtils.Publishing and subscribing.
// 0.3 Start the pull, you don't have to call this again because AckMode.NEXT
// - When we ack a batch message the server starts preparing or adding to the next batch.
Console.WriteLine("\n----------\n0. Initialize the subscription and pull.");
IJetStreamPullSubscription sub = js.PullSubscribe(helper.Subject, pullOptions);
c.Flush(1000);
// 1. Publish some that is less than the batch size.
Console.WriteLine("\n----------\n1. Publish some amount of messages, but not entire batch size.");
JsUtils.Publish(js, helper.Subject, "A", 6);
sub.PullExpiresIn(10, 1200);
IList <Msg> messages = JsUtils.ReadMessagesAck(sub, timeout: 2000);
Console.WriteLine("We should have received 6 total messages, we received: " + messages.Count);
// 2. Publish some more covering our pull size...
Console.WriteLine("----------\n2. Publish more than the batch size.");
sub.PullExpiresIn(10, 1200);
JsUtils.Publish(js, helper.Subject, "B", 14);
messages = JsUtils.ReadMessagesAck(sub, timeout: 2000);
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 3. There are still 4 messages from B, but the batch was finished
// - won't get any messages until a pull is issued.
Console.WriteLine("----------\n3. Read without issuing a pull.");
messages = JsUtils.ReadMessagesAck(sub, timeout: 2000);
Console.WriteLine("We should have received 0 total messages, we received: " + messages.Count);
// 4. re-issue the pull to get the last 4
Console.WriteLine("----------\n4. Issue the pull to get the last 4.");
sub.PullExpiresIn(10, 1200);
messages = JsUtils.ReadMessagesAck(sub, timeout: 2000);
Console.WriteLine("We should have received 4 total messages, we received: " + messages.Count);
// 5. publish a lot of messages
Console.WriteLine("----------\n5. Publish a lot of messages. The last pull was under the batch size.");
Console.WriteLine(" Issue another pull with batch size less than number of messages.");
JsUtils.Publish(js, helper.Subject, "C", 25);
sub.PullExpiresIn(10, 1200);
messages = JsUtils.ReadMessagesAck(sub, timeout: 2000);
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 6. there are still more messages
Console.WriteLine("----------\n6. Still more messages. Issue another pull with batch size less than number of messages.");
sub.PullExpiresIn(10, 1200);
messages = JsUtils.ReadMessagesAck(sub, timeout: 2000);
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 7. there are still more messages
Console.WriteLine("----------\n7. Still more messages. Issue another pull with batch size more than number of messages.");
sub.PullExpiresIn(10, 1200);
messages = JsUtils.ReadMessagesAck(sub, timeout: 2000);
Console.WriteLine("We should have received 5 total messages, we received: " + messages.Count);
// 8. we got them all
Console.WriteLine("----------\n8. No messages left.");
sub.PullExpiresIn(10, 1200);
messages = JsUtils.ReadMessagesAck(sub, timeout: 2000);
Console.WriteLine("We should have received 0 total messages, we received: " + messages.Count);
Console.WriteLine("----------\n");
// 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("Pull Subscription using primitive No Wait, Use Cases", args, Usage)
.DefaultStream("nowait-uc-stream")
.DefaultSubject("nowait-uc-subject")
.DefaultDurable("nowait-uc-durable")
.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 our JetStream context.
IJetStream js = c.CreateJetStreamContext();
// Build our subscription options. Durable is REQUIRED for pull based subscriptions
PullSubscribeOptions pullOptions = PullSubscribeOptions.Builder()
.WithDurable(helper.Durable) // required
.Build();
// 0.1 Initialize. subscription
// 0.2 DO NOT start the pull, no wait works differently than regular pull.
// With no wait, we have to start the pull the first time and every time the
// batch size is exhausted or no waits out.
// 0.3 Flush outgoing communication with/to the server, useful when app is both publishing and subscribing.
Console.WriteLine("\n----------\n0. Initialize the subscription and pull.");
IJetStreamPullSubscription sub = js.PullSubscribe(helper.Subject, pullOptions);
c.Flush(1000);
// 1. Start the pull, but there are no messages yet.
// - Read the messages
// - Since there are less than the batch size, we get them all (0)
Console.WriteLine("----------\n1. There are no messages yet");
sub.PullNoWait(10);
IList <Msg> messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 0 total messages, we received: " + messages.Count);
// 2. Publish 10 messages
// - Start the pull
// - Read the messages
// - Since there are exactly the batch size we get them all
Console.WriteLine("----------\n2. Publish 10 which satisfies the batch");
JsUtils.Publish(js, helper.Subject, "A", 10);
sub.PullNoWait(10);
messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 3. Publish 20 messages
// - Start the pull
// - Read the messages
Console.WriteLine("----------\n3. Publish 20 which is larger than the batch size.");
JsUtils.Publish(js, helper.Subject, "B", 20);
sub.PullNoWait(10);
messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 4. There are still messages left from the last
// - Start the pull
// - Read the messages
Console.WriteLine("----------\n4. Get the rest of the publish.");
sub.PullNoWait(10);
messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 5. Publish 5 messages
// - Start the pull
// - Read the messages
Console.WriteLine("----------\n5. Publish 5 which is less than batch size.");
JsUtils.Publish(js, helper.Subject, "C", 5);
sub.PullNoWait(10);
messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 5 total messages, we received: " + messages.Count);
// 6. Publish 14 messages
// - Start the pull
// - Read the messages
// - we do NOT get a nowait status message if there are more or equals messages than the batch
Console.WriteLine("----------\n6. Publish 14 which is more than the batch size.");
JsUtils.Publish(js, helper.Subject, "D", 14);
sub.PullNoWait(10);
messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 10 total messages, we received: " + messages.Count);
// 7. There are 4 messages left
// - Start the pull
// - Read the messages
// - Since there are less than batch size the last message we get will be a status 404 message.
Console.WriteLine("----------\n7. There are 4 messages left, which is less than the batch size.");
sub.PullNoWait(10);
messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 4 messages, we received: " + messages.Count);
Console.WriteLine("----------\n");
// 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("Pull Subscription using primitive Expires In", args, Usage)
.DefaultStream("expires-in-stream")
.DefaultSubject("expires-in-subject")
.DefaultDurable("expires-in-durable")
.DefaultCount(15)
.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 our JetStream context.
IJetStream js = c.CreateJetStreamContext();
// Start publishing the messages, don't wait for them to finish, simulating an outside producer.
JsUtils.PublishInBackground(js, helper.Subject, "expires-in-message", helper.Count);
// Build our subscription options. Durable is REQUIRED for pull based subscriptions
PullSubscribeOptions pullOptions = PullSubscribeOptions.Builder()
.WithDurable(helper.Durable) // required
.Build();
// subscribe
IJetStreamPullSubscription sub = js.PullSubscribe(helper.Subject, pullOptions);
c.Flush(1000);
bool keepGoing = true;
int red = 0;
while (keepGoing && red < helper.Count)
{
sub.PullExpiresIn(10, 1000);
int round = 0;
while (keepGoing && round < 10)
{
try
{
Msg m = sub.NextMessage(1000); // first message
Console.WriteLine($"{++red}. Message: {m}");
m.Ack();
round++;
}
catch (NATSTimeoutException) // timeout means there are no messages available
{
keepGoing = false;
}
}
}
// 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("JetStream Publish With Options Use Cases", args, Usage)
.DefaultStream("pubopts-stream")
.DefaultSubject("pubopts-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);
// get a regular context
IJetStream js = c.CreateJetStreamContext();
PublishOptions.PublishOptionsBuilder builder = PublishOptions.Builder()
.WithExpectedStream(helper.Stream)
.WithMessageId("mid1");
PublishAck pa = js.Publish(helper.Subject, Encoding.ASCII.GetBytes("message1"), builder.Build());
Console.WriteLine("Published message on subject {0}, stream {1}, seqno {2}.",
helper.Subject, pa.Stream, pa.Seq);
// IMPORTANT!
// You can reuse the builder in 2 ways.
// 1. Manually set a field to null or to DefaultLastSequence if you want to clear it out.
// 2. Use the clearExpected method to clear the expectedLastId, expectedLastSequence and messageId fields
// Manual re-use 1. Clearing some fields
builder
.WithExpectedLastMsgId("mid1")
.WithExpectedLastSequence(PublishOptions.DefaultLastSequence)
.WithMessageId(null);
pa = js.Publish(helper.Subject, Encoding.ASCII.GetBytes("message2"), builder.Build());
Console.WriteLine("Published message on subject {0}, stream {1}, seqno {2}.",
helper.Subject, pa.Stream, pa.Seq);
// Manual re-use 2. Setting all the expected fields again
builder
.WithExpectedLastMsgId(null)
.WithExpectedLastSequence(PublishOptions.DefaultLastSequence)
.WithMessageId("mid3");
pa = js.Publish(helper.Subject, Encoding.ASCII.GetBytes("message3"), builder.Build());
Console.WriteLine("Published message on subject {0}, stream {1}, seqno {2}.",
helper.Subject, pa.Stream, pa.Seq);
// reuse() method clears all the fields, then we set some fields.
builder.ClearExpected()
.WithExpectedLastSequence(pa.Seq)
.WithMessageId("mid4");
pa = js.Publish(helper.Subject, Encoding.ASCII.GetBytes("message4"), builder.Build());
Console.WriteLine("Published message on subject {0}, stream {1}, seqno {2}.",
helper.Subject, pa.Stream, pa.Seq);
// exception when the expected stream does not match [10060]
try
{
PublishOptions errOpts = PublishOptions.Builder().WithExpectedStream("wrongStream").Build();
js.Publish(helper.Subject, Encoding.ASCII.GetBytes("ex1"), errOpts);
}
catch (NATSJetStreamException e)
{
Console.WriteLine($"Exception was: '{e.ErrorDescription}'");
}
// exception with wrong last msg ID [10070]
try
{
PublishOptions errOpts = PublishOptions.Builder().WithExpectedLastMsgId("wrongId").Build();
js.Publish(helper.Subject, Encoding.ASCII.GetBytes("ex2"), errOpts);
}
catch (NATSJetStreamException e)
{
Console.WriteLine($"Exception was: '{e.ErrorDescription}'");
}
// exception with wrong last sequence wrong last sequence: 4 [10071]
try
{
PublishOptions errOpts = PublishOptions.Builder().WithExpectedLastSequence(999).Build();
js.Publish(helper.Subject, Encoding.ASCII.GetBytes("ex3"), errOpts);
}
catch (NATSJetStreamException e)
{
Console.WriteLine($"Exception was: '{e.ErrorDescription}'");
}
// 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("JetStream Manage Consumers", args, Usage)
.DefaultStream("mcon-stream")
.DefaultSubject("mcon-subject")
.DefaultDurable("mcon-durable-")
.Build();
try
{
string durable1 = helper.Durable + "1";
string durable2 = helper.Durable + "2";
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);
// 1. Add Consumers
Console.WriteLine("----------\n1. Configure And Add Consumers");
ConsumerConfiguration cc = ConsumerConfiguration.Builder()
.WithDurable(durable1) // durable name is required when creating consumers
.Build();
ConsumerInfo ci = jsm.AddOrUpdateConsumer(helper.Stream, cc);
PrintConsumerInfo(ci);
cc = ConsumerConfiguration.Builder()
.WithDurable(durable2)
.Build();
ci = jsm.AddOrUpdateConsumer(helper.Stream, cc);
PrintObject(ci);
// 2. get a list of ConsumerInfo's for all consumers
Console.WriteLine("\n----------\n2. getConsumers");
IList <ConsumerInfo> consumers = jsm.GetConsumers(helper.Stream);
PrintConsumerInfoList(consumers);
// 3. get a list of all consumers
Console.WriteLine("\n----------\n3. getConsumerNames");
IList <string> consumerNames = jsm.GetConsumerNames(helper.Stream);
Console.WriteLine("Consumer Names: " + String.Join(",", consumerNames));
// 4. Delete a consumer, then list them again
// Subsequent calls to deleteStream will throw a
// NATSJetStreamException [10014]
Console.WriteLine("\n----------\n4. Delete a consumer");
jsm.DeleteConsumer(helper.Stream, durable1);
consumerNames = jsm.GetConsumerNames(helper.Stream);
Console.WriteLine("Consumer Names: " + String.Join(",", consumerNames));
// 5. Try to delete the consumer again and get the exception
Console.WriteLine("\n----------\n5. Delete consumer again");
try
{
jsm.DeleteConsumer(helper.Stream, durable1);
}
catch (NATSJetStreamException e)
{
Console.WriteLine($"Exception was: '{e.ErrorDescription}'");
}
Console.WriteLine("\n----------");
// 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("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);
}
}
public static void Main(string[] args)
{
ArgumentHelper helper = new ArgumentHelperBuilder("Pull Subscription using primitive Batch Size, Use Cases", args, Usage)
.DefaultStream("pull-stream")
.DefaultSubject("pull-subject")
.DefaultDurable("pull-durable")
.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 our JetStream context.
IJetStream js = c.CreateJetStreamContext();
// Build our subscription options. Durable is REQUIRED for pull based subscriptions
PullSubscribeOptions pullOptions = PullSubscribeOptions.Builder()
.WithDurable(helper.Durable) // required
.Build();
// 0.1 Initialize. subscription
// 0.2 Flush outgoing communication with/to the server, useful when app is both JsUtils.Publishing and subscribing.
// 0.3 Start the pull, you don't have to call this again because AckMode.NEXT
// - When we ack a batch message the server starts preparing or adding to the next batch.
Console.WriteLine("\n----------\n0. Initialize the subscription and pull.");
IJetStreamPullSubscription sub = js.PullSubscribe(helper.Subject, pullOptions);
c.Flush(1000);
sub.Pull(10);
// 1. JsUtils.Publish some that is less than the batch size.
// - Do this first as data will typically be published first.
Console.WriteLine("----------\n1. JsUtils.Publish some amount of messages, but not entire batch size.");
JsUtils.Publish(js, helper.Subject, "A", 4);
IList <Msg> messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 4 total messages, we received: " + messages.Count);
// 2. JsUtils.Publish some more covering our pull size...
// - Read what is available, expect only 6 b/c 4 + 6 = 10
Console.WriteLine("----------\n2. JsUtils.Publish more than the remaining batch size.");
JsUtils.Publish(js, helper.Subject, "B", 10);
messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 6 total messages, we received: " + messages.Count);
// 3. There are still 4 messages from B, but the batch was finished
// - won't get any messages until a pull is issued.
Console.WriteLine("----------\n3. Read without re-issue.");
messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 0 total messages, we received: " + messages.Count);
// 4. re-issue the pull to get the last 4
Console.WriteLine("----------\n4. Re-issue to get the last 4.");
sub.Pull(10);
messages = JsUtils.ReadMessagesAck(sub);
Console.WriteLine("We should have received 4 total messages, we received: " + messages.Count);
Console.WriteLine("----------\n");
// delete the stream since we are done with it.
jsm.DeleteStream(helper.Stream);
}
}
catch (Exception ex)
{
helper.ReportException(ex);
}
}
