借助网络配置,控制Modbus工具的日志显示,避免卡死界面
智能大石头 authored at 2021-12-11 22:09:19
19.64 KiB
XCoder
using System.Collections.Concurrent;
using System.Collections.ObjectModel;
using System.Net;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NewLife;
using NewLife.Data;
using NewLife.Log;
using NewLife.Net;
using NewLife.Remoting;
using NewLife.XCoder.Models;
using NewLife.XCoder.Tools.Net;

using NewLife.XCoder.Services;

namespace NewLife.XCoder.ViewModels;

/// <summary>API 服务发现 ViewModel</summary>
/// <remarks>
/// 向局域网广播,或按目标地址(单个 IP、CIDR 网段、IP 范围)探测 NewLife ApiServer。
/// 应答统一在 <see cref="ApiClient.Received"/> 事件里收集:广播请求会收到多台设备的应答,
/// 不能只取第一个返回值;收集阶段在后台线程,界面刷新统一回到扫描调用线程完成。
/// </remarks>
public partial class ApiDiscoverViewModel : ObservableObject
{
    #region 构造
    /// <summary>实例化 API 服务发现 ViewModel</summary>
    public ApiDiscoverViewModel() => Services.CollectionChanged += (s, e) => OnPropertyChanged(nameof(IsEmpty));
    #endregion

    #region 属性
    private CancellationTokenSource? _cancel;

    /// <summary>应答等待时间(毫秒)</summary>
    public const Int32 ResponseTimeout = 1500;

    /// <summary>单次最多探测的地址数</summary>
    public const Int32 MaxTargets = 1024;

    /// <summary>端口</summary>
    [ObservableProperty]
    private Int32 _port = 5500;

    /// <summary>目标 IP,留空则向局域网广播</summary>
    [ObservableProperty]
    private String _targetIp = "";

    /// <summary>发现的服务列表</summary>
    public ObservableCollection<ApiServiceInfo> Services { get; } = [];

    /// <summary>是否尚未发现服务</summary>
    public Boolean IsEmpty => Services.Count == 0;

    /// <summary>选中的服务</summary>
    [ObservableProperty]
    private ApiServiceInfo? _selectedService;

    /// <summary>日志输出</summary>
    [ObservableProperty]
    private String _log = "";

    /// <summary>状态摘要</summary>
    [ObservableProperty]
    private String _status = LocalizationService.T("就绪");

    /// <summary>是否正在扫描</summary>
    [ObservableProperty]
    private Boolean _isScanning;
    #endregion

    #region 扫描
    /// <summary>扫描网络中的 API 服务</summary>
    /// <returns>扫描任务</returns>
    [RelayCommand]
    private async Task Scan()
    {
        if (IsScanning) return;

        if (!EndpointParser.IsValidPort(Port))
        {
            AppendLog($"端口无效:{Port}(应为 1~65535)");
            Status = LocalizationService.T("端口无效");
            return;
        }

        IList<IPAddress> targets;
        try
        {
            targets = ParseTargets(TargetIp);
        }
        catch (ArgumentException ex)
        {
            AppendLog($"目标 IP 无效:{ex.Message}");
            Status = LocalizationService.T("目标地址无效");
            return;
        }

        var port = Port;
        var broadcast = targets.Count == 0;
        var locals = GetLocalAddresses();
        var bag = new ConcurrentDictionary<String, ApiServiceInfo>();

        Services.Clear();
        SelectedService = null;

        var cts = _cancel = new CancellationTokenSource();
        var token = cts.Token;
        IsScanning = true;
        Status = LocalizationService.T("扫描中…");

        try
        {
            AppendLog(broadcast
                ? $"开始在端口 {port} 上广播扫描 API 服务({locals.Count} 个本机网卡)..."
                : $"开始探测 {targets.Count} 个地址,端口 {port}...");

            var tasks = new List<Task>();
            if (broadcast)
            {
                tasks.Add(ProbeAsync(null, [new IPEndPoint(IPAddress.Broadcast, port)], bag, token));
                foreach (var local in locals) tasks.Add(ProbeAsync(local, [new IPEndPoint(IPAddress.Broadcast, port)], bag, token));
            }
            else
            {
                // 按本机网卡分组探测,让应答回到对应网段的套接字上
                var groups = new Dictionary<String, (IPAddress? Local, List<IPEndPoint> Targets)>();
                foreach (var ip in targets)
                {
                    var local = locals.FirstOrDefault(e => SameSubnet(e, ip));
                    var key = local + "";
                    if (!groups.TryGetValue(key, out var group))
                    {
                        group = (local, []);
                        groups[key] = group;
                    }
                    group.Targets.Add(new IPEndPoint(ip, port));
                }

                foreach (var group in groups.Values) tasks.Add(ProbeAsync(group.Local, group.Targets, bag, token));
            }

            await Task.WhenAll(tasks);

            // 用户点了停止:保留已收到的结果,不再做补充查询
            var canceled = token.IsCancellationRequested;
            if (!canceled) await EnrichStarAgentAsync(bag.Values, token);

            foreach (var item in bag.Values.OrderBy(e => e.RemoteIP, StringComparer.Ordinal).ThenBy(e => e.Port))
            {
                Services.Add(item);
                AppendLog($"发现服务:{item.EndPoint} {item.DisplayName} {item.MachineName} -> {item.RawJson}");
            }

            if (canceled)
            {
                Status = $"已取消,收到 {Services.Count} 个服务";
                AppendLog("扫描已停止");
            }
            else
            {
                Status = $"发现 {Services.Count} 个服务";
                AppendLog($"扫描完成,发现 {Services.Count} 个服务(同一设备已去重)");
            }
        }
        catch (OperationCanceledException)
        {
            Status = LocalizationService.T("已取消");
            AppendLog("扫描已停止");
        }
        catch (Exception ex)
        {
            Status = LocalizationService.T("扫描失败");
            AppendLog($"扫描出错:{ex.Message}");
        }
        finally
        {
            IsScanning = false;
            _cancel = null;
            cts.Dispose();
        }
    }

    /// <summary>停止正在进行的扫描</summary>
    [RelayCommand]
    private void Cancel()
    {
        if (!IsScanning) return;

        _cancel?.Cancel();
        Status = LocalizationService.T("正在停止…");
    }

    private async Task ProbeAsync(IPAddress? local, IReadOnlyList<IPEndPoint> targets, ConcurrentDictionary<String, ApiServiceInfo> bag, CancellationToken token)
    {
        var clients = new List<ApiClient>();
        try
        {
            foreach (var ep in targets)
            {
                token.ThrowIfCancellationRequested();

                var client = new ApiClient($"udp://{ep.Address}:{ep.Port}")
                {
                    Log = Logger.Null,
                    EncoderLog = Logger.Null,
                };
                if (local != null) client.Local = new NetUri { Address = local };
                client.Received += (s, e) => OnReply(s, e, local, ep.Port, bag);
                clients.Add(client);

                // 不等待返回值:广播与多目标场景会有多台设备分别应答,统一在 Received 事件里收集
                _ = InvokeAsync(client, token);
            }

            await Task.Delay(ResponseTimeout, token);
        }
        catch (OperationCanceledException) { }
        finally
        {
            foreach (var client in clients)
            {
                try { client.Dispose(); } catch { }
            }
        }
    }

    private static async Task InvokeAsync(ApiClient client, CancellationToken token)
    {
        try
        {
            // 未收到应答时会在超时后抛异常;这里只关心 Received 事件,异常直接忽略
            await client.InvokeAsync<Object>("Api/Info", null, token);
        }
        catch
        {
        }
    }

    private void OnReply(Object? sender, ApiReceivedEventArgs e, IPAddress? local, Int32 port, ConcurrentDictionary<String, ApiServiceInfo> bag)
    {
        if (e.Message == null || !e.Message.Reply) return;

        var msg = e.ApiMessage;
        var client = sender as ApiClient;
        if (msg?.Data == null || client?.Encoder == null) return;

        try
        {
            if (client.Encoder.DecodeResult(msg.Action, msg.Data, e.Message, typeof(ApiServiceInfo)) is not ApiServiceInfo info) return;

            // 广播会被本机 ApiServer 收到并回一个空包,不能让它污染列表
            if (info.Name.IsNullOrEmpty() && info.MachineName.IsNullOrEmpty() && info.LocalIP.IsNullOrEmpty() &&
                info.Version.IsNullOrEmpty() && info.FileVersion.IsNullOrEmpty() && info.OS.IsNullOrEmpty()) return;

            // 广播应答的来源常常是 255.255.255.255,退化为设备自报的本机地址
            var remote = (e.UserState as ReceivedEventArgs)?.Remote;
            var address = remote?.Address;
            if (address == null || address.IsAny() || Equals(address, IPAddress.Broadcast))
                address = GetDeviceAddress(info.LocalIP, local);

            info.RemoteIP = address + "";
            info.Port = remote?.Port ?? 0;
            if (info.Port <= 0) info.Port = port;
            info.FoundTime = DateTime.Now;
            info.RawJson = msg.Data?.ToStr() ?? "";

            var key = ApiServiceInfo.GetKey(info);
            bag.AddOrUpdate(key, info, (k, old) => { ApiServiceInfo.Merge(old, info); return old; });
        }
        catch
        {
            // 单条应答解析失败不应中断整轮扫描
        }
    }

    private static async Task EnrichStarAgentAsync(IEnumerable<ApiServiceInfo> services, CancellationToken token)
    {
        var tasks = new List<Task>();
        foreach (var item in services)
        {
            if (!String.Equals(item.Name, "StarAgent", StringComparison.OrdinalIgnoreCase)) continue;
            if (item.RemoteIP.IsNullOrEmpty() || item.Port <= 0) continue;

            tasks.Add(Task.Run(() => EnrichOneAsync(item, token)));
        }

        if (tasks.Count > 0) await Task.WhenAll(tasks);
    }

    private static async Task EnrichOneAsync(ApiServiceInfo item, CancellationToken token)
    {
        try
        {
            using var client = new ApiClient($"udp://{item.RemoteIP}:{item.Port}")
            {
                Log = Logger.Null,
                EncoderLog = Logger.Null,
            };
            using var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
            cts.CancelAfter(ResponseTimeout);

            if (await client.InvokeAsync<AgentDetail>("Info", null, cts.Token) is { } detail)
            {
                item.Code = detail.Code + "";
                item.Server = detail.Server + "";
            }
        }
        catch
        {
            // 补充信息失败不影响已经发现的服务
        }
    }

    /// <summary>星尘代理 Info 应答(只取需要的字段)</summary>
    private sealed class AgentDetail
    {
        /// <summary>设备编码</summary>
        public String? Code { get; set; }

        /// <summary>服务器地址</summary>
        public String? Server { get; set; }
    }

    /// <summary>清空日志</summary>
    [RelayCommand]
    private void ClearLog() => Log = "";

    /// <summary>清空服务列表</summary>
    [RelayCommand]
    private void ClearServices()
    {
        Services.Clear();
        SelectedService = null;
        Status = LocalizationService.T("就绪");
    }

    /// <summary>追加一条操作反馈,供界面层调用</summary>
    /// <param name="message">消息</param>
    public void Report(String message)
    {
        Status = LocalizationService.Translate(message);
        AppendLog(message);
    }

    private void AppendLog(String msg)
    {
        msg = NewLife.XCoder.Services.LocalizationService.Translate(msg);
        Log += $"{msg}\r\n";
    }
    #endregion

    #region 地址解析
    /// <summary>解析目标地址文本</summary>
    /// <param name="text">
    /// 用户输入。留空表示广播;支持单个 IP、CIDR 网段(如 192.168.1.0/24)、
    /// IP 范围(如 192.168.1.1-192.168.1.20),多项以逗号或空格分隔。
    /// </param>
    /// <returns>目标地址列表;留空时返回空列表</returns>
    /// <exception cref="ArgumentException">格式非法或数量超过 <see cref="MaxTargets"/></exception>
    public static IList<IPAddress> ParseTargets(String? text)
    {
        var list = new List<IPAddress>();
        if (text.IsNullOrWhiteSpace()) return list;

        foreach (var item in text!.Split([',', ';', ' ', '\r', '\n', '\t'], StringSplitOptions.RemoveEmptyEntries))
        {
            var value = item.Trim();
            if (value.IsNullOrEmpty()) continue;

            var slash = value.IndexOf('/');
            if (slash > 0)
            {
                list.AddRange(ParseCidr(value[..slash], value[(slash + 1)..]));
                continue;
            }

            var dash = value.IndexOf('-');
            if (dash > 0)
            {
                list.AddRange(ParseRange(value[..dash], value[(dash + 1)..]));
                continue;
            }

            if (!IPAddress.TryParse(value, out var ip)) throw new ArgumentException($"无法识别:{value}");

            list.Add(ip);
        }

        var result = new List<IPAddress>(list.Count);
        var set = new HashSet<String>();
        foreach (var ip in list)
        {
            if (set.Add(ip + "")) result.Add(ip);
        }

        if (result.Count > MaxTargets) throw new ArgumentException($"目标地址过多({result.Count} 个),一次最多 {MaxTargets} 个");

        return result;
    }

    private static List<IPAddress> ParseCidr(String address, String bitsText)
    {
        if (!IPAddress.TryParse(address.Trim(), out var ip) || !ip.IsIPv4()) throw new ArgumentException($"网段地址必须是 IPv4:{address}");
        if (!Int32.TryParse(bitsText.Trim(), out var bits) || bits is < 16 or > 32) throw new ArgumentException($"网段掩码应为 16~32:{address}/{bitsText}");

        var list = new List<IPAddress>();
        if (bits == 32)
        {
            list.Add(ip);

            return list;
        }

        // 输入地址可以带主机位(如 10.0.0.12/24),先按掩码对齐到网络地址再展开
        var mask = bits == 0 ? 0 : UInt32.MaxValue << (32 - bits);
        var network = ToUInt32(ip.GetAddressBytes()) & mask;
        var total = 1u << (32 - bits);
        var first = bits == 31 ? network : network + 1;
        var last = bits == 31 ? network + 1 : network + total - 2;
        for (var value = first; value <= last; value++)
        {
            if (list.Count >= MaxTargets) throw new ArgumentException($"网段地址过多(超过 {MaxTargets} 个),请缩小范围");

            list.Add(ToAddress(value));
        }

        return list;
    }

    private static List<IPAddress> ParseRange(String startText, String endText)
    {
        if (!IPAddress.TryParse(startText.Trim(), out var start) || !start.IsIPv4()) throw new ArgumentException($"范围起点必须是 IPv4:{startText}");
        if (!IPAddress.TryParse(endText.Trim(), out var end) || !end.IsIPv4()) throw new ArgumentException($"范围终点必须是 IPv4:{endText}");

        var first = ToUInt32(start.GetAddressBytes());
        var last = ToUInt32(end.GetAddressBytes());
        if (first > last) throw new ArgumentException($"范围起点大于终点:{startText}-{endText}");
        if (last - first + 1 > MaxTargets) throw new ArgumentException($"范围过大(超过 {MaxTargets} 个),请缩小范围");

        var list = new List<IPAddress>();
        for (var value = first; ; value++)
        {
            list.Add(ToAddress(value));
            if (value == last) break;
        }

        return list;
    }

    private static UInt32 ToUInt32(Byte[] bytes) => ((UInt32)bytes[0] << 24) | ((UInt32)bytes[1] << 16) | ((UInt32)bytes[2] << 8) | bytes[3];

    private static IPAddress ToAddress(UInt32 value)
    {
        var bytes = new Byte[] { (Byte)(value >> 24), (Byte)(value >> 16), (Byte)(value >> 8), (Byte)value };

        return new IPAddress(bytes);
    }

    /// <summary>获取本机可用的 IPv4 地址</summary>
    /// <returns>地址列表</returns>
    private static List<IPAddress> GetLocalAddresses()
    {
        var list = new List<IPAddress>();
        foreach (var ip in NetHelper.GetIPs())
        {
            if (ip.IsIPv4() && !ip.IsAny() && !IPAddress.IsLoopback(ip)) list.Add(ip);
        }

        return list;
    }

    /// <summary>从设备自报的地址里挑一个可达地址</summary>
    /// <param name="localIPs">设备上报的本机地址,逗号分隔</param>
    /// <param name="probeLocal">本轮探测使用的本机地址</param>
    /// <returns>设备地址;无法解析时返回 null</returns>
    private static IPAddress? GetDeviceAddress(String localIPs, IPAddress? probeLocal)
    {
        if (localIPs.IsNullOrEmpty()) return null;

        var ips = new List<IPAddress>();
        foreach (var item in localIPs.Split([',', ';', ' ', '|'], StringSplitOptions.RemoveEmptyEntries))
        {
            if (IPAddress.TryParse(item.Trim(), out var ip) && ip.IsIPv4() && !ip.IsAny()) ips.Add(ip);
        }
        if (ips.Count == 0) return null;

        // 优先与本轮探测网卡同网段,其次与本机任一网卡同网段,最后退回第一个
        var locals = new List<IPAddress>();
        if (probeLocal != null) locals.Add(probeLocal);
        locals.AddRange(GetLocalAddresses());

        foreach (var ip in ips)
        {
            foreach (var local in locals)
            {
                if (SameSubnet(ip, local)) return ip;
            }
        }

        return ips[0];
    }

    /// <summary>判断两个地址是否同一网段</summary>
    /// <param name="left">地址</param>
    /// <param name="right">地址</param>
    /// <returns>是否同网段</returns>
    /// <remarks>拿不到网卡掩码,按常见的 /24 判断,仅用于多个候选地址之间挑一个</remarks>
    private static Boolean SameSubnet(IPAddress left, IPAddress right)
    {
        if (!left.IsIPv4() || !right.IsIPv4()) return false;

        var a = left.GetAddressBytes();
        var b = right.GetAddressBytes();

        return a[0] == b[0] && a[1] == b[1] && a[2] == b[2];
    }
    #endregion

    #region 导出
    /// <summary>把发现结果转成 CSV 文本</summary>
    /// <param name="services">服务列表</param>
    /// <returns>CSV 文本</returns>
    public static String ToCsv(IEnumerable<ApiServiceInfo> services)
    {
        var sb = new System.Text.StringBuilder();
        sb.AppendLine("名称,标题,主机,系统,版本,接口版本,地址,设备地址,编码,服务器,服务端时间,发现时间,原始应答");

        foreach (var item in services)
        {
            sb.AppendLine(String.Join(",",
                Csv(item.Name),
                Csv(item.Title),
                Csv(item.MachineName),
                Csv(item.OS),
                Csv(item.DisplayVersion),
                Csv(item.ApiVersion),
                Csv(item.EndPoint),
                Csv(item.LocalIP),
                Csv(item.Code),
                Csv(item.ServerAddress),
                Csv(item.Time),
                Csv(item.FoundTime > DateTime.MinValue ? item.FoundTime.ToString("yyyy-MM-dd HH:mm:ss") : ""),
                Csv(item.RawJson)));
        }

        return sb.ToString();
    }

    private static String Csv(String? value)
    {
        if (value.IsNullOrEmpty()) return "";

        var text = value!.Replace("\"", "\"\"");
        if (text.Contains(',') || text.Contains('"') || text.Contains('\n') || text.Contains('\r')) return $"\"{text}\"";

        return text;
    }
    #endregion
}