static void Main(string[] args)
{
string clientId = $"producer-{Guid.NewGuid().ToString()}";
var cf = new StanConnectionFactory();
StanOptions options = StanOptions.GetDefaultOptions();
options.NatsURL = "nats://localhost:4222";
using (var c = cf.CreateConnection("test-cluster", clientId, options))
{
do
{
var opts = StanSubscriptionOptions.GetDefaultOptions();
opts.StartWithLastReceived();
var s = c.Subscribe("nats.streaming.demo.client", opts, (obj, arguments) =>
{
string message = Encoding.UTF8.GetString(arguments.Message.Data);
Console.WriteLine(message);
});
c.Publish("nats.streaming.demo", Encoding.UTF8.GetBytes("Published from the publisher"));
Thread.Sleep(10000);
} while (true);
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
string clientId = $"producer-{Guid.NewGuid().ToString()}";
StanOptions stanOptions = StanOptions.GetDefaultOptions();
stanOptions.NatsURL = _natsOptions.Url;
using (var c = new StanConnectionFactory()
.CreateConnection(_natsOptions.ClusterId, clientId, stanOptions))
{
while (!cancellationToken.IsCancellationRequested)
{
var message = new Message();
await _messageRepository.AddAsync(message);
var json = JsonSerializer.Serialize(message);
Console.WriteLine($"Отправка {json}");
c.Publish(_natsOptions.Subject, Encoding.UTF8.GetBytes(json));
await Task.Delay(1000);
}
_logger.LogInformation("Отправка сообщений отменена.");
}
}
private async Task RxSubscriber(string dataCentre, CancellationToken token)
{
var clusterId = "test-cluster";
var clientId = Guid.NewGuid().ToString("N");
var stanOptions = StanOptions.GetDefaultOptions();
stanOptions.NatsURL = _natsClusterNodes[dataCentre];
using var stanConnection = new StanConnectionFactory().CreateConnection(clusterId, clientId, stanOptions);
var messagesSubject = stanConnection.Observe("foo");
var loopCount = 0;
messagesSubject.Subscribe(onNext: (message) =>
{
Console.WriteLine(
$"{dataCentre}: received '{System.Text.Encoding.UTF8.GetString(message.Data)}'. Redelivered: {message.Redelivered}. Sequence: {message.Sequence}");
Console.WriteLine($"loopCount: {Interlocked.Increment(ref loopCount)}");
});
await Task.Delay(1000000, token);
Console.WriteLine("Exiting subscription");
}
static void Main(string[] args)
{
// run docker run --rm --name natstest -p 4222:4222 -p 8222:8222 nats-streaming -store file -dir ./data --max_msgs 0 --max_bytes 0 --cluster_id scarsnatscluster
var cf = new StanConnectionFactory();
var c = cf.CreateConnection("mynatscluster", "my-publish");
// when the server responds with an acknowledgement, this
// handler will be invoked.
EventHandler <StanAckHandlerArgs> ackHandler = (obj, natsargs) =>
{
if (!string.IsNullOrEmpty(natsargs.Error))
{
Console.WriteLine("Published Msg {0} failed: {1}",
natsargs.GUID, natsargs.Error);
}
// handle success - correlate the send with the guid..
//Console.WriteLine("Published msg {0} was stored on the server.");
};
int i = 0;
// returns immediately
while (true)
{
string guid = c.Publish("my.log.error", System.Text.Encoding.UTF8.GetBytes(i.ToString() + " - This error sucks!"), ackHandler);
Console.WriteLine("{1} - Published msg {0} was stored on the server.", guid, i.ToString());
i++;
System.Threading.Thread.Sleep(new TimeSpan(0, 0, 5));
}
}
// .\nats-streaming-server.exe -cid cluster-teste-local -store file -dir dados-cluster-teste-local
static void Main(string[] args)
{
string CLUSTER_ID = "cluster-teste-local";
string CLIENT_ID = "Producer-" + DateTime.Now.Second;
string SUBJECT = "subject-test";
string URL_NATS = "nats://localhost:4222";
var cf = new StanConnectionFactory();
StanOptions stanOptions = StanOptions.GetDefaultOptions();
stanOptions.NatsURL = URL_NATS;
Console.WriteLine($"Connecting (URL_NATS = {URL_NATS}) ...");
Console.WriteLine($"CLUSTER_ID = {CLUSTER_ID}");
Console.WriteLine($"CLIENT_ID = {CLIENT_ID}");
using (var c = cf.CreateConnection(CLUSTER_ID, CLIENT_ID, stanOptions))
{
Random r = new Random();
while (true)
{
var msgId = r.Next();
string msg = CLIENT_ID + "-" + msgId.ToString();
c.Publish(SUBJECT, Encoding.UTF8.GetBytes(msg));
Console.WriteLine($"Msg published on {SUBJECT} : {msg}");
Thread.Sleep(1000);
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Starting subsriber app...");
var natsConnectionOptions = StanOptions.GetDefaultOptions();
natsConnectionOptions.NatsURL = "nats://localhost:4222";
natsConnectionOptions.ServerHeartbeatTimeoutCallback = () =>
{
Console.WriteLine("Hurrr... connection problem!");
};
natsConnectionOptions.ServerHeartbeatTimeoutMillis = 10000;
var stanConnection = new StanConnectionFactory().CreateConnection("test-cluster", $"subscirber-name", natsConnectionOptions);
var options = StanSubscriptionOptions.GetDefaultOptions();
stanConnection.Subscribe($"some-channel", options, (sender, e) =>
{
Console.WriteLine("Message received...");
});
Console.WriteLine("Started... Hit any key to quit.");
Console.ReadKey();
}
static void Main(string[] args)
{
string serverURL = "nats://localhost:4222", clusterID = "test-cluster", clientID = "pub_client", subject = "foo_subject";
StanOptions cOpts = StanOptions.GetDefaultOptions();
cOpts.NatsURL = serverURL;
using (var c = new StanConnectionFactory().CreateConnection(clusterID, clientID, cOpts))
{
Console.WriteLine("nats: connected serverURL='{0}', clusterID='{1}', clientID='{2}'", serverURL, clusterID, clientID);
// publish message
var ev = new AutoResetEvent(false);
var seq = 0;
var thread = new Thread(obj =>
{
do
{
var msg = string.Format("message [#{0}]", ++seq);
c.Publish(subject, System.Text.Encoding.UTF8.GetBytes(msg));
Console.WriteLine("nats: published subject='{0}', message='{1}'", subject, msg);
} while (!ev.WaitOne(TimeSpan.FromSeconds(5)));
});
thread.Start();
// wait for exit
Console.WriteLine("program: press <enter> to exit...");
Console.ReadLine();
ev.Set();
thread.Join();
}
}
public void Start()
{
// connect to STAN
var cf = new StanConnectionFactory();
var natsOptions = StanOptions.GetDefaultOptions();
natsOptions.NatsURL = "nats://localhost:4223";
_stanConnection = cf.CreateConnection("test-cluster", "ShippingService", natsOptions);
// create events subscription
StanSubscriptionOptions stanOptions = StanSubscriptionOptions.GetDefaultOptions();
stanOptions.DurableName = "ShippingService";
// determine where to start reading in the event-stream
ulong?lastSeqNr = GetLastSequenceNumber();
if (lastSeqNr != null)
{
lastSeqNr++;
stanOptions.StartAt(lastSeqNr.Value);
Console.WriteLine($"Replaying from seq# {lastSeqNr}");
}
else
{
stanOptions.DeliverAllAvailable();
Console.WriteLine("Replaying all messages.");
}
_stanConnection.Subscribe("store.events", stanOptions, EventReceived);
}
public static void Main(string[] args)
{
Console.WriteLine($"NATS Monitor Tool - v1.2");
if (args == null || !args.Any())
{
Console.WriteLine("Need argument!");
Environment.Exit(1);
}
_eventName = args[0];
if (args.Length > 1)
{
URL = $"nats://{args[1]}";
}
var scf = new StanConnectionFactory();
var options = StanOptions.GetDefaultOptions();
options.NatsURL = URL;
var clientId = Environment.MachineName;
var stanConnection = scf.CreateConnection("events-streaming",
$"{clientId}-{Guid.NewGuid()}",
options);
var subOptions = StanSubscriptionOptions.GetDefaultOptions();
subOptions.DurableName = Environment.MachineName;
subOptions.StartAt(DateTime.UtcNow.AddMinutes(-1));
Console.WriteLine($"Starting connection to {_eventName} at {URL}");
using (var sub = stanConnection.Subscribe(_eventName, subOptions, (sender, handlerArgs) =>
{
WriteToConsole(format_json(Encoding.UTF8.GetString(handlerArgs.Message.Data)));
_eventCount++;
}))
{
while (true)
{
Thread.Sleep(1000);
if (!Console.KeyAvailable)
{
continue;
}
var key = Console.ReadKey(true);
if (key.Modifiers.HasFlag(ConsoleModifiers.Control) && key.Key == ConsoleKey.S)
{
sub.Close();
WriteToConsole("Exiting application...");
Environment.Exit(0);
}
}
}
}
void InitStanClient()
{
var stanConnectionFactory = new StanConnectionFactory();
_stanClient = stanConnectionFactory.CreateConnection(_options.ClusterId, _options.ClientId, _stanOptions);
_stanSubscriptionOptions = StanSubscriptionOptions.GetDefaultOptions();
_stanSubscriptionOptions.DurableName = _options.StanSubscriptionOptions.DurableName;
}
//Deadlock when i use simple stan configuration for cluster
static async void DeadlockInStanOptions()
{
var cf = new StanConnectionFactory();
var opts = StanOptions.GetDefaultOptions();
opts.NatsURL = "nats://127.0.0.1:4223,nats://127.0.0.1:4224";
opts.PingInterval = 500;
var opts2 = StanOptions.GetDefaultOptions();
opts2.NatsURL = "nats://127.0.0.1:4222";
using (var producer = cf.CreateConnection("test-cluster", "appname", opts))
using (var consumer = cf.CreateConnection("test-cluster", "appname2", opts2))
{
using (consumer.Subscribe("foo", (sender, handlerArgs) => Console.WriteLine(
System.Text.Encoding.UTF8.GetString(handlerArgs.Message.Data))))
{
Console.WriteLine("Connected. ConnServ {0}.", producer?.NATSConnection?.ConnectedUrl);
//first success send
producer?.Publish("foo", System.Text.Encoding.UTF8.GetBytes("first success hello"));
//stop connected stan container, simulation disconnect
var firstUrl = producer?.NATSConnection?.ConnectedUrl;
var clusterContainerName = firstUrl.Contains("4224") ? "nats-2" : "nats-1";
DockerController.SendStopContainer(clusterContainerName);
//simulation of sending 10 messages to diconnected node
for (var i = 0; i < 10; i++)
{
var success = false;
while (!success)
{
Console.WriteLine($"Publishing. ConnState {producer?.NATSConnection?.State}. Connected to {producer?.NATSConnection?.ConnectedUrl}");
try
{
producer?.Publish("foo", System.Text.Encoding.UTF8.GetBytes("hello"));
success = true;
}
catch (Exception e)
{
System.Console.WriteLine("exception: {0}", e.Message);
}
await Task.Delay(1000);
}
}
DockerController.SendStartContainer(clusterContainerName);
}
}
}
/// <summary>
/// Establishes the server connection.
/// </summary>
private void Connect()
{
var factory = new StanConnectionFactory();
var retry = new LinearRetryPolicy(exception => true, 20, TimeSpan.FromSeconds(0.5));
retry.Invoke(
() =>
{
Connection = factory.CreateConnection("test-cluster", nameof(NatsStreamingFixture));
});
}
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);
}
}
static void Main(string[] args)
{
string CLUSTER_ID = "cluster-teste-local";
string CLIENT_ID = "Consumer-" + DateTime.Now.Second;
string DURABLE_NAME = "durable-queue";
string SUBJECT = "subject-test";
string QUEUE_GROUP = "queue-group-test";
string URL_NATS = "nats://localhost:4222";
var cf = new StanConnectionFactory();
StanOptions stanOptions = StanOptions.GetDefaultOptions();
stanOptions.NatsURL = URL_NATS;
Console.WriteLine($"Connecting (URL_NATS = {URL_NATS}) ...");
Console.WriteLine($"CLUSTER_ID = {CLUSTER_ID}");
Console.WriteLine($"CLIENT_ID = {CLIENT_ID}");
using (var c = cf.CreateConnection(CLUSTER_ID, CLIENT_ID, stanOptions))
{
var subscriptionOpts = StanSubscriptionOptions.GetDefaultOptions();
subscriptionOpts.DurableName = DURABLE_NAME;
subscriptionOpts.ManualAcks = true;
subscriptionOpts.MaxInflight = 1;
var cts = new CancellationTokenSource();
Task.Run(() =>
{
c.Subscribe(SUBJECT, QUEUE_GROUP, subscriptionOpts, (obj, args) =>
{
string msg = Encoding.UTF8.GetString(args.Message.Data);
Console.WriteLine($"Msg received on {SUBJECT} : {msg}");
args.Message.Ack();
});
}, cts.Token);
Console.WriteLine("Waiting... [press any key to exit]");
Console.ReadKey();
cts.Cancel();
}
}
public void Setup(string appname)
{
var cf = new StanConnectionFactory();
_connection = cf.CreateConnection("test-cluster", appname);
_connection.NATSConnection.Opts.DisconnectedEventHandler += (sender, args) =>
{
OnDisconnected?.Invoke(this, new OnDisconnectedHandlerArgs(args.Conn.State));
};
_connection.NATSConnection.Opts.ClosedEventHandler += (sender, args) =>
{
OnClosed?.Invoke(this, new OnClosedHandlerArgs(args.Conn.State));
};
}
public NATSOrderRepository()
{
try
{
var cf = new StanConnectionFactory();
var options = StanOptions.GetDefaultOptions();
options.NatsURL = "nats://localhost:4223";
_stanConnection = cf.CreateConnection("test-cluster", CLIENTID, options);
var subOptions = StanSubscriptionOptions.GetDefaultOptions();
subOptions.DeliverAllAvailable();
_stanConnection.Subscribe(EVENTSTREAM_SUBJECT, subOptions, (obj, args) =>
{
try
{
string message = Encoding.UTF8.GetString(args.Message.Data);
string[] messageParts = message.Split('#');
string eventTypeDescriptor =
$"Store.OrderProcessingService.Domain.Events.{messageParts[0]}";
Type eventType = Type.GetType(eventTypeDescriptor);
string eventData = message.Substring(message.IndexOf('#') + 1);
dynamic e = JsonSerializer.Deserialize(eventData, eventType);
if (_eventStreams.ContainsKey(e.OrderNumber))
{
_eventStreams[e.OrderNumber].Add(e);
}
else
{
_eventStreams.Add(e.OrderNumber, new List <BusinessEvent>()
{
e
});
Console.WriteLine($"Order #{e.OrderNumber} found during replay.");
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
});
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
}
private void Run(string[] args)
{
_clientId += Guid.NewGuid();
Banner();
_cOpts.NatsURL = Url;
using var c = new StanConnectionFactory().CreateConnection(ClusterId, _clientId, _cOpts);
while (true)
{
long acksProcessed = 0;
var sw = Stopwatch.StartNew();
var ev = new AutoResetEvent(false);
// async
for (var i = 0; i < Count; i++)
{
var guid = c.Publish(Subject, _payload, (obj, pubArgs) =>
{
if (Verbose)
{
Console.WriteLine("Received ack for message {0}", pubArgs.GUID);
}
if (!string.IsNullOrEmpty(pubArgs.Error))
{
Console.WriteLine("Error processing message {0}", pubArgs.GUID);
}
if (Interlocked.Increment(ref acksProcessed) == Count)
{
ev.Set();
}
});
if (Verbose)
{
Console.WriteLine("Published message with guid: {0}", guid);
}
}
ev.WaitOne();
sw.Stop();
Console.Write("Published {0} msgs with acknowledgements in {1} seconds ", Count, sw.Elapsed.TotalSeconds);
Console.WriteLine("({0} msgs/second).", (int)(Count / sw.Elapsed.TotalSeconds));
}
}
static void Main(string[] args)
{
// run docker run --rm --name natstest -p 4222:4222 -p 8222:8222 nats-streaming -store file -dir ./data --max_msgs 0 --max_bytes 0 --cluster_id scarsnatscluster
EventHandler <StanMsgHandlerArgs> ackHandler = (obj, natsargs) =>
{
Console.WriteLine("Message: {0} - {1} - {2}", natsargs.Message.Subject,
System.Text.Encoding.UTF8.GetString(natsargs.Message.Data), natsargs.Message.TimeStamp.ToString());
};
var opts = StanSubscriptionOptions.GetDefaultOptions();
opts.DeliverAllAvailable();
//opts.StartAt(22);
var cf = new StanConnectionFactory();
var c = cf.CreateConnection("mynatscluster", "my-reader");
var s = c.Subscribe("my.log.error", opts, ackHandler);
}
public void Run(string[] args)
{
parseArgs(args);
banner();
var opts = StanOptions.GetDefaultOptions();
opts.NatsURL = url;
using (var c = new StanConnectionFactory().CreateConnection(clusterID, clientID, opts))
{
TimeSpan elapsed = receiveAsyncSubscriber(c);
Console.Write("Received {0} msgs in {1} seconds ", received, elapsed.TotalSeconds);
Console.WriteLine("({0} msgs/second).",
(int)(received / elapsed.TotalSeconds));
}
}
public void Run(string[] args)
{
_clientId += Guid.NewGuid();
Banner();
var opts = StanOptions.GetDefaultOptions();
opts.NatsURL = Url;
using var c = new StanConnectionFactory().CreateConnection(ClusterId, _clientId, opts);
while (true)
{
_received = 0;
var elapsed = ReceiveAsyncSubscriber(c);
Console.Write("Received {0} msgs in {1} seconds ", _received, elapsed.TotalSeconds);
Console.WriteLine("({0} msgs/second).", (int)(_received / elapsed.TotalSeconds));
}
}
public void Start()
{
_repo = new SQLServerOrderRepository();
// connect to NATS
var natsConnectionFactory = new ConnectionFactory();
_natsConnection = natsConnectionFactory.CreateConnection("nats://localhost:4222");
// connect to STAN
var cf = new StanConnectionFactory();
var options = StanOptions.GetDefaultOptions();
options.NatsURL = "nats://localhost:4223";
_stanConnection = cf.CreateConnection("test-cluster", "OrderProcessingService", options);
// create commands subscription
_commandsSubscription = _natsConnection.SubscribeAsync("store.commands.*", CommandReceived);
}
private void Publish(string dataCentre)
{
var stanOptions = StanOptions.GetDefaultOptions();
stanOptions.NatsURL = _natsClusterNodes[dataCentre];
var iteration = 0;
const int numberOfMessagesToSend = 10;
using var stanConnection = new StanConnectionFactory().CreateConnection(ClusterId, $"{Environment.MachineName.ToLower()}-{dataCentre}-sending", stanOptions);
var messages = Enumerable.Range(1, numberOfMessagesToSend).Select(r =>
{
Console.WriteLine($"{dataCentre}: sent 'Sending message from test {++iteration}'");
stanConnection.Publish("foo",
System.Text.Encoding.UTF8.GetBytes($"Sending message from test {iteration}"));
return(r);
});
Console.WriteLine($"Published {messages.Count()} messages...");
}
private async Task Subscriber(string dataCentre, CancellationToken token)
{
var subscriberOptions = StanOptions.GetDefaultOptions();
subscriberOptions.NatsURL = _natsClusterNodes[dataCentre];
var loopCount = 0;
using var stanConnection = new StanConnectionFactory().CreateConnection(ClusterId, $"{Environment.MachineName.ToLower()}-{dataCentre}-receiving", subscriberOptions);
using var subscribe = stanConnection.Subscribe("foo", CreateStanSubscriptionOptions(dataCentre, subscriberOptions), (obj, context) =>
{
Console.WriteLine(
$"{dataCentre}: received '{System.Text.Encoding.UTF8.GetString(context.Message.Data)}'. Redelivered: {context.Message.Redelivered}. Sequence: {context.Message.Sequence}");
Console.WriteLine($"loopCount: {Interlocked.Increment(ref loopCount)}");
});
await Task.Delay(1000000, token);
subscribe.Unsubscribe();
Console.WriteLine("Exiting subscription");
}
static void Main(string[] args)
{
var natsOptions = ConnectionFactory.GetDefaultOptions();
natsOptions.Url = "nats://localhost:4222";
natsOptions.PingInterval = 1 * 1000;
natsOptions.MaxPingsOut = 3;
natsOptions.AllowReconnect = true;
natsOptions.MaxReconnect = Options.ReconnectForever;
natsOptions.ReconnectWait = 1 * 1000;
var natsConn = new ConnectionFactory().CreateConnection(natsOptions);
var stanOptions = StanOptions.GetDefaultOptions();
stanOptions.NatsConn = natsConn;
var stanConn = new StanConnectionFactory().CreateConnection("test-cluster", "net-client", stanOptions);
TestNATS(natsConn);
// TestSTAN(stanConn);
}
static void Main(string[] args)
{
string clientId = $"producer-{Guid.NewGuid().ToString()}";
var cf = new StanConnectionFactory();
StanOptions options = StanOptions.GetDefaultOptions();
options.NatsURL = "nats://localhost:4223";
using (var c = cf.CreateConnection("test-cluster", clientId, options))
{
for (int i = 1; i <= 25; i++)
{
string message = $"[{DateTime.Now.ToString("hh:mm:ss:fffffff")}] Message {i}";
Console.WriteLine($"Sending {message}");
c.Publish("nats.streaming.demo", Encoding.UTF8.GetBytes(message));
}
}
}
private IStanConnection GetConnection()
{
var clientId = _natsOptions.Value.ClientId?.Replace(".", "_");
var options = StanOptions.GetDefaultOptions();
options.NatsURL = _natsOptions.Value.NatsUrl;
options.ConnectionLostEventHandler = (_, args) =>
{
SetUnrecoverableState(args.ConnectionException ?? new Exception("NATS connection was lost"));
};
//fix https://github.com/nats-io/csharp-nats-streaming/issues/28
options.PubAckWait = 30000;
var cf = new StanConnectionFactory();
_connection = cf.CreateConnection(_natsOptions.Value.Cluster, clientId + Guid.NewGuid(), options);
return(_connection);
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage: consumer <clientid>");
return;
}
string clientId = args[0];
var cf = new StanConnectionFactory();
StanOptions options = StanOptions.GetDefaultOptions();
options.NatsURL = "nats://localhost:4222";
using (var c = cf.CreateConnection("test-cluster", clientId, options))
{
var opts = StanSubscriptionOptions.GetDefaultOptions();
//opts.DeliverAllAvailable();
//opts.StartAt(15);
//opts.StartAt(TimeSpan.FromSeconds(10));
//opts.StartAt(new DateTime(2019, 9, 18, 9, 0, 0));
//opts.StartWithLastReceived();
//opts.DurableName = "durable";
var s = c.Subscribe("nats.streaming.demo", opts, (obj, args) =>
{
string message = Encoding.UTF8.GetString(args.Message.Data);
Console.WriteLine($"[#{args.Message.Sequence}] {message}");
});
Console.WriteLine($"Consumer with client id '{clientId}' started. Press any key to quit...");
Console.ReadKey(true);
//s.Unsubscribe();
c.Close();
}
}
static void Main(string[] args)
{
var clusterId = "test-cluster";
var clientId = Guid.NewGuid().ToString("N");
using (var cn = new StanConnectionFactory().CreateConnection(clusterId, clientId))
{
var cts = new CancellationTokenSource();
Task.Run(() =>
{
var temperatures =
cn.Observe("temperatures")
.Where(m => m.Data?.Any() == true)
.Select(m => BitConverter.ToInt32(m.Data, 0));
temperatures.Subscribe(t => Console.WriteLine($"{t}C"));
temperatures.Subscribe(t => Console.WriteLine($"{(t * 9 / 5) + 32}F"));
}, cts.Token);
Task.Run(async() =>
{
var rnd = new Random();
while (!cts.IsCancellationRequested)
{
cn.Publish("temperatures", BitConverter.GetBytes(rnd.Next(-10, 40)));
await Task.Delay(1000, cts.Token);
}
}, cts.Token);
Console.WriteLine("Hit any key to exit");
Console.ReadKey();
cts.Cancel();
}
}
static void Main()
{
string serverURL = "nats://localhost:4222", clusterID = "test-cluster", clientID = "client_sub", subject = "foo_subject", queue = "foo_queue", durable = "foo_durable";
StanOptions cOpts = StanOptions.GetDefaultOptions();
cOpts.NatsURL = serverURL;
using (var c = new StanConnectionFactory().CreateConnection(clusterID, clientID, cOpts))
{
Console.WriteLine("nats: connected serverURL='{0}', clusterID='{1}', clientID='{2}'", serverURL, clusterID, clientID);
StanSubscriptionOptions sOpts = StanSubscriptionOptions.GetDefaultOptions();
sOpts.DurableName = durable;
sOpts.MaxInflight = 1;
using (var s = c.Subscribe(subject, queue, sOpts, (sender, args) =>
{
Console.WriteLine("Received seq # {0}: {1}", args.Message.Sequence, System.Text.Encoding.UTF8.GetString(args.Message.Data));
}))
{
Console.WriteLine("nats: subscribed subject='{0}', queue='{1}', durable='{2}'", subject, queue, durable);
Console.WriteLine("program: press <enter> to exit...");
Console.ReadLine();
}
}
}
public void Start()
{
// connect to NATS
var natsConnectionFactory = new ConnectionFactory();
_natsConnection = natsConnectionFactory.CreateConnection("nats://localhost:4222");
// connect to STAN
var cf = new StanConnectionFactory();
var natsOptions = StanOptions.GetDefaultOptions();
natsOptions.NatsURL = "nats://localhost:4223";
_stanConnection = cf.CreateConnection("test-cluster", "OrdersQueryService", natsOptions);
// create queries subscription
_natsConnection.SubscribeAsync("store.queries.*", QueryReceived);
// create events subscription
StanSubscriptionOptions stanOptions = StanSubscriptionOptions.GetDefaultOptions();
stanOptions.DurableName = "OrdersQueryService";
_stanConnection.Subscribe("store.events", stanOptions, EventReceived);
}
