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));
});
}
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));
});
}
private static void PubAsync(Context ctx, IConnection c, Stats stats, int id)
{
IJetStream js = c.CreateJetStreamContext(ctx.GetJetStreamOptions());
Publisher <Task <PublishAck> > publisher;
if (ctx.LatencyFlag)
{
publisher = (s, p) => js.PublishAsync(BuildLatencyMessage(s, p));
}
else
{
publisher = js.PublishAsync;
}
string label = ctx.GetLabel(id);
List <Task <PublishAck> > futures = new List <Task <PublishAck> >();
int roundCount = 0;
int pubTarget = ctx.GetPubCount(id);
int published = 0;
int unReported = 0;
while (published < pubTarget)
{
if (++roundCount >= ctx.RoundSize)
{
ProcessFutures(futures, stats);
roundCount = 0;
}
Jitter(ctx);
byte[] payload = ctx.GetPayload();
stats.Start();
futures.Add(publisher.Invoke(ctx.Subject, payload));
stats.StopAndCount(ctx.PayloadSize);
unReported = ReportMaybe(label, ctx, ++published, ++unReported, "Published");
}
Report(label, published, "Completed Publishing");
}
public static void Main(string[] args)
{
ArgumentHelper helper = new ArgumentHelperBuilder("JetStream Publish Async", args, Usage)
.DefaultStream("example-stream")
.DefaultSubject("example-subject")
.DefaultPayload("Hello")
.DefaultCount(10)
.Build();
try
{
using (IConnection c = new ConnectionFactory().CreateConnection(helper.MakeOptions()))
{
// Use the utility to create a stream stored in memory.
JsUtils.CreateStreamOrUpdateSubjects(c, helper.Stream, helper.Subject);
// create a JetStream context
IJetStream js = c.CreateJetStreamContext();
IList <Task <PublishAck> > tasks = new List <Task <PublishAck> >();
int stop = helper.Count < 2 ? 2 : helper.Count + 1;
for (int x = 1; x < stop; x++)
{
// make unique message data if you want more than 1 message
byte[] data = helper.Count < 2
? Encoding.UTF8.GetBytes(helper.Payload)
: Encoding.UTF8.GetBytes(helper.Payload + "-" + x);
// Publish a message and print the results of the publish acknowledgement.
Msg msg = new Msg(helper.Subject, null, helper.Header, data);
// We'll use the defaults for this simple example, but there are options
// to constrain publishing to certain streams, expect sequence numbers and
// more. See the JetStreamPublishWithOptionsUseCases example for details.
// An exception will be thrown if there is a failure.
tasks.Add(js.PublishAsync(msg));
while (tasks.Count > 0)
{
Task <PublishAck> task = tasks[0];
tasks.RemoveAt(0);
if (task.IsCompleted)
{
try
{
PublishAck pa = task.Result;
Console.WriteLine("Published message {0} on subject {1}, stream {2}, seqno {3}.",
Encoding.UTF8.GetString(data), helper.Subject, pa.Stream, pa.Seq);
}
catch (Exception e)
{
Console.WriteLine("Publish Failed: " + e);
}
}
else
{
// re queue so will be checked for completed again
tasks.Add(task);
}
}
}
}
}
catch (Exception ex)
{
helper.ReportException(ex);
}
}