gh-8 Fix unit test

Signed-off-by: Victor Chang <[email protected]>

Author: mocsharp

src/InformaticsGateway/Logging/Log.800.Hl7Service.cs

@@ -22,5 +22,8 @@ public static partial class Log
 
         [LoggerMessage(EventId = 804, Level = LogLevel.Error, Message = "Error sending HL7 acknowledgment.")]
         public static partial void ErrorSendingHl7Acknowledgment(this ILogger logger, Exception ex);
+
+        [LoggerMessage(EventId = 805, Level = LogLevel.Information, Message = "Maximum number {maximumAllowedConcurrentConnections} of clients reached.")]
+        public static partial void MaxedOutHl7Connections(this ILogger logger, int maximumAllowedConcurrentConnections);
     }
 }

src/InformaticsGateway/Program.cs

@@ -30,9 +30,9 @@
 using Monai.Deploy.InformaticsGateway.Configuration;
 using Monai.Deploy.InformaticsGateway.Database;
 using Monai.Deploy.InformaticsGateway.Repositories;
+using Monai.Deploy.InformaticsGateway.Services.Common;
 using Monai.Deploy.InformaticsGateway.Services.Connectors;
 using Monai.Deploy.InformaticsGateway.Services.DicomWeb;
-using Monai.Deploy.InformaticsGateway.Services.Export;
 using Monai.Deploy.InformaticsGateway.Services.HealthLevel7;
 using Monai.Deploy.InformaticsGateway.Services.Http;
 using Monai.Deploy.InformaticsGateway.Services.Scp;
@@ -121,6 +121,8 @@ internal static IHostBuilder CreateHostBuilder(string[] args) =>
                     services.AddSingleton<IMonaiServiceLocator, MonaiServiceLocator>();
                     services.AddSingleton<IStorageInfoProvider, StorageInfoProvider>();
                     services.AddSingleton<IMonaiAeChangedNotificationService, MonaiAeChangedNotificationService>();
+                    services.AddSingleton<ITcpListenerFactory, TcpListenerFactory>();
+                    services.AddSingleton<IMllpClientFactory, MllpClientFactory>();
                     services.AddSingleton<IApplicationEntityManager, ApplicationEntityManager>();
                     services.AddSingleton<SpaceReclaimerService>();
                     services.AddSingleton<ScpService>();

src/InformaticsGateway/Services/Common/INetworkStream.cs

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: © 2022 MONAI Consortium
+// SPDX-License-Identifier: Apache License 2.0
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Monai.Deploy.InformaticsGateway.Services.Common
+{
+    internal interface INetworkStream : IDisposable
+    {
+        int ReadTimeout { get; set; }
+        int WriteTimeout { get; set; }
+
+        ValueTask WriteAsync(ReadOnlyMemory<byte> ackData, CancellationToken cancellationToken = default);
+
+        Task FlushAsync(CancellationToken cancellationToken = default);
+
+        ValueTask<int> ReadAsync(Memory<byte> messageBuffer, CancellationToken cancellationToken = default);
+    }
+}

src/InformaticsGateway/Services/Common/ITcpClientAdapter.cs

@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: © 2022 MONAI Consortium
+// SPDX-License-Identifier: Apache License 2.0
+
+using System;
+using System.Net;
+
+namespace Monai.Deploy.InformaticsGateway.Services.Common
+{
+    internal interface ITcpClientAdapter : IDisposable
+    {
+        EndPoint RemoteEndPoint { get; }
+
+        INetworkStream GetStream();
+    }
+}

src/InformaticsGateway/Services/Common/ITcpListener.cs

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: © 2022 MONAI Consortium
+// SPDX-License-Identifier: Apache License 2.0
+
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using Ardalis.GuardClauses;
+
+namespace Monai.Deploy.InformaticsGateway.Services.Common
+{
+    internal interface ITcpListener
+    {
+        void Start();
+
+        void Stop();
+
+        ValueTask<ITcpClientAdapter> AcceptTcpClientAsync(CancellationToken cancellationToken = default);
+    }
+
+    internal class TcpListener : ITcpListener
+    {
+        private readonly System.Net.Sockets.TcpListener _tcpListener;
+
+        public TcpListener(IPAddress ipAddress, int port)
+        {
+            Guard.Against.Null(ipAddress, nameof(ipAddress));
+
+            _tcpListener = new System.Net.Sockets.TcpListener(ipAddress, port);
+        }
+
+        public void Start()
+        {
+            _tcpListener.Start();
+        }
+
+        public void Stop()
+        {
+            _tcpListener.Stop();
+        }
+
+        public async ValueTask<ITcpClientAdapter> AcceptTcpClientAsync(CancellationToken cancellationToken = default)
+        {
+            return new TcpClientAdapter(await _tcpListener.AcceptTcpClientAsync(cancellationToken).ConfigureAwait(false));
+        }
+    }
+}

src/InformaticsGateway/Services/Common/ITcpListenerFactory.cs

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: © 2022 MONAI Consortium
+// SPDX-License-Identifier: Apache License 2.0
+
+using System.Net;
+
+namespace Monai.Deploy.InformaticsGateway.Services.Common
+{
+    internal interface ITcpListenerFactory
+    {
+        ITcpListener CreateTcpListener(IPAddress ipaddress, int port);
+    }
+
+    internal class TcpListenerFactory : ITcpListenerFactory
+    {
+        public ITcpListener CreateTcpListener(IPAddress ipaddress, int port) => new TcpListener(ipaddress, port);
+    }
+}

src/InformaticsGateway/Services/Common/NetworkStreamAdapter.cs

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: © 2022 MONAI Consortium
+// SPDX-License-Identifier: Apache License 2.0
+
+using System;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Monai.Deploy.InformaticsGateway.Services.Common
+{
+    internal class NetworkStreamAdapter : INetworkStream
+    {
+        private readonly NetworkStream _networkStream;
+        private bool _disposedValue;
+
+        public int ReadTimeout { get => _networkStream.ReadTimeout; set => _networkStream.ReadTimeout = value; }
+        public int WriteTimeout { get => _networkStream.WriteTimeout; set => _networkStream.WriteTimeout = value; }
+
+        public NetworkStreamAdapter(NetworkStream networkStream)
+        {
+            _networkStream = networkStream ?? throw new ArgumentNullException(nameof(networkStream));
+        }
+
+        public async Task FlushAsync(CancellationToken cancellationToken = default)
+            => await _networkStream.FlushAsync(cancellationToken).ConfigureAwait(false);
+
+        public async ValueTask<int> ReadAsync(Memory<byte> messageBuffer, CancellationToken cancellationToken = default)
+            => await _networkStream.ReadAsync(messageBuffer, cancellationToken).ConfigureAwait(false);
+
+        public async ValueTask WriteAsync(ReadOnlyMemory<byte> ackData, CancellationToken cancellationToken = default)
+            => await _networkStream.WriteAsync(ackData, cancellationToken).ConfigureAwait(false);
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposedValue)
+            {
+                if (disposing)
+                {
+                    _networkStream.Dispose();
+                }
+
+                _disposedValue = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
+    }
+}

src/InformaticsGateway/Services/Common/TcpClientAdapter.cs

@@ -0,0 +1,50 @@
+// SPDX-FileCopyrightText: © 2022 MONAI Consortium
+// SPDX-License-Identifier: Apache License 2.0
+
+using System;
+using System.Net;
+
+namespace Monai.Deploy.InformaticsGateway.Services.Common
+{
+    internal class TcpClientAdapter : ITcpClientAdapter
+    {
+        private readonly System.Net.Sockets.TcpClient _tcpClient;
+        private bool _disposedValue;
+
+        public EndPoint? RemoteEndPoint
+        {
+            get
+            {
+                return _tcpClient.Client.RemoteEndPoint;
+            }
+        }
+
+        public TcpClientAdapter(System.Net.Sockets.TcpClient tcpClient)
+            => _tcpClient = tcpClient ?? throw new ArgumentNullException(nameof(tcpClient));
+
+        public INetworkStream GetStream()
+        {
+            return new NetworkStreamAdapter(_tcpClient.GetStream());
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposedValue)
+            {
+                if (disposing)
+                {
+                    _tcpClient.Dispose();
+                }
+
+                _disposedValue = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
+    }
+}

src/InformaticsGateway/Services/HealthLevel7/IMllpClient.cs

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: © 2022 MONAI Consortium
+// SPDX-License-Identifier: Apache License 2.0
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Monai.Deploy.InformaticsGateway.Services.HealthLevel7
+{
+    internal interface IMllpClient
+    {
+        Guid ClientId { get; }
+
+        void Dispose();
+
+        Task Start(Action<IMllpClient, MllpClientResult> onDisconnect, CancellationToken cancellationToken);
+    }
+}

src/InformaticsGateway/Services/HealthLevel7/IMllpClientFactory.cs

@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: © 2022 MONAI Consortium
+// SPDX-License-Identifier: Apache License 2.0
+
+using Microsoft.Extensions.Logging;
+using Monai.Deploy.InformaticsGateway.Configuration;
+using Monai.Deploy.InformaticsGateway.Services.Common;
+
+namespace Monai.Deploy.InformaticsGateway.Services.HealthLevel7
+{
+    internal interface IMllpClientFactory
+    {
+        IMllpClient CreateClient(ITcpClientAdapter client, Hl7Configuration configurations, ILogger<MllpClient> logger);
+    }
+
+    internal class MllpClientFactory : IMllpClientFactory
+    {
+        public IMllpClient CreateClient(ITcpClientAdapter client, Hl7Configuration configurations, ILogger<MllpClient> logger) => new MllpClient(client, configurations, logger);
+    }
+}