using NewLife;
using NewLife.Log;
using NewLife.Serialization;
using NewLife.Threading;
using Stardust.Data.Nodes;
using Stardust.Models;
namespace Stardust.Server.Services;
/// <summary>定期从Microsoft官网同步.NET运行时安装包信息到DotNetPackage表</summary>
public class DotNetSyncService : IHostedService
{
private readonly ITracer _tracer;
private readonly StarServerSetting _setting;
private TimerX _timer;
private Int32 _lastPeriod;
private readonly HttpClient _http;
public DotNetSyncService(ITracer tracer, StarServerSetting setting)
{
_tracer = tracer;
_setting = setting;
_http = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
}
/// <summary>启动服务，初始化定时器。不管配置是否禁用都启动，DoSync 内判断配置</summary>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>任务</returns>
public Task StartAsync(CancellationToken cancellationToken)
{
// 不管配置是否禁用，都启动定时器。DoSync内判断配置，每次执行后更新周期
var period = _setting.DotNetSyncPeriod;
// 初始周期直接用配置值（默认43200秒=12小时），禁用时退回到60秒占位
var initPeriod = period > 0 ? period * 1000 : 60_000;
_timer = new TimerX(DoSync, null, 5_000, initPeriod)
{
Async = true,
};
_lastPeriod = period;
return Task.CompletedTask;
}
/// <summary>停止服务，销毁定时器</summary>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>任务</returns>
public Task StopAsync(CancellationToken cancellationToken)
{
_timer.TryDispose();
return Task.CompletedTask;
}
/// <summary>更新定时器周期，根据当前配置动态调整</summary>
private void UpdateTimer()
{
var period = _setting.DotNetSyncPeriod;
if (_lastPeriod == period) return;
_lastPeriod = period;
if (period <= 0)
{
// 禁用时改为每分钟检查，确保配置变化后能快速恢复
_timer.Period = 60_000;
XTrace.WriteLine("DotNetSyncService is paused, configured period={0}", period);
}
else
{
_timer.Period = period * 1000;
XTrace.WriteLine("DotNetSyncService period updated to {0} second(s)", period);
}
}
/// <summary>执行同步。扫描多个主版本的 .NET 运行时信息，从官方源拉取并更新到本地</summary>
/// <param name="state">定时器状态参数</param>
private async void DoSync(Object state)
{
var period = _setting.DotNetSyncPeriod;
if (period <= 0)
{
// 禁用时不执行同步，但每分钟会进来检查配置变化
UpdateTimer();
return;
}
var url = _setting.DotNetSyncUrl;
if (url.IsNullOrEmpty()) return;
using var span = _tracer?.NewSpan(nameof(DotNetSyncService));
try
{
// 扫描多个主版本
var majors = new[] { 6, 7, 8, 9, 10 };
foreach (var major in majors)
{
var u = url.Replace("{major}", major + "");
await SyncMajor(major + ".0", u, span);
}
}
catch (Exception ex)
{
span?.SetError(ex, null);
XTrace.Log.Error("DotNetSyncService.Error {0}", ex.Message);
}
finally
{
// 每次执行完后检查配置有无变化，动态更新定时器周期
UpdateTimer();
}
}
/// <summary>同步指定主版本的 .NET 运行时信息</summary>
/// <param name="versionPrefix">版本前缀，如 "6.0"</param>
/// <param name="url">官方发布 API 地址</param>
/// <param name="span">跟踪跨度</param>
private async Task SyncMajor(String versionPrefix, String url, ISpan span)
{
XTrace.WriteLine("DotNetSyncService.Sync {0}", url);
var json = await _http.GetStringAsync(url);
var js = JsonParser.Decode(json);
var releases = js["releases"] as IList<Object>;
if (releases == null) return;
// 预查当前大版本下所有 SDK 记录，供 SyncSdk 复用，避免循环内反复查库
var sdkPkgs = DotNetPackage.FindAll(DotNetPackage._.Kind == "sdk" &
DotNetPackage._.Version.StartsWith(versionPrefix));
foreach (var item in releases)
{
var rel = item as IDictionary<String, Object>;
if (rel == null) continue;
var ver = rel["release-version"] + "";
// 跳过预览版和RC版
if (ver.Contains("preview", StringComparison.OrdinalIgnoreCase) ||
ver.Contains("rc", StringComparison.OrdinalIgnoreCase)) continue;
// 处理 aspnetcore-runtime → Kind=aspnet
var allPkgs = DotNetPackage.FindAllByVersion(ver);
SyncRuntime(rel, "aspnetcore-runtime", "aspnet", ver, allPkgs);
// 处理 runtime → Kind=runtime（dotnet-runtime 基础运行时）
SyncRuntime(rel, "runtime", "runtime", ver, allPkgs);
// 处理 windowsdesktop → Kind=desktop
SyncRuntime(rel, "windowsdesktop", "desktop", ver, allPkgs);
// dotnet-hosting 不在顶级 key 中，而是在 aspnetcore-runtime.files 的最后一项，由 SyncRuntime 内识别
// 处理 sdk（单个主 SDK，如 10.0.301）→ Kind=sdk
SyncSdk(rel["sdk"] as IDictionary<String, Object>, sdkPkgs);
// 处理 sdks（多个 SDK 版本数组，如 [10.0.301, 10.0.109]）→ Kind=sdk
var sdks = rel["sdks"] as IList<Object>;
if (sdks != null)
{
foreach (var s in sdks)
SyncSdk(s as IDictionary<String, Object>, sdkPkgs);
}
}
}
private void SyncRuntime(IDictionary<String, Object> rel, String key, String kind, String version,
IList<DotNetPackage> allPkgs)
{
if (!rel.TryGetValue(key, out var v) || v == null) return;
// Microsoft JSON 结构: { "aspnetcore-runtime": { "files": [...] } }
var runtime = v as IDictionary<String, Object>;
if (runtime == null) return;
var files = runtime["files"] as IList<Object>;
if (files == null) return;
foreach (var item in files)
{
var file = item as IDictionary<String, Object>;
if (file == null) continue;
var name = file["name"] + "";
var url = file["url"] + "";
var rid = file["rid"] + "";
var hash = file["hash"] + "";
if (name.IsNullOrEmpty() || url.IsNullOrEmpty()) continue;
// 优先从 URL 截取文件名（JSON name 字段可能缺版本号，如 dotnet-hosting-win.exe）
var idx = url.LastIndexOf('/');
if (idx >= 0 && idx < url.Length - 1)
{
var urlName = url.Substring(idx + 1);
if (!urlName.IsNullOrEmpty() && urlName.Contains('.'))
name = urlName;
}
// 过滤：仅保留标准运行时安装包，排除 composite/targeting-pack 等变体
if (!IsStandardRuntimeFile(name, kind)) continue;
// 根据文件名确定实际 Kind（dotnet-hosting 嵌套在 aspnetcore-runtime 中，应记为 host）
var actualKind = name.StartsWith("dotnet-hosting-") ? "host" : kind;
// 解析 RID 为 OSKind + CpuArch
var (os, arch) = ParseRid(rid);
// dotnet-hosting-win.exe 的 rid 为空字符串，根据文件名推断为 Windows/Any
if (os == 0 && name.StartsWith("dotnet-hosting-"))
{
if (name.Contains("win", StringComparison.OrdinalIgnoreCase))
{
os = (Int32)OSKind.Windows;
arch = (Int32)CpuArch.Any;
}
}
if (os == 0) continue;
// Windows 上跳过 .zip（只保留 .exe 安装包）
if (os == (Int32)OSKind.Windows && name.EndsWithIgnoreCase(".zip")) continue;
// 查出所有匹配记录（allPkgs 是版本维度的快照，此处做 Kind+OS+Arch 维度的去重）
var matched = allPkgs.Where(e =>
e.Kind == actualKind &&
e.OSKind == (OSKind)os &&
e.Architecture == (CpuArch)arch).ToList();
if (matched.Count == 0)
{
// 无记录 → 新建
var pkg = new DotNetPackage
{
Version = version,
Kind = actualKind,
OSKind = (OSKind)os,
Architecture = (CpuArch)arch,
FileName = name,
Source = url,
FileHash = hash,
Enable = true,
Channel = NodeChannels.Release,
Force = false,
};
pkg.Insert();
allPkgs.Add(pkg);
}
else
{
// 同 (Version, Kind, OS, Arch) 有多条 → 保留最老一条（最小 ID），删其余重复
var keep = matched.OrderBy(e => e.Id).First();
foreach (var dup in matched)
{
if (dup == keep) continue;
dup.Delete();
allPkgs.Remove(dup);
}
// 手动上传的记录（Source 指向 Cube 附件）不被自动同步覆盖
if (!keep.Source.StartsWith("/cube/file"))
{
// 仅字段实际变化才更新，避免 XCode 拦截器触发无意义 UPDATE
if (keep.FileName != name || keep.Source != url || keep.FileHash != hash)
{
keep.FileName = name;
keep.Source = url;
keep.FileHash = hash;
keep.Update();
}
}
}
}
}
/// <summary>同步 SDK 安装包（单个 SDK 对象或 sdks 数组中的每个元素）</summary>
/// <param name="sdkObj">sdk 对象，含 version / files 字段</param>
/// <param name="sdkPkgs">当前大版本下所有 SDK 记录列表（避免循环内反复查库）</param>
private void SyncSdk(IDictionary<String, Object> sdkObj, IList<DotNetPackage> sdkPkgs)
{
if (sdkObj == null) return;
var sdkVersion = sdkObj["version"] + "";
if (sdkVersion.IsNullOrEmpty()) return;
var files = sdkObj["files"] as IList<Object>;
if (files == null) return;
foreach (var item in files)
{
var file = item as IDictionary<String, Object>;
if (file == null) continue;
var name = file["name"] + "";
var url = file["url"] + "";
var rid = file["rid"] + "";
var hash = file["hash"] + "";
if (name.IsNullOrEmpty() || url.IsNullOrEmpty()) continue;
// 优先从 URL 截取文件名
var idx = url.LastIndexOf('/');
if (idx >= 0 && idx < url.Length - 1)
{
var urlName = url.Substring(idx + 1);
if (!urlName.IsNullOrEmpty() && urlName.Contains('.'))
name = urlName;
}
// 过滤：仅保留 dotnet-sdk-* 安装包
if (!IsStandardRuntimeFile(name, "sdk")) continue;
// 解析 RID
var (os, arch) = ParseRid(rid);
if (os == 0) continue;
// Windows 上跳过 .zip（只保留 .exe 安装包）
if (os == (Int32)OSKind.Windows && name.EndsWithIgnoreCase(".zip")) continue;
// 按 SDK 版本号查已有 SDK 记录（SDK 版本号作 Version）
var matched = sdkPkgs.Where(e =>
e.Version == sdkVersion &&
e.Kind == "sdk" &&
e.OSKind == (OSKind)os &&
e.Architecture == (CpuArch)arch).ToList();
if (matched.Count == 0)
{
// 无记录 → 新建
var pkg = new DotNetPackage
{
Version = sdkVersion,
Kind = "sdk",
OSKind = (OSKind)os,
Architecture = (CpuArch)arch,
FileName = name,
Source = url,
FileHash = hash,
Enable = true,
Channel = NodeChannels.Release,
Force = false,
};
pkg.Insert();
sdkPkgs.Add(pkg);
}
else
{
// 同 (SDK Version, Kind, OS, Arch) 有多条 → 保留最老一条，删其余重复
var keep = matched.OrderBy(e => e.Id).First();
foreach (var dup in matched)
{
if (dup == keep) continue;
dup.Delete();
sdkPkgs.Remove(dup);
}
// 手动上传的记录不被自动同步覆盖
if (!keep.Source.StartsWith("/cube/file"))
{
// 仅字段实际变化才更新
if (keep.FileName != name || keep.Source != url || keep.FileHash != hash)
{
keep.FileName = name;
keep.Source = url;
keep.FileHash = hash;
keep.Update();
}
}
}
}
}
/// <summary>判断文件是否为标准运行时安装包（排除 composite/targeting-pack 等变体）</summary>
/// <remarks>
/// 注意：dotnet-hosting-win.exe 不在独立的 "dotnet-hosting" 顶级 key 中，
/// 而是作为最后一项出现在 "aspnetcore-runtime".files 数组内。
/// 因此处理 "aspnet" kind 时也需要识别 dotnet-hosting-* 前缀。
/// </remarks>
private static Boolean IsStandardRuntimeFile(String name, String kind)
{
return kind switch
{
// aspnetcore-runtime 下：标准运行时 + 嵌套的 dotnet-hosting（排除 composite/targeting）
"aspnet" => (name.StartsWith("aspnetcore-runtime-") &&
!name.Contains("composite") &&
!name.Contains("targeting")) ||
name.StartsWith("dotnet-hosting-"),
// runtime 下：dotnet-runtime-*（排除 dotnet-apphost-pack-*）
"runtime" => name.StartsWith("dotnet-runtime-"),
"desktop" => name.StartsWith("windowsdesktop-runtime-"),
"host" => name.StartsWith("dotnet-hosting-"),
"sdk" => name.StartsWith("dotnet-sdk-"),
_ => false,
};
}
/// <summary>解析RID为OSKind和CpuArch</summary>
private static (Int32 os, Int32 arch) ParseRid(String rid)
{
if (rid.IsNullOrEmpty()) return (0, 0);
var os = 0;
var arch = 0;
// OS 判断
if (rid.StartsWithIgnoreCase("win")) os = (Int32)OSKind.Windows;
else if (rid.StartsWithIgnoreCase("linux-musl")) os = (Int32)OSKind.LinuxMusl;
else if (rid.StartsWithIgnoreCase("linux")) os = (Int32)OSKind.Linux;
else if (rid.StartsWithIgnoreCase("osx")) os = (Int32)OSKind.OSX;
// Arch 判断
if (rid.EndsWithIgnoreCase("-x64")) arch = (Int32)CpuArch.X64;
else if (rid.EndsWithIgnoreCase("-x86")) arch = (Int32)CpuArch.X86;
else if (rid.EndsWithIgnoreCase("-arm64")) arch = (Int32)CpuArch.Arm64;
else if (rid.EndsWithIgnoreCase("-arm")) arch = (Int32)CpuArch.Arm;
return (os, arch);
}
}
|