MitsubishiMcUdpSimulatorServer.cs

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

using System.Net;
using System.Net.Sockets;
using Dreamine.PLC.Core.Memory;
 
namespace Dreamine.PLC.Mitsubishi.MC.Simulation;

public sealed class MitsubishiMcUdpSimulatorServer : IAsyncDisposable
{
    private readonly MitsubishiMcSimulatorServerOptions _options;
    private readonly MitsubishiMcBinary3ESimulatorProtocol _protocol;
    private CancellationTokenSource? _cts;
    private UdpClient? _udpClient;
    private Task? _receiveTask;

    public MitsubishiMcUdpSimulatorServer(MitsubishiMcSimulatorServerOptions options)
        : this(options, new InMemoryPlcMemory())
    {
    }

    public MitsubishiMcUdpSimulatorServer(MitsubishiMcSimulatorServerOptions options, InMemoryPlcMemory memory)
    {
        _options = options ?? throw new ArgumentNullException(nameof(options));
        _protocol = new MitsubishiMcBinary3ESimulatorProtocol(memory ?? throw new ArgumentNullException(nameof(memory)), options);
        _protocol.StatusChanged += OnProtocolStatusChanged;
    }

    public event EventHandler<string>? StatusChanged;

    public bool IsRunning => _udpClient is not null;

    public Task StartAsync(CancellationToken cancellationToken = default)
    {
        if (_udpClient is not null)
        {
            return Task.CompletedTask;
        }
 
        var address = ParseAddress(_options.Host);
        _udpClient = new UdpClient(new IPEndPoint(address, _options.Port));
        _cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        _receiveTask = Task.Run(() => ReceiveLoopAsync(_cts.Token), CancellationToken.None);
        StatusChanged?.Invoke(this, $"MC UDP simulator server started. {_options.Host}:{_options.Port}");
        return Task.CompletedTask;
    }

    public async Task StopAsync()
    {
        if (_udpClient is null)
        {
            return;
        }
 
        _cts?.Cancel();
        _udpClient.Close();
        _udpClient.Dispose();
        _udpClient = null;
 
        if (_receiveTask is not null)
        {
            try
            {
                await _receiveTask.ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
            }
            catch (ObjectDisposedException)
            {
            }
            catch (SocketException)
            {
            }
        }
 
        _cts?.Dispose();
        _cts = null;
        StatusChanged?.Invoke(this, "MC UDP simulator server stopped.");
    }

    public async ValueTask DisposeAsync()
    {
        _protocol.StatusChanged -= OnProtocolStatusChanged;
        await StopAsync().ConfigureAwait(false);
    }

    private async Task ReceiveLoopAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested && _udpClient is not null)
        {
            UdpReceiveResult request;
            try
            {
                request = await _udpClient.ReceiveAsync(cancellationToken).ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
                break;
            }
            catch (ObjectDisposedException)
            {
                break;
            }
            catch (SocketException)
            {
                break;
            }
 
            var response = _protocol.Execute(request.Buffer);
            await _udpClient.SendAsync(response, response.Length, request.RemoteEndPoint).ConfigureAwait(false);
        }
    }

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

    private void OnProtocolStatusChanged(object? sender, string e)
    {
        StatusChanged?.Invoke(this, e);
    }
}