From b492d9f86732a1bf702f8c5f61a16ffb933eb364 Mon Sep 17 00:00:00 2001 From: ShukeBta <272197458+ShukeBta@users.noreply.github.com> Date: Thu, 18 Jun 2026 01:39:39 +0800 Subject: [PATCH] Fix license sync and cloud scan scheduling --- internal/handler/license.go | 68 +++++++++++++++++----- internal/handler/license_test.go | 39 +++++++++++++ internal/service/scanner.go | 93 ++++++++++++++++++++++++++---- internal/service/scheduler.go | 24 ++++++-- internal/service/scheduler_test.go | 23 ++++++-- web/src/pages/SettingsPage.tsx | 4 +- 6 files changed, 215 insertions(+), 36 deletions(-) diff --git a/internal/handler/license.go b/internal/handler/license.go index 7dcd6ed..88d34c5 100644 --- a/internal/handler/license.go +++ b/internal/handler/license.go @@ -53,15 +53,16 @@ type licenseServerSignedResp struct { } type licenseServerStatusResp struct { - Valid bool `json:"valid"` - LicenseType *string `json:"license_type"` - ExpiryDate *string `json:"expiry_date"` - MaxDevices int `json:"max_devices"` - MaxUsers *int `json:"max_users"` - UnlimitedUsers bool `json:"unlimited_users"` - DaysRemaining *int `json:"days_remaining"` - DeviceName string `json:"device_name"` - IsActive bool `json:"is_active"` + Valid bool `json:"valid"` + LicenseType *string `json:"license_type"` + ExpiryDate *string `json:"expiry_date"` + MaxDevices int `json:"max_devices"` + MaxUsers *int `json:"max_users"` + UnlimitedUsers bool `json:"unlimited_users"` + DaysRemaining *int `json:"days_remaining"` + DeviceName string `json:"device_name"` + IsActive bool `json:"is_active"` + HeartbeatRequested bool `json:"heartbeat_requested"` } func licenseActivateHandler(svc *service.Container) gin.HandlerFunc { @@ -129,13 +130,16 @@ func licenseStatusHandler(svc *service.Container) gin.HandlerFunc { nextState := licenseStateFromSigned(signed, deviceID, deviceName) nextState.LicenseKey = state.LicenseKey state = nextState + if refreshed, ok, _, refreshErr := refreshLicenseServerStatus(c.Request.Context(), client, state, deviceID); refreshErr == nil && ok { + refreshed.LicenseKey = state.LicenseKey + state = refreshed + } _ = persistLicenseState(c.Request.Context(), svc, state) } else { - var upstream licenseServerStatusResp - if getErr := client.get(c.Request.Context(), "/api/v1/status/"+url.PathEscape(deviceID), &upstream); getErr == nil && upstream.Valid { - applyLicenseStatus(&state, upstream, deviceID) + if refreshed, ok, _, getErr := refreshLicenseServerStatus(c.Request.Context(), client, state, deviceID); getErr == nil && ok { + state = refreshed _ = persistLicenseState(c.Request.Context(), svc, state) - } else if getErr == nil && !upstream.Valid { + } else if getErr == nil { state.Valid = false _ = persistLicenseState(c.Request.Context(), svc, state) } @@ -210,9 +214,27 @@ func maybeSendLicenseHeartbeat(ctx context.Context, svc *service.Container, inte if err != nil { return state, false, nil } - if !licenseHeartbeatEligible(state) || !licenseHeartbeatDue(state, interval) { + if !licenseHeartbeatEligible(state) { return state, false, nil } + if !licenseHeartbeatDue(state, interval) { + client, clientErr := newLicenseClient(ctx, svc) + if clientErr != nil { + return state, false, nil + } + deviceID, idErr := ensureLicenseDeviceID(ctx, svc, state.DeviceID) + if idErr != nil { + return state, false, idErr + } + refreshed, ok, requested, refreshErr := refreshLicenseServerStatus(ctx, client, state, deviceID) + if refreshErr == nil && ok { + state = refreshed + _ = persistLicenseState(ctx, svc, state) + } + if !requested { + return state, false, nil + } + } next, err := sendLicenseHeartbeat(ctx, svc) if err != nil { return state, false, err @@ -264,12 +286,30 @@ func sendLicenseHeartbeat(ctx context.Context, svc *service.Container) (service. } state := licenseStateFromSigned(upstream, deviceID, deviceName) state.LicenseKey = oldState.LicenseKey + if refreshed, ok, _, refreshErr := refreshLicenseServerStatus(ctx, client, state, deviceID); refreshErr == nil && ok { + refreshed.LicenseKey = state.LicenseKey + state = refreshed + } if err := persistLicenseState(ctx, svc, state); err != nil { return service.LicenseActivationState{}, err } return state, nil } +func refreshLicenseServerStatus(ctx context.Context, client *licenseClient, state service.LicenseActivationState, deviceID string) (service.LicenseActivationState, bool, bool, error) { + var upstream licenseServerStatusResp + if err := client.get(ctx, "/api/v1/status/"+url.PathEscape(deviceID), &upstream); err != nil { + return state, false, false, err + } + if !upstream.Valid { + state.Valid = false + state.UpdatedAt = time.Now().Format(time.RFC3339) + return state, false, upstream.HeartbeatRequested, nil + } + applyLicenseStatus(&state, upstream, deviceID) + return state, true, upstream.HeartbeatRequested, nil +} + type licenseClient struct { baseURL string hmacSecret string diff --git a/internal/handler/license_test.go b/internal/handler/license_test.go index 27dfb46..8800cef 100644 --- a/internal/handler/license_test.go +++ b/internal/handler/license_test.go @@ -1,6 +1,8 @@ package handler import ( + "net/http" + "net/http/httptest" "testing" "time" @@ -79,6 +81,43 @@ func TestApplyLicenseStatusReflectsUnlimitedUsers(t *testing.T) { } } +func TestRefreshLicenseServerStatusReflectsEditedLimitAndHeartbeatRequest(t *testing.T) { + upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path != "/api/v1/status/device-1" { + t.Fatalf("unexpected path %s", r.URL.Path) + } + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{ + "valid": true, + "license_type": "subscription", + "max_devices": 5, + "max_users": 60, + "unlimited_users": false, + "device_name": "NAS", + "heartbeat_requested": true, + "is_active": true + }`)) + })) + defer upstream.Close() + + state := service.LicenseActivationState{Valid: true, UnlimitedUsers: true} + client := &licenseClient{baseURL: upstream.URL, httpClient: upstream.Client()} + + refreshed, ok, requested, err := refreshLicenseServerStatus(t.Context(), client, state, "device-1") + if err != nil { + t.Fatalf("refresh status: %v", err) + } + if !ok || !requested { + t.Fatalf("expected valid status with requested heartbeat, ok=%v requested=%v", ok, requested) + } + if refreshed.MaxUsers == nil || *refreshed.MaxUsers != 60 || refreshed.UnlimitedUsers { + t.Fatalf("edited user limit was not reflected: %+v", refreshed) + } + if refreshed.MaxDevices != 5 || refreshed.DeviceName != "NAS" { + t.Fatalf("server status fields were not applied: %+v", refreshed) + } +} + func TestLicenseHeartbeatPayloadIncludesStoredLicenseKey(t *testing.T) { payload := licenseHeartbeatPayload(service.LicenseActivationState{ LicenseKey: "MS-ABCD-EFGH-JKLM-NPQR", diff --git a/internal/service/scanner.go b/internal/service/scanner.go index 813d7f5..1988dd9 100644 --- a/internal/service/scanner.go +++ b/internal/service/scanner.go @@ -682,13 +682,19 @@ func (s *ScannerService) CancelCloudScan(libraryID string) bool { s.cloudScanMu.Lock() defer s.cloudScanMu.Unlock() entry := s.cloudScans[libraryID] - if entry == nil || entry.cancel == nil || (entry.status.State != "running" && entry.status.State != "canceling") { + if entry == nil || (entry.status.State != "running" && entry.status.State != "queued" && entry.status.State != "canceling") { return false } entry.status.State = "canceling" entry.status.Stage = "canceling" entry.status.UpdatedAt = time.Now() - entry.cancel() + if entry.cancel != nil { + entry.cancel() + } else { + entry.status.State = "canceled" + entry.status.Stage = "canceled" + entry.status.FinishedAt = time.Now() + } return true } @@ -700,13 +706,19 @@ func (s *ScannerService) CancelAllCloudScans() int { defer s.cloudScanMu.Unlock() cancelled := 0 for _, entry := range s.cloudScans { - if entry == nil || entry.cancel == nil || (entry.status.State != "running" && entry.status.State != "canceling") { + if entry == nil || (entry.status.State != "running" && entry.status.State != "queued" && entry.status.State != "canceling") { continue } entry.status.State = "canceling" entry.status.Stage = "canceling" entry.status.UpdatedAt = time.Now() - entry.cancel() + if entry.cancel != nil { + entry.cancel() + } else { + entry.status.State = "canceled" + entry.status.Stage = "canceled" + entry.status.FinishedAt = time.Now() + } cancelled++ } return cancelled @@ -724,13 +736,19 @@ func (s *ScannerService) CancelCloudScansForProvider(provider string) int { defer s.cloudScanMu.Unlock() cancelled := 0 for _, entry := range s.cloudScans { - if entry == nil || entry.status.Provider != provider || entry.cancel == nil || (entry.status.State != "running" && entry.status.State != "canceling") { + if entry == nil || entry.status.Provider != provider || (entry.status.State != "running" && entry.status.State != "queued" && entry.status.State != "canceling") { continue } entry.status.State = "canceling" entry.status.Stage = "canceling" entry.status.UpdatedAt = time.Now() - entry.cancel() + if entry.cancel != nil { + entry.cancel() + } else { + entry.status.State = "canceled" + entry.status.Stage = "canceled" + entry.status.FinishedAt = time.Now() + } cancelled++ } return cancelled @@ -816,22 +834,77 @@ func (s *ScannerService) StartAllCloudLibraryScans() ([]CloudScanStatus, error) } libs = FilterScannableCloudLibraries(context.Background(), s.repo, libs) statuses := make([]CloudScanStatus, 0, len(libs)) + queue := make([]string, 0, len(libs)) for _, lib := range libs { if !lib.Enabled { continue } - if _, ok := ParseCloudLibraryMount(lib.Path); !ok { + mount, ok := ParseCloudLibraryMount(lib.Path) + if !ok { continue } - status, _, err := s.StartCloudLibraryScan(lib.ID, false) - if err != nil { - status = CloudScanStatus{LibraryID: lib.ID, State: "error", Error: err.Error(), UpdatedAt: time.Now()} + status, queued := s.queueCloudLibraryScan(lib, mount) + if queued { + queue = append(queue, lib.ID) } statuses = append(statuses, status) } + if len(queue) > 0 { + go s.runQueuedCloudLibraryScans(queue) + } return statuses, nil } +func (s *ScannerService) queueCloudLibraryScan(lib model.Library, mount CloudMountInfo) (CloudScanStatus, bool) { + now := time.Now() + status := CloudScanStatus{ + LibraryID: lib.ID, + Provider: mount.Provider, + Stage: "queued", + State: "queued", + StartedAt: now, + UpdatedAt: now, + ResumeHint: "中断后再次点击扫描会从头遍历，但已入库媒体会去重更新，只补齐缺失项。", + Estimate: "小目录通常几十秒；几万文件的大目录可能需要数分钟到数小时，取决于网盘接口速度。", + } + s.cloudScanMu.Lock() + defer s.cloudScanMu.Unlock() + if s.cloudScans == nil { + s.cloudScans = make(map[string]*cloudScanEntry) + } + if entry := s.cloudScans[lib.ID]; entry != nil { + switch entry.status.State { + case "running", "queued", "canceling": + return entry.status, false + } + } + s.cloudScans[lib.ID] = &cloudScanEntry{status: status} + return status, true +} + +func (s *ScannerService) runQueuedCloudLibraryScans(libraryIDs []string) { + ctx, cancel := cloudScanContext(context.Background(), cloudScanTimeout(context.Background(), s.repo, 24*time.Hour)) + defer cancel() + for _, libraryID := range libraryIDs { + if ctx.Err() != nil { + return + } + if s.cloudScanWasCanceled(libraryID) { + continue + } + if _, err := s.ScanLibraryWithoutAutoScrape(ctx, libraryID); err != nil && !errors.Is(err, ErrCloudScanAlreadyRunning) && !errors.Is(err, context.Canceled) && s.log != nil { + s.log.Warn("cloud library queued scan failed", zap.String("library_id", libraryID), zap.Error(err)) + } + } +} + +func (s *ScannerService) cloudScanWasCanceled(libraryID string) bool { + s.cloudScanMu.Lock() + defer s.cloudScanMu.Unlock() + entry := s.cloudScans[libraryID] + return entry != nil && entry.status.State == "canceled" +} + // ScanLibrary walks the library root and persists discovered media files. func (s *ScannerService) ScanLibrary(ctx context.Context, libraryID string) (*ScanResult, error) { return s.scanLibrary(ctx, libraryID, true) diff --git a/internal/service/scheduler.go b/internal/service/scheduler.go index cae69a0..7f7b2c3 100644 --- a/internal/service/scheduler.go +++ b/internal/service/scheduler.go @@ -87,8 +87,8 @@ const ( cloudAutoSyncEnabledKey = "cloud.auto_sync_enabled" cloudSyncIntervalSecondsKey = "cloud.sync_interval_seconds" cloudLastAutoSyncDateKey = "cloud.last_auto_sync_date" - cloudAutoSyncWindowStartHour = 19 - cloudAutoSyncWindowEndHour = 21 + cloudAutoSyncWindowStartHour = 23 + cloudAutoSyncWindowEndHour = 5 cloudAutoSyncCompletedDateForm = "2006-01-02" ) @@ -498,19 +498,33 @@ func (s *SchedulerService) autoCloudSyncDue(ctx context.Context, now time.Time) if err != nil { return true } - return strings.TrimSpace(last) != now.Format(cloudAutoSyncCompletedDateForm) + return strings.TrimSpace(last) != cloudAutoSyncWindowDate(now) } func cloudAutoSyncInWindow(now time.Time) bool { hour := now.In(time.Local).Hour() - return hour >= cloudAutoSyncWindowStartHour && hour < cloudAutoSyncWindowEndHour + if cloudAutoSyncWindowStartHour == cloudAutoSyncWindowEndHour { + return true + } + if cloudAutoSyncWindowStartHour < cloudAutoSyncWindowEndHour { + return hour >= cloudAutoSyncWindowStartHour && hour < cloudAutoSyncWindowEndHour + } + return hour >= cloudAutoSyncWindowStartHour || hour < cloudAutoSyncWindowEndHour +} + +func cloudAutoSyncWindowDate(now time.Time) string { + local := now.In(time.Local) + if cloudAutoSyncWindowStartHour > cloudAutoSyncWindowEndHour && local.Hour() < cloudAutoSyncWindowEndHour { + local = local.AddDate(0, 0, -1) + } + return local.Format(cloudAutoSyncCompletedDateForm) } func (s *SchedulerService) markCloudAutoSyncCompleted(ctx context.Context, now time.Time) error { if s.repo == nil || s.repo.Setting == nil { return nil } - return s.repo.Setting.Set(ctx, cloudLastAutoSyncDateKey, now.Format(cloudAutoSyncCompletedDateForm)) + return s.repo.Setting.Set(ctx, cloudLastAutoSyncDateKey, cloudAutoSyncWindowDate(now)) } func (s *SchedulerService) cloudSyncInterval(ctx context.Context) time.Duration { diff --git a/internal/service/scheduler_test.go b/internal/service/scheduler_test.go index 7649aed..3e4c395 100644 --- a/internal/service/scheduler_test.go +++ b/internal/service/scheduler_test.go @@ -332,7 +332,7 @@ func TestSchedulerCloudSyncRunsOnlyOnceInsideNightlyWindow(t *testing.T) { scheduler := NewSchedulerService(log, repos, scanner, nil, nil, storage, NewHub(log), "") scheduler.now = func() time.Time { - return time.Date(2026, 6, 11, 18, 30, 0, 0, time.Local) + return time.Date(2026, 6, 11, 22, 30, 0, 0, time.Local) } if err := scheduler.jobSyncCloudLibraries(t.Context()); err != nil { t.Fatalf("cloud sync outside window: %v", err) @@ -353,13 +353,26 @@ func TestSchedulerCloudSyncRunsOnlyOnceInsideNightlyWindow(t *testing.T) { } scheduler.now = func() time.Time { - return time.Date(2026, 6, 11, 20, 15, 0, 0, time.Local) + return time.Date(2026, 6, 12, 4, 15, 0, 0, time.Local) + } + if !cloudAutoSyncInWindow(scheduler.now()) { + t.Fatalf("04:15 should still be inside overnight cloud sync window") + } + if got := cloudAutoSyncWindowDate(scheduler.now()); got != "2026-06-11" { + t.Fatalf("04:15 should belong to previous nightly window, got %s", got) } if err := scheduler.jobSyncCloudLibraries(t.Context()); err != nil { - t.Fatalf("second cloud sync same day: %v", err) + t.Fatalf("second cloud sync same overnight window: %v", err) } if got := requests.Load(); got != 1 { - t.Fatalf("same-day auto sync should not rerun, requests = %d", got) + t.Fatalf("same overnight auto sync should not rerun, requests = %d", got) + } + + scheduler.now = func() time.Time { + return time.Date(2026, 6, 12, 5, 0, 0, 0, time.Local) + } + if cloudAutoSyncInWindow(scheduler.now()) { + t.Fatalf("05:00 should be outside overnight cloud sync window") } } @@ -465,7 +478,7 @@ func TestSchedulerCloudSyncDisabledByDefault(t *testing.T) { } func fixedNightlySyncTime() time.Time { - return time.Date(2026, 6, 11, 19, 30, 0, 0, time.Local) + return time.Date(2026, 6, 11, 23, 30, 0, 0, time.Local) } func TestSchedulerLoopWaitsIntervalAfterSlowRun(t *testing.T) { diff --git a/web/src/pages/SettingsPage.tsx b/web/src/pages/SettingsPage.tsx index da4a790..711e83e 100644 --- a/web/src/pages/SettingsPage.tsx +++ b/web/src/pages/SettingsPage.tsx @@ -165,14 +165,14 @@ const GROUPS: SettingGroup[] = [ key: 'cloud.auto_sync_enabled', label: '夜间自动同步网盘媒体库', type: 'toggle', - hint: '默认关闭。开启后仅在每天 19:00-21:00 自动补齐缺失媒体并扫描新增；手动扫描仍可随时执行。', + hint: '默认关闭。开启后仅在每天 23:00-05:00 按检查间隔触发；每次完整扫描所有启用网盘库一次后自动停止。手动扫描仍可随时执行。', defaultValue: 'false', }, { key: 'cloud.sync_interval_seconds', label: '夜间窗口检查间隔秒数', type: 'number', - hint: '最小 300 秒，建议 1800 秒；同一天成功同步后不会重复全量扫，避免大型网盘反复递归。', + hint: '最小 300 秒，建议 1800 秒；同一个夜间窗口成功同步后不会重复全量扫，避免大型网盘反复递归。', defaultValue: '1800', }, {