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
}
|