public async Task StartAsync(string consumerId)
{
StanOptions options = StanOptions.GetDefaultOptions();
options.NatsURL = _natsOptions.Url;
var stanSubOptions = StanSubscriptionOptions.GetDefaultOptions();
stanSubOptions.DurableName = _natsOptions.DurableName;
_stanConnection = new StanConnectionFactory()
.CreateConnection(_natsOptions.ClusterId, consumerId, options);
try
{
_stanConnection
.Subscribe(_natsOptions.Subject, stanSubOptions, (obj, args) =>
{
string messageData = Encoding.UTF8.GetString(args.Message.Data);
Console.WriteLine($"[#{args.Message.Sequence}] {messageData}");
var message = JsonSerializer.Deserialize <Message>(messageData);
message.Number = args.Message.Sequence;
_messageRepository.AddAsync(message).GetAwaiter().GetResult();
});
}
catch (Exception e)
{
_logger.LogError($"Ошибка подписки на сообщения: {e.ToString()}");
CloseConnection();
}
await Task.CompletedTask;
}
public QuantObserver(IQuantConfig config, ILogger log)
{
try
{
_log = log;
_config = config;
_options = _config.Options();
_stanOptions = _options.StanOptions;
InitStanClient();
}
catch (StanConnectionException e)
{
_log.Critical(e, e.Message);
// To need for writ log
System.Threading.Thread.Sleep(2000);
throw;
}
catch (Exception e)
{
_log.Critical(e, e.Message);
// To need for writ log
System.Threading.Thread.Sleep(2000);
throw;
}
}
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("Отправка сообщений отменена.");
}
}
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);
}
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);
}
}
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");
}
/// <summary>
/// Configures the application's services
/// </summary>
/// <param name="services">The <see cref="IServiceCollection"/> to configure</param>
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton(Options.Create(this.ApplicationOptions));
services.AddMediatR(typeof(SubscribeCommand).Assembly);
services.AddCommandBehavior(typeof(OperationExceptionHandlingBehavior <,>), typeof(SubscribeCommand).Assembly);
services.AddHttpClient(typeof(EventChannel).Name, options =>
{
options.BaseAddress = this.ApplicationOptions.Sink;
options.DefaultRequestHeaders.Add(EventingDefaults.Headers.Origin, "natss");
});
services.AddSingleton(provider =>
{
StanOptions stanOptions = StanOptions.GetDefaultOptions();
stanOptions.NatsURL = this.ApplicationOptions.Natss.Host;
return(new StanConnectionFactory().CreateConnection(this.ApplicationOptions.Natss.ClusterId, this.ApplicationOptions.Natss.ClientId, stanOptions));
});
services.AddSingleton <IEventChannel, EventChannel>();
services.AddStartupTask <EventChannelInitializationTask>();
services.AddHealthChecks()
.AddCheck <StartupTasksHealthCheck>("Startup Tasks");
services.AddIstioHeadersPropagation();
services.AddControllers(options =>
{
options.InputFormatters.Insert(0, new CloudEventJsonInputFormatter());
})
.AddJsonOptions(options =>
{
options.JsonSerializerOptions.IgnoreNullValues = true;
});
}
public QuantConnectionOption Options()
{
try
{
StanOptions stanOptions = StanOptions.GetDefaultOptions();
stanOptions.NatsURL = _config["NATS:StanOption:NatsURL"] ?? stanOptions.NatsURL;
stanOptions.DiscoverPrefix = _config["NATS:StanOption:DiscoverPrefix"] ?? stanOptions.DiscoverPrefix;
stanOptions.ConnectTimeout = _config["NATS:StanOption:ConnectTimeout"].ToInt(stanOptions.ConnectTimeout);
stanOptions.MaxPubAcksInFlight = _config["NATS:StanOption:MaxPubAcksInFlight"].ToLong(stanOptions.MaxPubAcksInFlight);
stanOptions.PingInterval = _config["NATS:StanOption:PingInterval"].ToInt(stanOptions.PingInterval);
stanOptions.PingMaxOutstanding = _config["NATS:StanOption:PingMaxOutstanding"].ToInt(stanOptions.PingMaxOutstanding);
stanOptions.PubAckWait = _config["NATS:StanOption:PubAckWait"].ToLong(stanOptions.PubAckWait);
StanSubscriptionOptions stanSubscriptionOptions = StanSubscriptionOptions.GetDefaultOptions();
stanSubscriptionOptions.DurableName = _config["NATS:StanSubscriptionOptions:DurableName"] ?? stanSubscriptionOptions.DurableName;
stanSubscriptionOptions.AckWait = _config["NATS:StanSubscriptionOptions:AckWait"].ToInt(stanSubscriptionOptions.AckWait);
stanSubscriptionOptions.MaxInflight = _config["NATS:StanSubscriptionOptions:DurableName"].ToInt(stanSubscriptionOptions.MaxInflight);
stanSubscriptionOptions.LeaveOpen = _config["NATS:StanSubscriptionOptions:LeaveOpen"].ToBool(stanSubscriptionOptions.LeaveOpen);
stanSubscriptionOptions.ManualAcks = _config["NATS:StanSubscriptionOptions:ManualAcks"].ToBool(stanSubscriptionOptions.ManualAcks);
return(new QuantConnectionOption
{
ClusterId = _config["NATS:StanConnectionOption:ClusterId"] ?? throw new QuantNotSetAppsettingParException("Not set StanOption:ClusterId"),
ClientId = _config["NATS:StanConnectionOption:ClientId"] ?? throw new QuantNotSetAppsettingParException("Not set StanOption:ClientId"),
QueueGroup = _config["NATS:StanSubscriptionOptions:QueueGroup"],
StanOptions = stanOptions,
StanSubscriptionOptions = stanSubscriptionOptions
});
}
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();
}
public StanMessageReceiverService(
IConfiguration configuration,
ILogger <StanMessageReceiverService> logger,
MessagingEvent messagingEvent,
IServiceProvider serviceProvider)
{
_configuration = configuration;
_logger = logger;
_serviceProvider = serviceProvider;
_messagingEvent = messagingEvent;
var opts = StanOptions.GetDefaultOptions();
opts.NatsURL = _configuration.GetValue <string>("Messaging:Stan:Servers");
string clusterID = _configuration.GetValue <string>("Messaging:Stan:ClusterId");
qGroup = _configuration.GetValue <string>("Messaging:Group");
try
{
_connection = new StanConnectionFactory().CreateConnection(clusterID, qGroup, opts);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error messaging connection");
//throw ex;
}
}
// .\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)
{
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 virtual void ConfigureContainer(ContainerBuilder builder)
{
builder.RegisterModule(
new RepositoryAutofacModule(Configuration.GetConnectionString("DefaultConnectionString")));
builder.RegisterModule(new ServiceAutofacModule());
var options = StanOptions.GetDefaultOptions();
options.NatsURL = Configuration
.GetSection("Bus")
.GetSection("Nats")["Url"];
var appName = Configuration
.GetSection("Bus")
.GetSection("Nats")["AppName"];
appName = $"{appName}_{Guid.NewGuid()}";
builder.RegisterModule(new StanBusesAutofacModule(Configuration
.GetSection("Bus")
.GetSection("Nats")["ClusterName"],
appName,
options));
}
private IStanConnection Connect(string clusterId, string clientId, StanOptions opts = null)
{
try
{
if (String.IsNullOrEmpty(clusterId) || String.IsNullOrEmpty(clientId))
{
return(null);
}
if (stanConnection == null || stanConnection.NATSConnection == null)
{
if (opts == null)
{
stanConnection = new StanConnectionFactory().CreateConnection(clusterId, clientId);
}
else
{
stanConnection = new StanConnectionFactory().CreateConnection(clusterId, clientId, opts);
}
}
}
catch (STAN.Client.StanConnectionException ex)
{
InternalLogger.Error(ex, $"NATS connection exception.");
}
catch (STAN.Client.StanConnectRequestTimeoutException ex)
{
InternalLogger.Error(ex, $"NATS connection request timeout exception.");
}
return(stanConnection);
}
public IStanConnection GetIStanConnection()
{
var options = StanOptions.GetDefaultOptions();
options.NatsURL = _appConfig.Value.NatsConnection.ConnectionUrl;
return(_connectionFactory.CreateConnection(_appConfig.Value.NatsConnection.ClusterId, _appConfig.Value.App.AppName, options));
}
public StanOptions GetStanTestOptions(TestServerInfo serverInfo, int timeout = 5000)
{
var opts = StanOptions.GetDefaultOptions();
opts.NatsURL = serverInfo.Url;
opts.ConnectTimeout = timeout;
return(opts);
}
public IStanConnection GetConnection()
{
var natsConfig = _appConfig.Value.NatsConnection;
var options = StanOptions.GetDefaultOptions();
options.NatsURL = natsConfig.Url;
return(_connectionFactory.CreateConnection(natsConfig.ClusterId, natsConfig.ClientId, options));
}
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);
}
}
}
}
public STANBus(IOptions <STANOptions> options)
{
var stanOptions = StanOptions.GetDefaultOptions();
stanOptions.ConnectTimeout = (int)TimeSpan.FromMilliseconds(10000).TotalMilliseconds;
stanOptions.NatsURL = options.Value.Url;
_connection = new Lazy <IStanConnection>(new StanConnectionFactory().CreateConnection(options.Value.ClusterID, options.Value.ClientID, stanOptions));
}
//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;
}
private static IStanConnection Connect(string clusterId, string clientId, StanOptions opts = null)
{
int connectionRetryCounter = 0;
int connectionRetryMax = 3;
while (connectionRetryMax > 0 && stanConnection == null)
{
try
{
if (stanConnection == null || stanConnection.NATSConnection == null)
{
if (opts == null)
{
stanConnection = new StanConnectionFactory().CreateConnection(clusterId, clientId);
}
else
{
stanConnection = new StanConnectionFactory().CreateConnection(clusterId, clientId, opts);
}
}
}
catch (STAN.Client.StanConnectionException ex)
{
connectionRetryMax--;
Console.WriteLine($"NATS connection exception. {ex}");
Thread.Sleep(1000 * connectionRetryCounter);
}
catch (STAN.Client.StanConnectRequestTimeoutException ex)
{
connectionRetryMax--;
Console.WriteLine($"NATS connection request timeout exception. {ex}");
Thread.Sleep(1000 * connectionRetryCounter);
}
catch (STAN.Client.StanConnectRequestException ex)
{
connectionRetryMax--;
Console.WriteLine($"NATS connection request exception. {ex}");
Thread.Sleep(1000 * connectionRetryCounter);
}
connectionRetryCounter++;
}
return(stanConnection);
}
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);
}
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));
}
}
