public void TestDefaultBuilder()
{
var po = PublishOptions.Builder().Build();
Assert.Equal(PublishOptions.DefaultLastSequence, po.ExpectedLastSeq);
Assert.Equal(PublishOptions.DefaultLastSequence, po.ExpectedLastSubjectSeq);
Assert.Equal(PublishOptions.DefaultStream, po.ExpectedStream);
Assert.Equal(PublishOptions.DefaultTimeout, po.StreamTimeout);
Assert.Null(po.ExpectedLastMsgId);
Assert.Null(po.MessageId);
Assert.Null(po.Stream);
}
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 TestInvalidBuilderArgs()
{
Assert.Throws <ArgumentException>(() => PublishOptions.Builder().
WithMessageId("").
Build());
Assert.Throws <ArgumentException>(() => PublishOptions.Builder().
WithStream("stream.*").
Build());
Assert.Throws <ArgumentException>(() => PublishOptions.Builder().
WithStream("stream.>").
Build());
Assert.Throws <ArgumentException>(() => PublishOptions.Builder().
WithStream("stream.one").
Build());
}
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 TestValidBuilderArgs()
{
PublishOptions.PublishOptionsBuilder builder = PublishOptions.Builder()
.WithExpectedStream("expectedstream")
.WithExpectedLastMsgId("expectedmsgid")
.WithExpectedLastSequence(42)
.WithExpectedLastSubjectSequence(43)
.WithMessageId("msgid")
.WithStream("stream")
.WithTimeout(5150);
var po = builder.Build();
Assert.Equal("expectedstream", po.ExpectedStream);
Assert.Equal("expectedmsgid", po.ExpectedLastMsgId);
Assert.Equal(42ul, po.ExpectedLastSeq);
Assert.Equal(43ul, po.ExpectedLastSubjectSeq);
Assert.Equal("msgid", po.MessageId);
Assert.Equal("stream", po.Stream);
Assert.Equal(5150, po.StreamTimeout.Millis);
po = builder.ClearExpected().Build();
Assert.Null(po.ExpectedLastMsgId);
Assert.Equal(PublishOptions.DefaultLastSequence, po.ExpectedLastSeq);
Assert.Equal(PublishOptions.DefaultLastSequence, po.ExpectedLastSubjectSeq);
Assert.Null(po.MessageId);
Assert.Equal("stream", po.Stream);
po = PublishOptions.Builder().
WithTimeout(Duration.OfMillis(5150)).
Build();
Assert.Equal(Duration.OfMillis(5150), po.StreamTimeout);
// check to allow -
PublishOptions.Builder().
WithExpectedStream("test-stream").
Build();
}
public async Task <OperateResult> SendAsync(TransportMessage message)
{
var connection = _connectionPool.RentConnection();
try
{
var msg = new Msg(message.GetName(), message.Body);
foreach (var header in message.Headers)
{
msg.Header[header.Key] = header.Value;
}
var js = connection.CreateJetStreamContext(_jetStreamOptions);
var builder = PublishOptions.Builder().WithMessageId(message.GetId());
var resp = await js.PublishAsync(msg, builder.Build());
if (resp.Seq > 0)
{
_logger.LogDebug($"NATS stream message [{message.GetName()}] has been published.");
return(OperateResult.Success);
}
throw new PublisherSentFailedException("NATS message send failed, no consumer reply!");
}
catch (Exception ex)
{
var warpEx = new PublisherSentFailedException(ex.Message, ex);
return(OperateResult.Failed(warpEx));
}
finally
{
_connectionPool.Return(connection);
}
}
public void TestPublishMiscExceptions()
{
Context.RunInJsServer(c =>
{
CreateDefaultTestStream(c);
IJetStream js = c.CreateJetStreamContext();
// stream supplied and matches
PublishOptions po = PublishOptions.Builder()
.WithStream(STREAM)
.Build();
js.Publish(SUBJECT, DataBytes(999), po);
// mismatch stream to PO stream
po = PublishOptions.Builder()
.WithStream(Stream(999))
.Build();
Assert.Throws <NATSJetStreamException>(() => js.Publish(SUBJECT, DataBytes(999), po));
// invalid subject
Assert.Throws <NATSNoRespondersException>(() => js.Publish(Subject(999), DataBytes(999)));
});
}
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 void TestPublishExpectations()
{
Context.RunInJsServer(c =>
{
CreateMemoryStream(c, STREAM, Subject(1), Subject(2));
IJetStream js = c.CreateJetStreamContext();
PublishOptions po = PublishOptions.Builder()
.WithExpectedStream(STREAM)
.WithMessageId(MessageId(1))
.Build();
PublishAck pa = js.Publish(Subject(1), DataBytes(1), po);
AssertPublishAck(pa, 1);
po = PublishOptions.Builder()
.WithExpectedLastMsgId(MessageId(1))
.WithMessageId(MessageId(2))
.Build();
pa = js.Publish(Subject(1), DataBytes(2), po);
AssertPublishAck(pa, 2);
po = PublishOptions.Builder()
.WithExpectedLastSequence(2)
.WithMessageId(MessageId(3))
.Build();
pa = js.Publish(Subject(1), DataBytes(3), po);
AssertPublishAck(pa, 3);
po = PublishOptions.Builder()
.WithExpectedLastSequence(3)
.WithMessageId(MessageId(4))
.Build();
pa = js.Publish(Subject(2), DataBytes(4), po);
AssertPublishAck(pa, 4);
po = PublishOptions.Builder()
.WithExpectedLastSubjectSequence(3)
.WithMessageId(MessageId(5))
.Build();
pa = js.Publish(Subject(1), DataBytes(5), po);
AssertPublishAck(pa, 5);
po = PublishOptions.Builder()
.WithExpectedLastSubjectSequence(4)
.WithMessageId(MessageId(6))
.Build();
pa = js.Publish(Subject(2), DataBytes(6), po);
AssertPublishAck(pa, 6);
PublishOptions po1 = PublishOptions.Builder().WithExpectedStream(Stream(999)).Build();
Assert.Throws <NATSJetStreamException>(() => js.Publish(Subject(1), DataBytes(999), po1));
PublishOptions po2 = PublishOptions.Builder().WithExpectedLastMsgId(MessageId(999)).Build();
Assert.Throws <NATSJetStreamException>(() => js.Publish(Subject(1), DataBytes(999), po2));
PublishOptions po3 = PublishOptions.Builder().WithExpectedLastSequence(999).Build();
Assert.Throws <NATSJetStreamException>(() => js.Publish(Subject(1), DataBytes(999), po3));
PublishOptions po4 = PublishOptions.Builder().WithExpectedLastSubjectSequence(999).Build();
Assert.Throws <NATSJetStreamException>(() => js.Publish(Subject(1), DataBytes(999), po4));
});
}
