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))); }