//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);
}
}
}
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);
}
}
private Exception reconnect()
{
if (_conn != null)
{
return(null);
}
// reconnect
Exception error = null;
lock (_token)
{
if (_conn != null)
{
return(null);
}
// create a new clientID
_clientID = string.Format("{0}-{1}", _serviceID, Guid.NewGuid());
// fields
var fields = getConnLogFields();
// now create a new connect
var opts = StanOptions.GetDefaultOptions();
opts.NatsURL = _serverURL;
try
{
// reset event
_publishAbort.Reset();
// reconnect
var conn = nats.DefaultFactory.CreateConnection(_clusterID, _clientID, opts);
if (conn == null)
{
throw new ApplicationException(string.Format("nats connection failed, conn==null"));
}
// save conn
_conn = conn;
// log info
logInfo(fields, "nats connection completed");
// resubscribe all
foreach (var item in _subs.Values)
{
IStanSubscription sub = null;
internalSubscribe(item.subject, item.queue, item.options, item.cb, out sub);
item.sub = sub;
}
}
catch (Exception ex)
{
error = ex;
}
}
// return
return(error);
}
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 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}");
}
}
// Init method
internal void Init()
{
// Create our edge connection
StanOptions opts = StanOptions.GetDefaultOptions();
opts.NatsURL = "192.168.0.8:4222";
edge = new EdgeConnection("test-cluster", "rfid", opts);
// Open the connection
edge.Open();
// Register an observed route manager to automatically handle remote observers with constraints
var resourceMgr = edge.RegisterObservedResourceManager("events", new RequestConstraints(RFIDDataType, "proto3"));
// Setup a handler for receiving new resource observer events
resourceMgr.OnResourceObserverCreated += ObserverCreated;
// Setup a handler for receiving observer removed events
resourceMgr.OnResourceObserverRemoved += ObserverRemoved;
}
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 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 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);
}
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));
}
}
}
public void Run(string[] args)
{
parseArgs(args);
banner();
var opts = StanOptions.GetDefaultOptions();
opts.NatsURL = url;
Console.CancelKeyPress += controlCHandler;
using (c = new StanConnectionFactory().CreateConnection(clusterID, clientID, opts))
{
TimeSpan elapsed = ReceiveMessages();
Console.Write("Received {0} msgs in {1} seconds ", received, elapsed.TotalSeconds);
Console.WriteLine("({0} msgs/second).",
(int)(received / elapsed.TotalSeconds));
}
}
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);
}
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");
}
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 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 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);
}
private static IStanConnection CreateConnection(string url, string clusterID, string clientID)
{
var nopts = ConnectionFactory.GetDefaultOptions();
nopts.Url = url;
nopts.Name = clientID;
nopts.DisconnectedEventHandler = (obj, args) =>
{
Log("({0}) Disconnected from NATS.", clientID);
};
nopts.ReconnectedEventHandler = (obj, args) =>
{
Log("({0}) Reconnected to NATS.", clientID);
};
nopts.AsyncErrorEventHandler = (obj, args) =>
{
Log("({0}) AsyncError: {1}.", clientID, args.Error);
};
var sopts = StanOptions.GetDefaultOptions();
sopts.ConnectionLostEventHandler = (obj, args) =>
{
Log("({0} STAN Connection lost. Exiting.", clientID);
Environment.Exit(1);
};
sopts.PubAckWait = 10000;
sopts.MaxPubAcksInFlight = 32;
sopts.NatsConn = new ConnectionFactory().CreateConnection(nopts);
var sc = new StanConnectionFactory().CreateConnection(clusterID, clientID, sopts);
return(sc);
}
private IStanConnection GetConnection()
{
var natsUrl = _configuration.GetSection("Messaging").GetSection("Nats")["natsUrl"];
var cluster = _configuration.GetSection("Messaging").GetSection("Nats")["cluster"];
var clientId = _configuration.GetSection("Messaging").GetSection("Nats")["clientId"]
?.Replace(".", "_");
var options = StanOptions.GetDefaultOptions();
options.NatsURL = natsUrl;
options.ConnectionLostEventHandler = (obj, 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(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.StartWithLastReceived();
Task.Run(() =>
{
var s = c.Subscribe("nats.streaming.demo", opts, (obj, arguments) =>
{
string message = Encoding.UTF8.GetString(arguments.Message.Data);
Console.WriteLine(message);
c.Publish("nats.streaming.demo.client", Encoding.UTF8.GetBytes("publishing from consumer " + clientId));
});
});
Console.WriteLine($"Consumer with client id '{clientId}' started. Press any key to quit...");
Console.ReadKey(true);
//s.Unsubscribe();
c.Close();
}
Console.ReadLine();
}
private StanOptions GetDefaultOptions() => StanOptions.GetDefaultOptions();
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
private void TestPingMaxOutFail(int value)
{
var opts = StanOptions.GetDefaultOptions();
Assert.Throws <ArgumentOutOfRangeException>(() => { opts.PingMaxOutstanding = value; });
}
public static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
IConfigurationRoot config = builder.Build();
Console.WriteLine("Starting...");
var natsconfig = config.GetSection("NatsConfig");
var natsurl = natsconfig["url"];
var clusterId = natsconfig["clusterid"];
var clientid = natsconfig["clientid"];
var topic = natsconfig["topic"];
StanOptions opts = StanOptions.GetDefaultOptions();
opts.NatsURL = natsurl;
opts.ConnectionLostEventHandler = (obj, args) =>
{
Console.WriteLine($"NATS connection lost. {args.ConnectionException}");
};
try
{
using (var conn = Connect(clusterId, clientid, opts))
{
var cts = new CancellationTokenSource();
Task.Run(() =>
{
conn.Subscribe(topic, (obj, args) =>
{
Console.WriteLine($"Received a message: {System.Text.Encoding.UTF8.GetString(args.Message.Data)}");
});
}, cts.Token);
if (IN_DOCKER)
{
Thread.Sleep(240000); // Only going to run this for 4min in the Docker container -- HEY! It's only an example!
}
else
{
Console.WriteLine("Hit any key to exit");
Console.ReadKey(); // If you don't run in a Docker container you could wait for the user to exit with any key
}
cts.Cancel();
}
}
catch (Exception ex)
{
if (ex is StanConnectRequestTimeoutException || ex is StanConnectionException)
{
Console.WriteLine($"Connection exception: {ex}");
return;
}
Console.WriteLine($"Exception: {ex}");
}
}
