feat: improve client

josephnhtam · Sep 15, 2024 · fbdaa20 · fbdaa20
1 parent 623231d
commit fbdaa20
Show file tree

Hide file tree

Showing 4 changed files with 51 additions and 26 deletions.
diff --git a/src/LiveStreamingServerNet.Networking/Contracts/INetworkStream.cs b/src/LiveStreamingServerNet.Networking/Contracts/INetworkStream.cs
@@ -2,7 +2,7 @@
 
 namespace LiveStreamingServerNet.Networking.Contracts
 {
-    public interface INetworkStream : INetworkStreamWriter, INetworkStreamReader, IDisposable
+    public interface INetworkStream : INetworkStreamWriter, INetworkStreamReader, IAsyncDisposable
     {
         Stream InnerStream { get; }
     }

diff --git a/src/LiveStreamingServerNet.Networking/Internal/Client.cs b/src/LiveStreamingServerNet.Networking/Internal/Client.cs
@@ -17,13 +17,12 @@ internal sealed class Client : IClient
         private readonly ILogger _logger;
 
         private readonly IClientBufferSender _bufferSender;
-
         private readonly TaskCompletionSource _stoppedTcs = new();
-        private CancellationTokenSource? _cts;
+        private readonly CancellationTokenSource _cts = new();
 
         public uint ClientId { get; }
         public DateTime StartTime { get; }
-        public bool IsConnected => _tcpClient?.Connected ?? false;
+        public bool IsConnected => _tcpClient.Connected;
         public EndPoint LocalEndPoint => _tcpClient.Client.LocalEndPoint!;
         public EndPoint RemoteEndPoint => _tcpClient.Client.RemoteEndPoint!;
 
@@ -52,20 +51,18 @@ public async Task RunAsync(CancellationToken stoppingToken)
         {
             _logger.ClientConnected(ClientId);
 
-            _cts = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken);
-            var cancellationToken = _cts.Token;
+            using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_cts.Token, stoppingToken);
+            var cancellationToken = linkedCts.Token;
 
             IClientHandler? handler = null;
             INetworkStream? networkStream = null;
 
             try
             {
-                handler = CreateClientHandler();
-
                 networkStream = await CreateNetworkStreamAsync(_serverEndPoint, cancellationToken);
-
                 _bufferSender.Start(networkStream, cancellationToken);
 
+                handler = CreateClientHandler();
                 await handler.InitializeAsync();
 
                 while (_tcpClient.Connected && !cancellationToken.IsCancellationRequested)
@@ -80,21 +77,15 @@ public async Task RunAsync(CancellationToken stoppingToken)
             {
                 _logger.ClientLoopError(ClientId, ex);
             }
-            finally
-            {
-                _cts.Cancel();
-            }
-
-            await _bufferSender.DisposeAsync();
 
-            await (handler?.DisposeAsync() ?? ValueTask.CompletedTask);
+            linkedCts.Cancel();
 
-            networkStream?.Dispose();
-
-            _tcpClient.Close();
+            await DisposeAsync(handler);
+            await DisposeAsync(_bufferSender);
+            await DisposeAsync(networkStream);
+            CloseTcpClient();
 
             _stoppedTcs.TrySetResult();
-
             _logger.ClientDisconnected(ClientId);
         }
 
@@ -140,7 +131,7 @@ public ValueTask SendAsync(Action<IDataBuffer> writer)
 
         public void Disconnect()
         {
-            _cts?.Cancel();
+            _cts.Cancel();
         }
 
         public async Task DisconnectAsync(CancellationToken cancellation)
@@ -149,8 +140,36 @@ public async Task DisconnectAsync(CancellationToken cancellation)
             await _stoppedTcs.Task.WithCancellation(cancellation);
         }
 
+        private async Task DisposeAsync(IAsyncDisposable? disposable)
+        {
+            try
+            {
+                if (disposable != null)
+                {
+                    await disposable.DisposeAsync();
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.DisposeError(ClientId, ex);
+            }
+        }
+
+        private void CloseTcpClient()
+        {
+            try
+            {
+                _tcpClient.Close();
+            }
+            catch (Exception ex)
+            {
+                _logger.CloseTcpClientError(ClientId, ex);
+            }
+        }
+
         public ValueTask DisposeAsync()
         {
+            _cts.Dispose();
             _tcpClient.Dispose();
             return ValueTask.CompletedTask;
         }

diff --git a/src/LiveStreamingServerNet.Networking/Internal/Logging/LoggerExtensions.cs b/src/LiveStreamingServerNet.Networking/Internal/Logging/LoggerExtensions.cs
@@ -55,5 +55,11 @@ internal static partial class LoggerExtensions
 
         [LoggerMessage(LogLevel.Error, "An error occurred while dispatching server stopped event")]
         public static partial void DispatchingServerStoppedEventError(this ILogger logger, Exception ex);
+
+        [LoggerMessage(LogLevel.Error, "ClientId: {ClientId} | An error occurred while disposing the client")]
+        public static partial void DisposeError(this ILogger logger, uint clientId, Exception ex);
+
+        [LoggerMessage(LogLevel.Error, "ClientId: {ClientId} | An error occurred while closing the TCP client")]
+        public static partial void CloseTcpClientError(this ILogger logger, uint clientId, Exception ex);
     }
 }
diff --git a/src/LiveStreamingServerNet.Networking/Internal/NetworkStream.cs b/src/LiveStreamingServerNet.Networking/Internal/NetworkStream.cs
@@ -12,11 +12,6 @@ public NetworkStream(Stream stream)
             InnerStream = stream;
         }
 
-        public void Dispose()
-        {
-            InnerStream.Dispose();
-        }
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ValueTask ReadExactlyAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken = default)
         {
@@ -28,5 +23,10 @@ public ValueTask WriteAsync(byte[] buffer, int offset, int count, CancellationTo
         {
             return InnerStream.WriteAsync(new Memory<byte>(buffer, offset, count), cancellationToken);
         }
+
+        public ValueTask DisposeAsync()
+        {
+            return InnerStream.DisposeAsync();
+        }
     }
 }