public string Publish(string subject, byte[] data, EventHandler <StanAckHandlerArgs> handler)
{
if (conn != null && conn.NATSConnection.State == ConnState.CONNECTED)
{
subject = $"{producID}_{subject}";
return(conn.Publish(subject, data, handler));
}
else
{
return(null);
}
}
public void Publish <T>(string queueName, T t)
{
if (string.IsNullOrEmpty(queueName))
{
throw new ArgumentException("invalid queue name", nameof(queueName));
}
using (var memoryStream = new MemoryStream())
{
var binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(memoryStream, t);
_connection.Publish(queueName, memoryStream.GetBuffer());
}
}
/// <summary>
/// Publish publishes the data argument to the given subject. The data
/// argument is left untouched and needs to be correctly interpreted on
/// the receiver. This API is asynchronous and handles the acknowledgement
/// or error from the NATS streaming server in the provided handler. An exception is thrown when
/// an error occurs during the send, the handler will process acknowledgments and errors.
/// </summary>
/// <typeparam name="TMessage">The message type.</typeparam>
/// <param name="connection">The conmnection.</param>
/// <param name="subject">Subject to publish the message to.</param>
/// <param name="data">Message payload.</param>
/// <param name="handler">Event handler to process message acknowledgements.</param>
/// <returns>The GUID of the published message.</returns>
/// <exception cref="StanException">Thrown when an error occurs publishing the message.</exception>
public static string Publish <TMessage>(this IStanConnection connection, string subject, TMessage data, EventHandler <StanAckHandlerArgs> handler)
where TMessage : class, IRoundtripData, new()
{
Covenant.Requires <ArgumentNullException>(data != null);
return(connection.Publish(subject, data.ToBytes(), handler));
}
//---------------------------------------------------------------------
// IStanConnection extensions
/// <summary>
/// Publish publishes the data argument to the given subject. The data
/// argument is left untouched and needs to be correctly interpreted on
/// the receiver. This API is synchronous and waits for the acknowledgement
/// or error from the NATS streaming server.
/// </summary>
/// <typeparam name="TMessage">The message type.</typeparam>
/// <param name="connection">The conmnection.</param>
/// <param name="subject">Subject to publish the message to.</param>
/// <param name="data">Message payload.</param>
/// <exception cref="StanException">When an error occurs locally or on the NATS streaming server.</exception>
public static void Publish <TMessage>(this IStanConnection connection, string subject, TMessage data)
where TMessage : class, IRoundtripData, new()
{
Covenant.Requires <ArgumentNullException>(data != null);
connection.Publish(subject, data.ToBytes());
}
internal void SendMessages(string url, string clusterID)
{
IStanConnection sc = null;
sc = CreateConnection(url, clusterID, "synadia-rel-publisher");
for (int i = 0; !IsFinished(); i++)
{
try
{
sc.Publish("synadia.restest", payload, (obj, args) => { /* NOOP */ });
// sync publish for long running stability
// sc.Publish("synadia.restest", payload); ;
}
catch (Exception e)
{
Log("Publish Exception: " + e.Message);
Thread.Sleep(250);
}
if (i % 500 == 0)
{
Log("Publisher Sent {0} messages to the streaming server.", i);
PrintResourceStats();
}
}
sc?.Close();
Log("Publisher is finished.");
}
static void TestSTAN(IStanConnection conn)
{
Task.Run(async() =>
{
var i = 0;
while (true)
{
try
{
string guid = conn.Publish("stest", UTF8Encoding.UTF8.GetBytes(i.ToString()), null);
await Task.Delay(1000);
i++;
}
catch (Exception err)
{
Console.WriteLine(err);
}
}
});
var sOpts = StanSubscriptionOptions.GetDefaultOptions();
sOpts.AckWait = 60000;
var s = conn.Subscribe("stest", sOpts, (obj, msgArs) =>
{
Console.WriteLine(UTF8Encoding.UTF8.GetString(msgArs.Message.Data));
});
}
public Program(string[] args)
{
var clientId = "";
var topic = "sample";
if (args.Length > 1)
{
topic = args[1];
}
if (args.Length > 2)
{
clientId = args[2];
}
var cf = new StanConnectionFactory();
var options = StanOptions.GetDefaultOptions();
options.ConnectTimeout = 1000;
options.NatsURL = "nats://*****:*****@localhost:4222";
IStanConnection connection = cf.CreateConnection("test-cluster", clientId, options);
if (args.Length > 0 && args[0] == "send")
{
while (true)
{
connection.Publish(topic, Encoding.UTF8.GetBytes("Hello NATS " + Guid.NewGuid().ToString()));
Console.WriteLine("Message sent to topic: " + topic);
Thread.Sleep(500);
}
}
else
{
var subName = "subscription-1";
if (args.Length > 0)
{
subName = args[0];
}
EventHandler <StanMsgHandlerArgs> eh = (sender, argsMsg) =>
{
var body = Encoding.UTF8.GetString(argsMsg.Message.Data);
// TODO: Handle headers in right way
Console.WriteLine(body);
Thread.Sleep(1000);
argsMsg.Message.Ack();
};
var opts = StanSubscriptionOptions.GetDefaultOptions();
opts.DurableName = subName;
opts.ManualAcks = true;
opts.AckWait = 60000;
opts.MaxInflight = 1;
IStanSubscription subscription = subscription = connection.Subscribe(topic, subName, opts, eh);
}
}
public void Subscribe()
{
Assert.Equal(ConnState.CONNECTED, connection.NATSConnection.State);
StanMsg <Person> received = null;
using (var subscription = connection.Subscribe <Person>("subject",
(sender, args) =>
{
received = args.Msg;
received.Ack();
}))
{
var jack = new Person()
{
Id = 1,
Name = "Jack",
Age = 10,
Data = new byte[] { 0, 1, 2, 3, 4 }
};
connection.Publish("subject", jack);
NeonHelper.WaitFor(() => received != null, TimeSpan.FromSeconds(5));
Assert.True(received.Data == jack);
}
}
private void PublishBusinessEvent(BusinessEvent e)
{
string eventType = e.GetType().Name;
string eventData = JsonSerializer.Serialize(e, e.GetType());
// create message
// Event-type is embedded in the message:
// <event-type>#<value>|<value>|<value>
string body = $"{eventType}#{eventData}";
byte[] message = Encoding.UTF8.GetBytes(body);
_stanConnection.Publish("store.events", message);
}
public void Update(string orderNumber, BusinessEvent e)
{
try
{
string eventType = e.GetType().Name;
string eventData = JsonSerializer.Serialize(e, e.GetType());
string message = $"{eventType}#{eventData}";
_stanConnection.Publish(EVENTSTREAM_SUBJECT, Encoding.UTF8.GetBytes(message));
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
}
public void Start()
{
var messageNumber = _repository.GetLastMessageNumber();
_connection = _connectionProvider.GetConnection();
_cancellationTokenSource = new CancellationTokenSource();
Task.Run(async() =>
{
while (!_cancellationTokenSource.IsCancellationRequested)
{
var message = GenerateMessage(++messageNumber);
byte[] payload = MessagePackSerializer.Serialize(message);
_connection.Publish("PostTechnology.EventBus", payload);
_monitor?.Information(message);
await _repository.Add(message);
await Task.Delay(1000, _cancellationTokenSource.Token);
}
}, _cancellationTokenSource.Token);
}
public string Publish(string subject, byte[] data, EventHandler <StanAckHandlerArgs> handler)
{
subject = $"{productID}_{subject}";
return(conn.Publish(subject, data, handler));
}
public void Publish(string subject, T data)
{
_stanClient.Publish(subject, Encoding.UTF8.GetBytes(JsonSerializer.Serialize <T>(data)));
}
