463 lines
13 KiB
C#
463 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using AMWD.Protocols.Modbus.Common.Contracts;
|
|
using AMWD.Protocols.Modbus.Tcp.Utils;
|
|
|
|
namespace AMWD.Protocols.Modbus.Tcp
|
|
{
|
|
/// <summary>
|
|
/// The default Modbus TCP connection.
|
|
/// </summary>
|
|
public class ModbusTcpConnection : IModbusConnection
|
|
{
|
|
#region Fields
|
|
|
|
private string _hostname;
|
|
private int _port;
|
|
|
|
private bool _isDisposed;
|
|
private bool _isConnected;
|
|
private readonly TcpClientWrapper _client = new();
|
|
|
|
private CancellationTokenSource _disconnectCts;
|
|
private Task _reconnectTask = Task.CompletedTask;
|
|
private readonly SemaphoreSlim _reconnectLock = new(1, 1);
|
|
|
|
private CancellationTokenSource _processingCts;
|
|
private Task _processingTask = Task.CompletedTask;
|
|
private readonly AsyncQueue<RequestQueueItem> _requestQueue = new();
|
|
|
|
#endregion Fields
|
|
|
|
#region Properties
|
|
|
|
/// <inheritdoc/>
|
|
public string Name => "TCP";
|
|
|
|
/// <inheritdoc/>
|
|
public bool IsConnected => _isConnected && _client.Connected;
|
|
|
|
/// <summary>
|
|
/// The DNS name of the remote host to which the connection is intended to.
|
|
/// </summary>
|
|
public virtual string Hostname
|
|
{
|
|
get => _hostname;
|
|
set
|
|
{
|
|
if (string.IsNullOrWhiteSpace(value))
|
|
throw new ArgumentNullException(nameof(value));
|
|
|
|
_hostname = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The port number of the remote host to which the connection is intended to.
|
|
/// </summary>
|
|
public virtual int Port
|
|
{
|
|
get => _port;
|
|
set
|
|
{
|
|
if (value < 1 || ushort.MaxValue < value)
|
|
throw new ArgumentOutOfRangeException(nameof(value));
|
|
|
|
_port = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the receive time out value of the connection.
|
|
/// </summary>
|
|
public virtual TimeSpan ReadTimeout
|
|
{
|
|
get => TimeSpan.FromMilliseconds(_client.ReceiveTimeout);
|
|
set => _client.ReceiveTimeout = (int)value.TotalMilliseconds;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the send time out value of the connection.
|
|
/// </summary>
|
|
public virtual TimeSpan WriteTimeout
|
|
{
|
|
get => TimeSpan.FromMilliseconds(_client.SendTimeout);
|
|
set => _client.SendTimeout = (int)value.TotalMilliseconds;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the maximum time until the reconnect is given up.
|
|
/// </summary>
|
|
public virtual TimeSpan ReconnectTimeout { get; set; } = TimeSpan.MaxValue;
|
|
|
|
/// <summary>
|
|
/// Gets or sets the interval in which a keep alive package should be sent.
|
|
/// </summary>
|
|
public virtual TimeSpan KeepAliveInterval { get; set; } = TimeSpan.Zero;
|
|
|
|
#endregion Properties
|
|
|
|
/// <inheritdoc/>
|
|
public async Task ConnectAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
#if NET8_0_OR_GREATER
|
|
ObjectDisposedException.ThrowIf(_isDisposed, this);
|
|
#else
|
|
if (_isDisposed)
|
|
throw new ObjectDisposedException(GetType().FullName);
|
|
#endif
|
|
|
|
if (_disconnectCts != null)
|
|
{
|
|
await _reconnectTask;
|
|
return;
|
|
}
|
|
|
|
_disconnectCts = new CancellationTokenSource();
|
|
using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_disconnectCts.Token, cancellationToken);
|
|
|
|
_reconnectTask = ReconnectInternalAsync(linkedCts.Token);
|
|
await _reconnectTask.ConfigureAwait(false);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public Task DisconnectAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
#if NET8_0_OR_GREATER
|
|
ObjectDisposedException.ThrowIf(_isDisposed, this);
|
|
#else
|
|
if (_isDisposed)
|
|
throw new ObjectDisposedException(GetType().FullName);
|
|
#endif
|
|
if (_disconnectCts == null)
|
|
return Task.CompletedTask;
|
|
|
|
return DisconnectInternalAsync(cancellationToken);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public void Dispose()
|
|
{
|
|
if (_isDisposed)
|
|
return;
|
|
|
|
_isDisposed = true;
|
|
DisconnectInternalAsync(CancellationToken.None).Wait();
|
|
|
|
_client.Dispose();
|
|
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public Task<IReadOnlyList<byte>> InvokeAsync(IReadOnlyList<byte> request, Func<IReadOnlyList<byte>, bool> validateResponseComplete, CancellationToken cancellationToken = default)
|
|
{
|
|
#if NET8_0_OR_GREATER
|
|
ObjectDisposedException.ThrowIf(_isDisposed, this);
|
|
#else
|
|
if (_isDisposed)
|
|
throw new ObjectDisposedException(GetType().FullName);
|
|
#endif
|
|
|
|
if (!IsConnected)
|
|
throw new ApplicationException($"Connection is not open");
|
|
|
|
if (request?.Count < 1)
|
|
throw new ArgumentNullException(nameof(request));
|
|
|
|
#if NET8_0_OR_GREATER
|
|
ArgumentNullException.ThrowIfNull(validateResponseComplete);
|
|
#else
|
|
if (validateResponseComplete == null)
|
|
throw new ArgumentNullException(nameof(validateResponseComplete));
|
|
#endif
|
|
|
|
var item = new RequestQueueItem
|
|
{
|
|
Request = [.. request],
|
|
ValidateResponseComplete = validateResponseComplete,
|
|
TaskCompletionSource = new(),
|
|
CancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken),
|
|
};
|
|
|
|
item.CancellationTokenRegistration = item.CancellationTokenSource.Token.Register(() =>
|
|
{
|
|
_requestQueue.Remove(item);
|
|
item.CancellationTokenSource.Dispose();
|
|
item.TaskCompletionSource.TrySetCanceled(cancellationToken);
|
|
item.CancellationTokenRegistration.Dispose();
|
|
});
|
|
|
|
_requestQueue.Enqueue(item);
|
|
return item.TaskCompletionSource.Task;
|
|
}
|
|
|
|
private async Task ReconnectInternalAsync(CancellationToken cancellationToken)
|
|
{
|
|
if (!_reconnectLock.Wait(0, cancellationToken))
|
|
return;
|
|
|
|
try
|
|
{
|
|
_isConnected = false;
|
|
_processingCts?.Cancel();
|
|
await _processingTask.ConfigureAwait(false);
|
|
|
|
int delay = 1;
|
|
int maxDelay = 60;
|
|
|
|
var ipAddresses = Resolve(Hostname);
|
|
if (ipAddresses.Count == 0)
|
|
throw new ApplicationException($"Could not resolve hostname '{Hostname}'");
|
|
|
|
var startTime = DateTime.UtcNow;
|
|
while (!cancellationToken.IsCancellationRequested)
|
|
{
|
|
try
|
|
{
|
|
foreach (var ipAddress in ipAddresses)
|
|
{
|
|
_client.Close();
|
|
|
|
#if NET6_0_OR_GREATER
|
|
using var connectTask = _client.ConnectAsync(ipAddress, Port, cancellationToken);
|
|
#else
|
|
using var connectTask = _client.ConnectAsync(ipAddress, Port);
|
|
#endif
|
|
if (await Task.WhenAny(connectTask, Task.Delay(ReadTimeout, cancellationToken)) == connectTask)
|
|
{
|
|
await connectTask;
|
|
if (_client.Connected)
|
|
{
|
|
_isConnected = true;
|
|
|
|
_processingCts?.Dispose();
|
|
_processingCts = new();
|
|
_processingTask = ProcessAsync(_processingCts.Token);
|
|
|
|
SetKeepAlive();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
throw new SocketException((int)SocketError.TimedOut);
|
|
}
|
|
catch (SocketException) when (ReconnectTimeout == TimeSpan.MaxValue || DateTime.UtcNow.Subtract(startTime) < ReconnectTimeout)
|
|
{
|
|
delay *= 2;
|
|
if (delay > maxDelay)
|
|
delay = maxDelay;
|
|
|
|
try
|
|
{
|
|
await Task.Delay(TimeSpan.FromSeconds(delay), cancellationToken).ConfigureAwait(false);
|
|
}
|
|
catch
|
|
{ /* keep it quiet */ }
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_reconnectLock.Release();
|
|
}
|
|
}
|
|
|
|
private async Task DisconnectInternalAsync(CancellationToken cancellationToken)
|
|
{
|
|
_disconnectCts?.Cancel();
|
|
_processingCts?.Cancel();
|
|
|
|
try
|
|
{
|
|
await _reconnectTask.ConfigureAwait(false);
|
|
await _processingTask.ConfigureAwait(false);
|
|
}
|
|
catch
|
|
{ /* keep it quiet */ }
|
|
|
|
// Ensure that the client is closed
|
|
await _reconnectLock.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
try
|
|
{
|
|
_isConnected = false;
|
|
_client.Close();
|
|
}
|
|
finally
|
|
{
|
|
_reconnectLock.Release();
|
|
}
|
|
|
|
_disconnectCts?.Dispose();
|
|
_disconnectCts = null;
|
|
|
|
_processingCts?.Dispose();
|
|
_processingCts = null;
|
|
|
|
while (_requestQueue.TryDequeue(out var item))
|
|
{
|
|
item.CancellationTokenRegistration.Dispose();
|
|
item.CancellationTokenSource.Dispose();
|
|
item.TaskCompletionSource.TrySetCanceled(CancellationToken.None);
|
|
}
|
|
}
|
|
|
|
#region Processing
|
|
|
|
private async Task ProcessAsync(CancellationToken cancellationToken)
|
|
{
|
|
while (!cancellationToken.IsCancellationRequested)
|
|
{
|
|
var item = await _requestQueue.DequeueAsync(cancellationToken).ConfigureAwait(false);
|
|
item.CancellationTokenRegistration.Dispose();
|
|
|
|
using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, item.CancellationTokenSource.Token);
|
|
try
|
|
{
|
|
var stream = _client.GetStream();
|
|
await stream.FlushAsync(linkedCts.Token).ConfigureAwait(false);
|
|
|
|
#if NET6_0_OR_GREATER
|
|
await stream.WriteAsync(item.Request, linkedCts.Token).ConfigureAwait(false);
|
|
#else
|
|
await stream.WriteAsync(item.Request, 0, item.Request.Length, linkedCts.Token).ConfigureAwait(false);
|
|
#endif
|
|
|
|
linkedCts.Token.ThrowIfCancellationRequested();
|
|
|
|
var bytes = new List<byte>();
|
|
byte[] buffer = new byte[260];
|
|
|
|
do
|
|
{
|
|
#if NET6_0_OR_GREATER
|
|
int readCount = await stream.ReadAsync(buffer, linkedCts.Token).ConfigureAwait(false);
|
|
#else
|
|
int readCount = await stream.ReadAsync(buffer, 0, buffer.Length, linkedCts.Token).ConfigureAwait(false);
|
|
#endif
|
|
if (readCount < 1)
|
|
throw new EndOfStreamException();
|
|
|
|
bytes.AddRange(buffer.Take(readCount));
|
|
|
|
linkedCts.Token.ThrowIfCancellationRequested();
|
|
}
|
|
while (!item.ValidateResponseComplete(bytes));
|
|
|
|
item.TaskCompletionSource.TrySetResult(bytes);
|
|
}
|
|
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
|
|
{
|
|
// DisconnectAsync() called
|
|
item.TaskCompletionSource.TrySetCanceled(cancellationToken);
|
|
return;
|
|
}
|
|
catch (OperationCanceledException) when (item.CancellationTokenSource.IsCancellationRequested)
|
|
{
|
|
item.TaskCompletionSource.TrySetCanceled(item.CancellationTokenSource.Token);
|
|
continue;
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
item.TaskCompletionSource.TrySetException(ex);
|
|
_reconnectTask = ReconnectInternalAsync(_disconnectCts.Token);
|
|
}
|
|
catch (SocketException ex)
|
|
{
|
|
item.TaskCompletionSource.TrySetException(ex);
|
|
_reconnectTask = ReconnectInternalAsync(_disconnectCts.Token);
|
|
}
|
|
catch (TimeoutException ex)
|
|
{
|
|
item.TaskCompletionSource.TrySetException(ex);
|
|
_reconnectTask = ReconnectInternalAsync(_disconnectCts.Token);
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
item.TaskCompletionSource.TrySetException(ex);
|
|
_reconnectTask = ReconnectInternalAsync(_disconnectCts.Token);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
item.TaskCompletionSource.TrySetException(ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class RequestQueueItem
|
|
{
|
|
public byte[] Request { get; set; }
|
|
|
|
public Func<IReadOnlyList<byte>, bool> ValidateResponseComplete { get; set; }
|
|
|
|
public TaskCompletionSource<IReadOnlyList<byte>> TaskCompletionSource { get; set; }
|
|
|
|
public CancellationTokenSource CancellationTokenSource { get; set; }
|
|
|
|
public CancellationTokenRegistration CancellationTokenRegistration { get; set; }
|
|
}
|
|
|
|
#endregion Processing
|
|
|
|
#region Helpers
|
|
|
|
[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
|
|
private static List<IPAddress> Resolve(string hostname)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(hostname))
|
|
return [];
|
|
|
|
if (IPAddress.TryParse(hostname, out var ipAddress))
|
|
return [ipAddress];
|
|
|
|
try
|
|
{
|
|
return Dns.GetHostAddresses(hostname)
|
|
.Where(a => a.AddressFamily == AddressFamily.InterNetwork || a.AddressFamily == AddressFamily.InterNetworkV6)
|
|
.OrderBy(a => a.AddressFamily) // Prefer IPv4
|
|
.ToList();
|
|
}
|
|
catch
|
|
{
|
|
return [];
|
|
}
|
|
}
|
|
|
|
[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
|
|
private void SetKeepAlive()
|
|
{
|
|
#if NET6_0_OR_GREATER
|
|
_client.Client?.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, KeepAliveInterval.TotalMilliseconds > 0);
|
|
_client.Client?.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveTime, (int)KeepAliveInterval.TotalSeconds);
|
|
_client.Client?.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveInterval, (int)KeepAliveInterval.TotalSeconds);
|
|
#else
|
|
// See: https://github.com/dotnet/runtime/issues/25555
|
|
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
|
|
return;
|
|
|
|
bool isEnabled = KeepAliveInterval.TotalMilliseconds > 0;
|
|
uint interval = KeepAliveInterval.TotalMilliseconds > uint.MaxValue
|
|
? uint.MaxValue
|
|
: (uint)KeepAliveInterval.TotalMilliseconds;
|
|
int uIntSize = sizeof(uint);
|
|
byte[] config = new byte[uIntSize * 3];
|
|
|
|
Array.Copy(BitConverter.GetBytes(isEnabled ? 1U : 0U), 0, config, uIntSize * 0, uIntSize);
|
|
Array.Copy(BitConverter.GetBytes(interval), 0, config, uIntSize * 1, uIntSize);
|
|
Array.Copy(BitConverter.GetBytes(interval), 0, config, uIntSize * 2, uIntSize);
|
|
_client.Client?.IOControl(IOControlCode.KeepAliveValues, config, null);
|
|
#endif
|
|
}
|
|
|
|
#endregion Helpers
|
|
}
|
|
}
|