Update Context for store

internal/domain/proxy/manager.go

@@ -2,14 +2,13 @@
 package proxy
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"gemini-balancer/internal/models"
 	"gemini-balancer/internal/store"
 	"gemini-balancer/internal/syncer"
 	"gemini-balancer/internal/task"
-
-	"context"
 	"net"
 	"net/http"
 	"net/url"
@@ -25,7 +24,7 @@ import (
 
 const (
 	TaskTypeProxySync = "proxy_sync"
-	proxyChunkSize    = 200 // 代理同步的批量大小
+	proxyChunkSize    = 200
 )
 
 type ProxyCheckResult struct {
@@ -35,13 +34,11 @@ type ProxyCheckResult struct {
 	ErrorMessage string  `json:"error_message"`
 }
 
-// managerCacheData
 type managerCacheData struct {
 	ActiveProxies []*models.ProxyConfig
 	ProxiesByID   map[uint]*models.ProxyConfig
 }
 
-// manager结构体
 type manager struct {
 	db     *gorm.DB
 	syncer *syncer.CacheSyncer[managerCacheData]
@@ -80,21 +77,21 @@ func newManager(db *gorm.DB, syncer *syncer.CacheSyncer[managerCacheData], taskR
 	}
 }
 
-func (m *manager) SyncProxiesInBackground(proxyStrings []string) (*task.Status, error) {
+func (m *manager) SyncProxiesInBackground(ctx context.Context, proxyStrings []string) (*task.Status, error) {
 	resourceID := "global_proxy_sync"
-	taskStatus, err := m.task.StartTask(0, TaskTypeProxySync, resourceID, len(proxyStrings), 0)
+	taskStatus, err := m.task.StartTask(ctx, 0, TaskTypeProxySync, resourceID, len(proxyStrings), 0)
 	if err != nil {
 		return nil, ErrTaskConflict
 	}
-	go m.runProxySyncTask(taskStatus.ID, proxyStrings)
+	go m.runProxySyncTask(context.Background(), taskStatus.ID, proxyStrings)
 	return taskStatus, nil
 }
 
-func (m *manager) runProxySyncTask(taskID string, finalProxyStrings []string) {
+func (m *manager) runProxySyncTask(ctx context.Context, taskID string, finalProxyStrings []string) {
 	resourceID := "global_proxy_sync"
 	var allProxies []models.ProxyConfig
 	if err := m.db.Find(&allProxies).Error; err != nil {
-		m.task.EndTaskByID(taskID, resourceID, nil, fmt.Errorf("failed to fetch current proxies: %w", err))
+		m.task.EndTaskByID(ctx, taskID, resourceID, nil, fmt.Errorf("failed to fetch current proxies: %w", err))
 		return
 	}
 	currentProxyMap := make(map[string]uint)
@@ -125,19 +122,19 @@ func (m *manager) runProxySyncTask(taskID string, finalProxyStrings []string) {
 	}
 	if len(idsToDelete) > 0 {
 		if err := m.bulkDeleteByIDs(idsToDelete); err != nil {
-			m.task.EndTaskByID(taskID, resourceID, nil, fmt.Errorf("failed during proxy deletion: %w", err))
+			m.task.EndTaskByID(ctx, taskID, resourceID, nil, fmt.Errorf("failed during proxy deletion: %w", err))
 			return
 		}
 	}
 	if len(proxiesToAdd) > 0 {
 		if err := m.bulkAdd(proxiesToAdd); err != nil {
-			m.task.EndTaskByID(taskID, resourceID, nil, fmt.Errorf("failed during proxy addition: %w", err))
+			m.task.EndTaskByID(ctx, taskID, resourceID, nil, fmt.Errorf("failed during proxy addition: %w", err))
 			return
 		}
 	}
 	result := gin.H{"added": len(proxiesToAdd), "deleted": len(idsToDelete), "final_total": len(finalProxyMap)}
-	m.task.EndTaskByID(taskID, resourceID, result, nil)
-	m.publishChangeEvent("proxies_synced")
+	m.task.EndTaskByID(ctx, taskID, resourceID, result, nil)
+	m.publishChangeEvent(ctx, "proxies_synced")
 	go m.invalidate()
 }
 
@@ -184,14 +181,15 @@ func (m *manager) bulkDeleteByIDs(ids []uint) error {
 	}
 	return nil
 }
+
 func (m *manager) bulkAdd(proxies []models.ProxyConfig) error {
 	return m.db.CreateInBatches(proxies, proxyChunkSize).Error
 }
 
-func (m *manager) publishChangeEvent(reason string) {
+func (m *manager) publishChangeEvent(ctx context.Context, reason string) {
 	event := models.ProxyStatusChangedEvent{Action: reason}
 	eventData, _ := json.Marshal(event)
-	_ = m.store.Publish(models.TopicProxyStatusChanged, eventData)
+	_ = m.store.Publish(ctx, models.TopicProxyStatusChanged, eventData)
 }
 
 func (m *manager) assignProxyIfNeeded(apiKey *models.APIKey) (*models.ProxyConfig, error) {