OmronFinsTcpSimulatorServer.cs

이 파일의 문서화 페이지로 가기

using System.Net;
using System.Net.Sockets;
using Dreamine.PLC.Core.Memory;
using Dreamine.PLC.Omron.Fins.Protocol;
 
namespace Dreamine.PLC.Omron.Fins.Simulation;

public sealed class OmronFinsTcpSimulatorServer : IAsyncDisposable
{
    private readonly OmronFinsSimulatorServerOptions _options;
    private readonly InMemoryPlcMemory _memory;
    private readonly OmronFinsSimulatorProtocol _protocol;
    private readonly List<TcpClient> _clients = [];
    private readonly object _syncRoot = new();
    private TcpListener? _listener;
    private CancellationTokenSource? _cts;
    private Task? _acceptTask;

    public OmronFinsTcpSimulatorServer(OmronFinsSimulatorServerOptions options)
        : this(options, new InMemoryPlcMemory())
    {
    }

    public OmronFinsTcpSimulatorServer(OmronFinsSimulatorServerOptions options, InMemoryPlcMemory memory)
    {
        _options = options ?? throw new ArgumentNullException(nameof(options));
        _memory = memory ?? throw new ArgumentNullException(nameof(memory));
        _protocol = new OmronFinsSimulatorProtocol(_memory, _options);
        _protocol.StatusChanged += (_, message) => StatusChanged?.Invoke(this, message);
    }

    public event EventHandler<string>? StatusChanged;

    public bool IsRunning => _listener is not null;

    public Task StartAsync()
    {
        if (IsRunning)
        {
            return Task.CompletedTask;
        }
 
        var address = ParseAddress(_options.Host);
 
        _cts = new CancellationTokenSource();
        _listener = new TcpListener(address, _options.Port);
        _listener.Start();
        _acceptTask = AcceptLoopAsync(_cts.Token);
        StatusChanged?.Invoke(this, $"FINS TCP simulator listening on {_options.Host}:{_options.Port}.");
        return Task.CompletedTask;
    }

    public async Task StopAsync()
    {
        if (!IsRunning)
        {
            return;
        }
 
        _cts?.Cancel();
        _listener?.Stop();
        _listener = null;
 
        TcpClient[] clients;
        lock (_syncRoot)
        {
            clients = _clients.ToArray();
            _clients.Clear();
        }
 
        foreach (var client in clients)
        {
            client.Dispose();
        }
 
        if (_acceptTask is not null)
        {
            try
            {
                await _acceptTask.ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
            }
            catch (ObjectDisposedException)
            {
            }
            catch (SocketException)
            {
            }
        }
 
        _cts?.Dispose();
        _cts = null;
        _acceptTask = null;
        StatusChanged?.Invoke(this, "FINS TCP simulator stopped.");
    }

    public async ValueTask DisposeAsync()
    {
        await StopAsync().ConfigureAwait(false);
    }
 

    private static IPAddress ParseAddress(string host)
    {
        if (string.IsNullOrWhiteSpace(host) || host == "0.0.0.0" || host == "*" || host == "+")
        {
            return IPAddress.Any;
        }
 
        return IPAddress.TryParse(host, out var address) ? address : IPAddress.Any;
    }

    private async Task AcceptLoopAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested && _listener is not null)
        {
            TcpClient client;
 
            try
            {
                client = await _listener.AcceptTcpClientAsync(cancellationToken).ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
                break;
            }
            catch (ObjectDisposedException)
            {
                break;
            }
            catch (SocketException) when (cancellationToken.IsCancellationRequested)
            {
                break;
            }
 
            lock (_syncRoot)
            {
                _clients.Add(client);
            }
 
            _ = Task.Run(() => ClientLoopAsync(client, cancellationToken), cancellationToken);
        }
    }

    private async Task ClientLoopAsync(TcpClient client, CancellationToken cancellationToken)
    {
        try
        {
            using (client)
            {
                var stream = client.GetStream();
                while (!cancellationToken.IsCancellationRequested && client.Connected)
                {
                    var packet = await ReceiveFinsTcpPacketAsync(stream, cancellationToken).ConfigureAwait(false);
                    var request = OmronFinsTcpPacket.Extract(packet);
                    var response = _protocol.HandleRequest(request);
                    var responsePacket = OmronFinsTcpPacket.Wrap(response);
                    await stream.WriteAsync(responsePacket, cancellationToken).ConfigureAwait(false);
                    await stream.FlushAsync(cancellationToken).ConfigureAwait(false);
                }
            }
        }
        catch (OperationCanceledException)
        {
        }
        catch (IOException)
        {
        }
        catch (SocketException)
        {
        }
        catch (ObjectDisposedException)
        {
        }
        catch (Exception ex)
        {
            StatusChanged?.Invoke(this, $"FINS TCP client error: {ex.Message}");
        }
        finally
        {
            lock (_syncRoot)
            {
                _clients.Remove(client);
            }
        }
    }

    private static async Task<byte[]> ReceiveFinsTcpPacketAsync(NetworkStream stream, CancellationToken cancellationToken)
    {
        var header = new byte[16];
        await ReadExactlyAsync(stream, header, cancellationToken).ConfigureAwait(false);
        var length = OmronFinsEndian.ReadInt32(header, 4);
        if (length < 8)
        {
            throw new InvalidOperationException($"Invalid FINS/TCP packet length: {length}.");
        }
 
        var body = new byte[length - 8];
        await ReadExactlyAsync(stream, body, cancellationToken).ConfigureAwait(false);
        var packet = new byte[header.Length + body.Length];
        Buffer.BlockCopy(header, 0, packet, 0, header.Length);
        Buffer.BlockCopy(body, 0, packet, header.Length, body.Length);
        return packet;
    }

    private static async Task ReadExactlyAsync(NetworkStream stream, byte[] buffer, CancellationToken cancellationToken)
    {
        var offset = 0;
        while (offset < buffer.Length)
        {
            var read = await stream.ReadAsync(buffer.AsMemory(offset, buffer.Length - offset), cancellationToken).ConfigureAwait(false);
            if (read == 0)
            {
                throw new IOException("The FINS TCP client closed the connection.");
            }
 
            offset += read;
        }
    }
}