first

2026-07-14 21:29:27 +08:00
commit f7ad7e20aa
1773 changed files with 514155 additions and 0 deletions
@@ -0,0 +1,149 @@
+using Common.AspNetCore.Extensions;
+using Common.Frame.Services.Cache.Interfaces;
+using Common.NETCore.Utility;
+using FASS.Scheduler.Models;
+using FASS.Scheduler.Services.CronTasks;
+using FASS.Scheduler.Services.EventBus;
+using FASS.Scheduler.Services.Extends;
+using FASS.Scheduler.Utility;
+using FASS.Service.Dtos.Setting;
+
+namespace FASS.Scheduler.Services
+{
+    public class AppHostService : IHostedService, IAsyncDisposable
+    {
+        private IHostApplicationLifetime Lifetime { get; }
+        private CancellationTokenSource? _startupTokenSource;
+        private Task? _startupTask;
+
+        public ILogger<AppHostService> Logger { get; }
+        public AppSettings AppSettings { get; }
+        public IServiceProvider ServiceProvider { get; }
+
+        public ExtendService ExtendService { get; private set; } = null!;
+        public EventBusService EventBusService { get; private set; } = null!;
+        public CronTaskService CronTaskService { get; private set; } = null!;
+
+        public AppHostService(
+            IHostApplicationLifetime lifetime,
+            ILogger<AppHostService> logger,
+            AppSettings appSettings,
+            IServiceProvider serviceProvider)
+        {
+            Lifetime = lifetime;
+            Logger = logger;
+            AppSettings = appSettings;
+            ServiceProvider = serviceProvider;
+
+            Lifetime.ApplicationStarted.Register(OnApplicationStarted);
+        }
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            Logger.LogInformation("服务启动中");
+            return Task.CompletedTask;
+        }
+
+        public async Task StopAsync(CancellationToken cancellationToken)
+        {
+            Logger.LogInformation("服务停止中");
+
+            var startupTokenSource = Interlocked.Exchange(ref _startupTokenSource, null);
+            startupTokenSource?.Cancel();
+            var startupTask = Interlocked.Exchange(ref _startupTask, null);
+            if (startupTask is not null)
+            {
+                try
+                {
+                    await startupTask.WaitAsync(cancellationToken);
+                }
+                catch (OperationCanceledException) when (startupTokenSource?.IsCancellationRequested == true || cancellationToken.IsCancellationRequested)
+                {
+                    Logger.LogInformation("服务启动流程已取消");
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogError(ex, "服务等待启动流程结束失败");
+                }
+            }
+            startupTokenSource?.Dispose();
+
+            var stopTasks = new List<Task>();
+            if (CronTaskService is not null)
+            {
+                stopTasks.Add(CronTaskService.StopAsync(cancellationToken));
+            }
+            if (EventBusService is not null)
+            {
+                stopTasks.Add(EventBusService.StopAsync(cancellationToken));
+            }
+            if (ExtendService is not null)
+            {
+                stopTasks.Add(ExtendService.StopAsync(cancellationToken));
+            }
+            await Task.WhenAll(stopTasks);
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            Logger.LogInformation("服务释放资源");
+        }
+
+        private void OnApplicationStarted()
+        {
+            if (_startupTask is not null)
+            {
+                return;
+            }
+
+            _startupTokenSource = new CancellationTokenSource();
+            _startupTask = RunStartupAsync(_startupTokenSource.Token);
+        }
+
+        private async Task RunStartupAsync(CancellationToken cancellationToken)
+        {
+            try
+            {
+                Logger.LogInformation("[{Name} V {Version}]", Session.AssemblyName.Name, Session.AssemblyName.Version);
+
+                if (AppSettings.Scheduler.StartupDueTime > 0)
+                {
+                    Logger.LogInformation("启动延迟：{Delay} 毫秒", AppSettings.Scheduler.StartupDueTime);
+                    await Task.Delay(AppSettings.Scheduler.StartupDueTime, cancellationToken);
+                }
+
+                Logger.LogInformation("--------初始化--------");
+
+                InitializeCache();
+                InitializeService();
+
+                Logger.LogInformation("--------启动--------");
+
+                await Task.WhenAll(
+                    ExtendService.StartAsync(cancellationToken),
+                    EventBusService.StartAsync(cancellationToken),
+                    CronTaskService.StartAsync(cancellationToken));
+            }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                Logger.LogInformation("--------取消--------");
+            }
+            catch (Exception ex)
+            {
+                Logger.LogCritical(ex, "错误");
+            }
+        }
+
+        public void InitializeCache()
+        {
+            ServiceProvider.GetScopeService<IDataService>().GetConfigToDto<ConfigServiceDto>(CacheKey.Setting.ConfigService);
+        }
+
+        public void InitializeService()
+        {
+            ExtendService = ServiceProvider.GetRequiredService<ExtendService>();
+            EventBusService = ServiceProvider.GetRequiredService<EventBusService>();
+            CronTaskService = ServiceProvider.GetRequiredService<CronTaskService>();
+        }
+    }
+}