public async Task Client_Should_throw_if_request_after_disconnected() { var subject = Context.GenerateSubject(); var body = new byte[0]; _responder = await Context.ConnectClientAsync(); _requester = await Context.ConnectClientAsync(); _responder.Sub(subject, stream => stream.Subscribe(msg => _responder.Pub(msg.ReplyTo, msg.GetPayloadAsString()))); await Context.DelayAsync(); // Succeeds var response = await _requester.RequestAsync(subject, "body"); Assert.NotNull(response); response = await _requester.RequestAsync(subject, body.AsMemory()); Assert.NotNull(response); // Disconnect from NATS per user request _requester.Disconnect(); Assert.False(_requester.IsConnected); // Fails after being disconnected await Should.ThrowNatsExceptionAsync(() => _requester.RequestAsync(subject, "body")); await Should.ThrowNatsExceptionAsync(() => _requester.RequestAsync(subject, body.AsMemory())); }
public async Task Client_Should_throw_if_pub_after_disconnected() { var subject = Context.GenerateSubject(); var body = new byte[0]; _client1 = await Context.ConnectClientAsync(); // Succeeds _client1.Pub(subject, "body"); _client1.Pub(subject, "body", "repy.to.subject"); _client1.Pub(subject, body.AsMemory()); _client1.Pub(subject, body.AsMemory(), "repy.to.subject"); // Disconnect from NATS per user request _client1.Disconnect(); Assert.False(_client1.IsConnected); // Fails after being disconnected Should.ThrowNatsException(() => _client1.Pub(subject, "body")); Should.ThrowNatsException(() => _client1.Pub(subject, "body", "reply.to.subject")); Should.ThrowNatsException(() => _client1.Pub(subject, body.AsMemory())); Should.ThrowNatsException(() => _client1.Pub(subject, body.AsMemory(), "reply.to.subject")); await Should.ThrowNatsExceptionAsync(() => _client1.PubAsync(subject, "body")); await Should.ThrowNatsExceptionAsync(() => _client1.PubAsync(subject, "body", "reply.to.subject")); await Should.ThrowNatsExceptionAsync(() => _client1.PubAsync(subject, body.AsMemory())); await Should.ThrowNatsExceptionAsync(() => _client1.PubAsync(subject, body.AsMemory(), "reply.to.subject")); }
public void Dispose() { _sync?.Dispose(); _sync = null; _client?.Disconnect(); _client?.Dispose(); _client = null; }
protected override void OnAfterEachTest() { _requester?.Disconnect(); _requester?.Dispose(); _requester = null; _responder?.Disconnect(); _responder?.Dispose(); _responder = null; }
public void Dispose() { _requester?.Disconnect(); _requester?.Dispose(); _requester = null; _responder?.Disconnect(); _responder?.Dispose(); _responder = null; }
protected override async Task DoWork(PairConfig pair, CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { try { using (BinanceSocketClient client = new BinanceSocketClient()) { ConnectionInfo cnInfo = new ConnectionInfo(_settings.Value.BusConnectionString); using (NatsClient natsClient = new NatsClient(cnInfo)) { if (!natsClient.IsConnected) { natsClient.Connect(); } CallResult <UpdateSubscription> successKline = null; successKline = client.SubscribeToTradeUpdates(pair.Symbol, async(data) => { Trade trade = data.ToEntity(); if (!_settings.Value.DisadleDealsSaving) { long id = await _tradesProcessor.Create(trade); } await natsClient.PubAsJsonAsync(_settings.Value.TradesQueueName, new Notification <Trade>() { Code = ActionCode.CREATED.Code, Payload = trade }); }); successKline.Data.ConnectionLost += () => { _logger.LogError($"Connection to {Exchange} is lost"); }; successKline.Data.ConnectionRestored += (data) => { _logger.LogError($"Connection to {Exchange} is Restored"); }; while (!stoppingToken.IsCancellationRequested) { } natsClient.Disconnect(); await client.Unsubscribe(successKline.Data); } } } catch (Exception ex) { _logger.LogError($"{Exchange.Description} Trades service failed with message {ex.Message}", ex); } } }
protected override void OnAfterEachTest() { _client1?.Disconnect(); _client1?.Dispose(); _client1 = null; _client2?.Disconnect(); _client2?.Dispose(); _client2 = null; _client3?.Disconnect(); _client3?.Dispose(); _client3 = null; }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { try { ConnectionInfo cnInfo = new ConnectionInfo(_settings.Value.BusConnectionString); using (NatsClient natsClient = new NatsClient(cnInfo)) { if (!natsClient.IsConnected) { natsClient.Connect(); } await natsClient.SubAsync(_settings.Value.CandlesQueueName, stream => stream.Subscribe(msg => { try { Task.Run(async() => await Process(msg, natsClient)); } catch (Exception ex) { _logger.LogError($"TradingProcessor failed with message: {ex.Message}", ex); } })); natsClient.Events.OfType <ClientDisconnected>().Subscribe(ev => { Console.WriteLine($"Client was disconnected due to reason '{ev.Reason}'"); if (!cnInfo.AutoReconnectOnFailure) { ev.Client.Connect(); } }); while (!stoppingToken.IsCancellationRequested) { await Task.Delay(TimeSpan.FromSeconds(1)); } natsClient.Disconnect(); } } catch (Exception ex) { _logger.LogError(ex.Message); } } }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { if (disposing && !_disposed) { if (_client != null && _client.IsConnected) { if (_subscription != null) { _client.Unsub(_subscription); _subscription = null; } _client.Disconnect(); } _disposed = true; } }
public void Dispose() { _sync?.Dispose(); _sync = null; _client1?.Disconnect(); _client1?.Dispose(); _client1 = null; _client2?.Disconnect(); _client2?.Dispose(); _client2 = null; _client3?.Disconnect(); _client3?.Dispose(); _client3 = null; }
public void IsMessageReceivedAfterLoggingIsDone() { var config = new NatsConfiguration { Host = "localhost", Port = 4222, ClientId = "Serilog.Sinks.Nats.IntegrationTests.Publisher", Subject = "IntegrationTest.TestSubject", RequestTimeoutMs = 1000, AutoReconnectOnFailure = true, AutoRespondToPing = true, BatchPostingLimit = 1, Credentials = new Credentials("test", "test"), Period = TimeSpan.FromMilliseconds(100), PubFlushMode = PubFlushMode.Auto, SocketOptions = new SocketOptions { ConnectTimeoutMs = 1000, ReceiveBufferSize = 50000, ReceiveTimeoutMs = 5000, SendBufferSize = 50000, SendTimeoutMs = 5000 }, Verbose = false }; Log.Logger = new LoggerConfiguration() .MinimumLevel.Debug() .Enrich.FromLogContext() .WriteTo.Nats(config, new JsonFormatter()) .CreateLogger(); var cnInfo = new ConnectionInfo("localhost") { Credentials = new Credentials("test", "test"), RequestTimeoutMs = 30000 }; var client = new NatsClient("Serilog.Sinks.Nats.IntegrationTests.Subscriber", cnInfo); client.Connect(); var foundMessage = false; client.SubWithHandlerAsync(config.Subject, msg => { foundMessage = true; }).ConfigureAwait(false); Log.Debug("Test message"); Thread.Sleep(1000); client.Disconnect(); Assert.True(foundMessage, "No log message received within timeout period"); }
protected override async Task DoWork(PairConfig pair, CancellationToken stoppingToken) { _logger.LogInformation($"{Exchange.Description} Candles worker is started"); IPeriodCode candlePeriod = pair.Timeframe.HasValue ? PeriodCode.Create(pair.Timeframe.Value) : DefaultCandleInterval; while (!stoppingToken.IsCancellationRequested) { try { using (BinanceSocketClient client = new BinanceSocketClient()) { ConnectionInfo cnInfo = new ConnectionInfo(_settings.Value.BusConnectionString); using (NatsClient natsClient = new NatsClient(cnInfo)) { if (!natsClient.IsConnected) { natsClient.Connect(); } CallResult <UpdateSubscription> successKline = client.SubscribeToKlineUpdates(pair.Symbol, candlePeriod.ToPeriodCode(), async(data) => { await SaveCandle(data.Data, natsClient); }); successKline.Data.ConnectionLost += () => { _logger.LogError($"Connection to {Exchange} is lost"); }; successKline.Data.ConnectionRestored += (data) => { _logger.LogError($"Connection to {Exchange} is Restored"); }; while (!stoppingToken.IsCancellationRequested) { } natsClient.Disconnect(); await client.Unsubscribe(successKline.Data); } } } catch (Exception ex) { _logger.LogError($"{Exchange.Description} Candles service failed with message: {ex.Message}", ex); } } }
public async Task Client_Should_not_reconnect_When_user_initiated_disconnect() { var wasDisconnectedDueToFailure = false; var wasDisconnected = false; var wasReconnected = false; _sync = Sync.MaxTwo(); var cnInfo = Context.GetConnectionInfo(); cnInfo.AutoReconnectOnFailure = true; _client = new NatsClient(cnInfo); await _client.ConnectAsync(); _client.Events .OfType <ClientDisconnected>() .Subscribe(ev => { wasDisconnectedDueToFailure = ev.Reason == DisconnectReason.DueToFailure; wasDisconnected = true; _sync.Release(); }); _client.Events .OfType <ClientConnected>() .Subscribe(ev => { wasReconnected = true; _sync.Release(); }); _client.Disconnect(); //Wait for the Disconnected release and the potential Connected release _sync.WaitForAny(); wasDisconnectedDueToFailure.Should().BeFalse(); wasDisconnected.Should().BeTrue(); wasReconnected.Should().BeFalse(); _client.IsConnected.Should().BeFalse(); }
public async Task Client_Should_not_reconnect_When_user_initiated_disconnect() { const string subject = "test"; var wasDisconnectedDueToFailure = false; var wasDisconnected = false; var wasReconnected = false; _client = new NatsClient(_cnInfoWithAutoReconnect); _client.Connect(); await _client.SubAsync(subject); _client.Events.OfType <ClientDisconnected>() .Subscribe(ev => { wasDisconnectedDueToFailure = ev.Reason == DisconnectReason.DueToFailure; wasDisconnected = true; ReleaseOne(); }); _client.Events.OfType <ClientConnected>() .Subscribe(ev => { wasReconnected = true; ReleaseOne(); }); _client.Disconnect(); //Wait for the Disconnected release and the potentiall Connected release WaitOne(); WaitOne(); wasDisconnectedDueToFailure.Should().BeFalse(); wasDisconnected.Should().BeTrue(); wasReconnected.Should().BeFalse(); _client.IsConnected.Should().BeFalse(); }
public async Task Given_subscribed_When_disconnectiong_and_connecting_again_It_should_resubscribe_and_get_messages() { var subject = GenerateSubject(); var interceptCount = 0; _client.Sub(subject, stream => stream.Subscribe(NatsObserver.Delegating <MsgOp>(msg => { Interlocked.Increment(ref interceptCount); ReleaseOne(); }))); await _client.PubAsync(subject, "Test1"); WaitOne(); _client.Disconnect(); _client.Connect(); await _client.PubAsync(subject, "Test2"); WaitOne(); interceptCount.Should().Be(2); }
public async Task Given_subscribed_When_disconnectiong_and_connecting_again_It_should_resubscribe_and_get_messages() { var subject = Context.GenerateSubject(); _sync = Sync.MaxOne(); _client = await Context.ConnectClientAsync(); _client.Sub(subject, stream => stream.Subscribe(NatsObserver.Delegating <MsgOp>(msg => _sync.Release(msg)))); await Context.DelayAsync(); await _client.PubAsync(subject, "Test1"); _sync.WaitForAny(); _client.Disconnect(); await _client.ConnectAsync(); await _client.PubAsync(subject, "Test2"); _sync.WaitForAny(); _sync.InterceptedCount.Should().Be(2); }
protected override async Task DoWork(PairConfig config, CancellationToken stoppingToken) { ExchangeConfig exchangeConfig = await _exchangeConfigProcessor.GetExchangeConfig(Exchange.Code); while (!stoppingToken.IsCancellationRequested) { try { string listenKey = String.Empty; using (BinanceClient client = new BinanceClient()) { listenKey = client.StartUserStream().Data; } using (BinanceSocketClient socketClient = new BinanceSocketClient()) { ConnectionInfo cnInfo = new ConnectionInfo(_settings.Value.BusConnectionString); using (NatsClient natsClient = new NatsClient(cnInfo)) { if (!natsClient.IsConnected) { natsClient.Connect(); } CallResult <UpdateSubscription> successAccount = socketClient.SubscribeToUserDataUpdates(listenKey, accountData => { }, async orderData => { Order order = orderData.ToOrder(); Deal deal = await _dealProcessor.UpdateForOrder(order, config); await natsClient.PubAsJsonAsync(_settings.Value.OrdersQueueName, new Notification <Deal>() { Code = ActionCode.UPDATED.Code, Payload = deal }); }, ocoOrderData => { }, async balancesData => { IEnumerable <Balance> balances = balancesData.Select(x => x.ToBalance()); foreach (Balance balance in balances) { await _balanceProcessor.UpdateOrCreate(balance); } }, onAccountBalanceUpdate => { }); while (!stoppingToken.IsCancellationRequested) { } natsClient.Disconnect(); await socketClient.UnsubscribeAll(); } } } catch (Exception ex) { _logger.LogError(ex.Message); } } }
protected override void OnAfterEachTest() { _client?.Disconnect(); _client?.Dispose(); _client = null; }