Example #1
0
        public void TestDispose()
        {
            _heartbeat.IsDisposed.Should().BeFalse();

            _heartbeat.Dispose();
            _heartbeat.IsDisposed.Should().BeTrue();
        }
Example #2
0
        // Graceful shutdown if possible
        public async Task StopAsync(CancellationToken cancellationToken)
        {
            if (Interlocked.Exchange(ref _stopped, 1) == 1)
            {
                return;
            }

            var tasks = new Task[_transports.Count];

            for (int i = 0; i < _transports.Count; i++)
            {
                tasks[i] = _transports[i].UnbindAsync();
            }
            await Task.WhenAll(tasks).ConfigureAwait(false);

            if (!await ConnectionManager.CloseAllConnectionsAsync(cancellationToken).ConfigureAwait(false))
            {
                Trace.NotAllConnectionsClosedGracefully();

                if (!await ConnectionManager.AbortAllConnectionsAsync().ConfigureAwait(false))
                {
                    Trace.NotAllConnectionsAborted();
                }
            }

            for (int i = 0; i < _transports.Count; i++)
            {
                tasks[i] = _transports[i].StopAsync();
            }
            await Task.WhenAll(tasks).ConfigureAwait(false);

            _heartbeat.Dispose();
        }
Example #3
0
 /// <summary>
 /// Cleans up resources
 /// </summary>
 /// <param name="disposing">Flag if being disposed</param>
 protected virtual void Dispose(bool disposing)
 {
     if (!_disposed)
     {
         if (disposing)
         {
             if (_heartbeat != null)
             {
                 _heartbeat.Dispose();
                 _heartbeat = null;
             }
             _disposed = true;
         }
     }
 }
Example #4
0
        public void disposing_stops_the_heart_beating()
        {
            // ARRANGE
            var hearbeat = new Heartbeat(TimeSpan.FromMilliseconds(200));

            // ACT
            var beats = new List <Unit>();

            hearbeat.Listen.Subscribe(beats.Add);

            hearbeat.Dispose();

            System.Threading.Thread.Sleep(450);

            // ASSERT
            Assert.That(beats, Is.Empty);
        }
Example #5
0
        // Graceful shutdown if possible
        public async Task StopAsync(CancellationToken cancellationToken)
        {
            if (Interlocked.Exchange(ref _stopping, 1) == 1)
            {
                await _stoppedTcs.Task.ConfigureAwait(false);

                return;
            }

            try
            {
                var tasks = new Task[_transports.Count];
                for (int i = 0; i < _transports.Count; i++)
                {
                    tasks[i] = _transports[i].UnbindAsync();
                }
                await Task.WhenAll(tasks).ConfigureAwait(false);

                if (!await ConnectionManager.CloseAllConnectionsAsync(cancellationToken).ConfigureAwait(false))
                {
                    Trace.NotAllConnectionsClosedGracefully();

                    if (!await ConnectionManager.AbortAllConnectionsAsync().ConfigureAwait(false))
                    {
                        Trace.NotAllConnectionsAborted();
                    }
                }

                for (int i = 0; i < _transports.Count; i++)
                {
                    tasks[i] = _transports[i].StopAsync();
                }
                await Task.WhenAll(tasks).ConfigureAwait(false);

                _heartbeat.Dispose();
            }
            catch (Exception ex)
            {
                _stoppedTcs.TrySetException(ex);
                throw;
            }

            _stoppedTcs.TrySetResult(null);
        }