From 79b503d1a62f306bf8120846113ac58af7f32e5d Mon Sep 17 00:00:00 2001 From: yml Date: Fri, 20 Nov 2026 13:37:00 +0800 Subject: [PATCH] =?UTF-8?q?fix(seckill):=20=E4=BB=A3=E7=90=86=E5=A4=B1?= =?UTF-8?q?=E8=B4=A5=E6=97=B6=E5=BF=AB=E9=80=9F=E5=9B=9E=E9=80=80=E7=9B=B4?= =?UTF-8?q?=E8=BF=9E=EF=BC=8C=E5=8F=91=E5=B8=83=200.5.3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/constants/constants.go | 2 +- internal/seckill/proxy_groups.go | 139 ++++++++++++++++++++++---- internal/seckill/proxy_groups_test.go | 65 ++++++++++++ internal/seckill/scheduler.go | 35 +++++++ wails.json | 4 +- 5 files changed, 224 insertions(+), 21 deletions(-) diff --git a/internal/constants/constants.go b/internal/constants/constants.go index 0c70e25..f5c380d 100644 --- a/internal/constants/constants.go +++ b/internal/constants/constants.go @@ -3,7 +3,7 @@ package constants import "time" // Version 应用版本号,与 wails.json version 同步。 -const Version = "0.5.2" +const Version = "0.5.3" // BuildTime 构建时间,由编译时 ldflags 注入。 var BuildTime = "unknown" diff --git a/internal/seckill/proxy_groups.go b/internal/seckill/proxy_groups.go index 53f1eb4..ea48e37 100644 --- a/internal/seckill/proxy_groups.go +++ b/internal/seckill/proxy_groups.go @@ -26,6 +26,9 @@ const ( proxyValidationTimeout = 3 * time.Second proxyValidationWorkers = 3 proxyValidateAttempts = 1 + proxyImmediateTimeout = 5 * time.Second + proxyScheduledTimeout = 20 * time.Second + proxyRefillTimeout = 20 * time.Second ) type proxySettingsSnapshot struct { @@ -131,6 +134,7 @@ func (s *Scheduler) UpdateProxySettings(cfg types.Config) { } s.clientMu.Lock() s.accountClientsDirty = true + s.proxyFallbackActive = false s.clientMu.Unlock() } @@ -182,6 +186,7 @@ func (s *Scheduler) closeAccountClients() { s.proxyStandbyTarget = 0 s.proxyPoolGeneration++ s.proxyRefillInFlight = false + s.proxyFallbackActive = false s.clientMu.Unlock() closeDouyuClientList(oldClients) } @@ -212,6 +217,7 @@ func (s *Scheduler) replaceAccountClients(pool preparedProxyPool) { s.proxyStandbyTarget = pool.standbyTarget s.proxyPoolGeneration++ s.proxyRefillInFlight = false + s.proxyFallbackActive = false s.clientMu.Unlock() closeDouyuClientList(oldClients) } @@ -272,6 +278,9 @@ func (s *Scheduler) accountClientsCover(accountNames []string) bool { func (s *Scheduler) calibrationClient() *client.DouyuClient { s.clientMu.RLock() defer s.clientMu.RUnlock() + if s.proxyFallbackActive && s.directClient != nil { + return s.directClient + } if len(s.accountClientOrder) > 0 && s.accountClientOrder[0] != nil { return s.accountClientOrder[0] } @@ -287,6 +296,12 @@ func (s *Scheduler) allClients() []*client.DouyuClient { seen[s.client] = struct{}{} out = append(out, s.client) } + if (s.proxyFallbackActive || s.client == nil) && s.directClient != nil { + if _, ok := seen[s.directClient]; !ok { + seen[s.directClient] = struct{}{} + out = append(out, s.directClient) + } + } for _, cli := range s.accountClientOrder { if cli == nil { continue @@ -315,6 +330,10 @@ func (s *Scheduler) prepareProxyGroups(accountProducts map[string]string, forceR s.closeAccountClients() return nil } + if !forceRefresh && s.proxyFallbackSnapshot() { + logger.LogEvent("代理", "warn", "代理此前准备失败,本次抢购直接使用直连,避免再次等待") + return nil + } if !forceRefresh && s.accountClientsCover(names) { return nil } @@ -324,16 +343,23 @@ func (s *Scheduler) prepareProxyGroups(accountProducts map[string]string, forceR standbyTarget := proxyStandbyCount(activeCount, cfg.sparePercent) base := s.clientSnapshot() if base == nil { - return errors.New("基础客户端未初始化") + s.activateProxyDirectFallback(errors.New("基础客户端未初始化")) + return nil } poolStartedAt := time.Now() - proxies, err := s.buildProxyPool(base, cfg, activeCount, activeCount+standbyTarget, nil) + timeout := proxyImmediateTimeout + if forceRefresh { + timeout = proxyScheduledTimeout + } + proxies, err := s.buildProxyPool(base, cfg, activeCount, activeCount+standbyTarget, nil, timeout) if err != nil { - return err + s.activateProxyDirectFallback(err) + return nil } if len(proxies) < activeCount { - return fmt.Errorf("代理数量不足: 需要%d个活动代理,实际%d个", activeCount, len(proxies)) + s.activateProxyDirectFallback(fmt.Errorf("代理数量不足: 需要%d个活动代理,实际%d个", activeCount, len(proxies))) + return nil } if len(proxies) < activeCount+standbyTarget { logger.LogEvent("代理", "warn", "备用代理不足: 目标%d个,实际%d个;活动代理不受影响", @@ -395,6 +421,25 @@ func (s *Scheduler) prepareProxyGroups(accountProducts map[string]string, forceR return nil } +func (s *Scheduler) proxyFallbackSnapshot() bool { + s.clientMu.RLock() + defer s.clientMu.RUnlock() + return s.proxyFallbackActive +} + +func (s *Scheduler) activateProxyDirectFallback(cause error) { + s.closeAccountClients() + s.clientMu.Lock() + active := s.directClient != nil + s.proxyFallbackActive = active + s.clientMu.Unlock() + if active { + logger.LogEvent("代理", "warn", "代理准备失败,已回退直连以保证抢购继续: %v", cause) + return + } + logger.LogEvent("代理", "error", "代理准备失败且直连客户端不可用: %v", cause) +} + func effectiveProxyStandbyTarget(cfg proxySettingsSnapshot, target, actual int) int { if cfg.proxyAPI == "" { return actual @@ -455,15 +500,16 @@ func proxyStandbyCount(activeCount, sparePercent int) int { return count } -func (s *Scheduler) buildProxyPool(base *client.DouyuClient, cfg proxySettingsSnapshot, required, desired int, excludedURLs map[string]struct{}) ([]validatedProxy, error) { +func (s *Scheduler) buildProxyPool(base *client.DouyuClient, cfg proxySettingsSnapshot, required, desired int, excludedURLs map[string]struct{}, timeout time.Duration) ([]validatedProxy, error) { if desired < required { desired = required } if required <= 0 { return nil, nil } + deadline := time.Now().Add(timeout) if cfg.proxyAPI != "" { - proxies, err := s.fetchAndValidateProxyPool(base, cfg, desired, excludedURLs) + proxies, err := s.fetchAndValidateProxyPool(base, cfg, desired, excludedURLs, timeout) if len(proxies) >= required { if len(proxies) < desired { logger.LogEvent("代理", "warn", "动态代理备用数量不足: 目标%d个,实际%d个", desired, len(proxies)) @@ -490,7 +536,11 @@ func (s *Scheduler) buildProxyPool(base *client.DouyuClient, cfg proxySettingsSn } templates := make([]validatedProxy, 0, validateCount) for _, rawURL := range staticURLs[:validateCount] { - proxy, err := s.validateProxy(base, rawURL, "静态") + if time.Now().After(deadline) { + closeValidatedProxies(templates) + return nil, errors.New("静态代理校验超时") + } + proxy, err := s.validateProxy(base, rawURL, "静态", time.Until(deadline)) if err != nil { closeValidatedProxies(templates) return nil, fmt.Errorf("静态代理不可用: %w", err) @@ -570,7 +620,7 @@ func splitProxyURLs(raw string) []string { return out } -func (s *Scheduler) fetchAndValidateProxyPool(base *client.DouyuClient, cfg proxySettingsSnapshot, count int, excludedURLs map[string]struct{}) ([]validatedProxy, error) { +func (s *Scheduler) fetchAndValidateProxyPool(base *client.DouyuClient, cfg proxySettingsSnapshot, count int, excludedURLs map[string]struct{}, timeout time.Duration) ([]validatedProxy, error) { service := s.proxyService if service == nil { service = proxyprovider.NewService() @@ -583,6 +633,7 @@ func (s *Scheduler) fetchAndValidateProxyPool(base *client.DouyuClient, cfg prox seen[rawURL] = struct{}{} } var lastErr error + deadline := time.Now().Add(timeout) rounds := proxyFetchRounds if count > rounds { @@ -592,12 +643,23 @@ func (s *Scheduler) fetchAndValidateProxyPool(base *client.DouyuClient, cfg prox rounds = proxyFetchMaxRounds } for round := 0; round < rounds; round++ { + remaining := time.Until(deadline) + if remaining <= 0 { + if lastErr == nil { + lastErr = errors.New("代理准备总时长超时") + } + break + } need := count - len(proxies) if need <= 0 { break } - ctx, cancel := context.WithTimeout(context.Background(), proxyRequestTimeout) + requestTimeout := proxyRequestTimeout + if remaining < requestTimeout { + requestTimeout = remaining + } + ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) endpoints, err := service.ExtractWithWhitelist(ctx, cfg.proxyAPI, need, proxyprovider.WhitelistConfig{ APIURL: cfg.proxyAPI, LoginPassword: cfg.whitelistPassword, @@ -612,7 +674,7 @@ func (s *Scheduler) fetchAndValidateProxyPool(base *client.DouyuClient, cfg prox break } } else { - validated := s.validateProxyBatch(base, endpoints) + validated := s.validateProxyBatch(base, endpoints, deadline) for _, item := range validated { if item.err != nil { lastErr = item.err @@ -641,7 +703,13 @@ func (s *Scheduler) fetchAndValidateProxyPool(base *client.DouyuClient, cfg prox } if round < rounds-1 { - time.Sleep(proxyFetchRetryWait) + wait := proxyFetchRetryWait + if remaining := time.Until(deadline); remaining < wait { + wait = remaining + } + if wait > 0 { + time.Sleep(wait) + } } } @@ -685,6 +753,10 @@ func (s *Scheduler) recordProxyResult(proxyClient *client.DouyuClient, err error } event, expiredClients, switched := s.switchGroupToStandbyLocked(proxyClient, group) + if !switched && s.directClient != nil { + event = s.switchGroupToDirectLocked(proxyClient, group) + switched = true + } needRefill := false failedAccounts := 0 failedURL := "" @@ -743,6 +815,22 @@ func (s *Scheduler) switchGroupToStandbyLocked(oldClient *client.DouyuClient, gr return proxySwitchEvent{}, expiredClients, false } +func (s *Scheduler) switchGroupToDirectLocked(oldClient *client.DouyuClient, group *proxyRuntimeGroup) proxySwitchEvent { + event := proxySwitchEvent{ + accountNames: append([]string(nil), group.accountNames...), + fromURL: group.activeURL, + } + group.activeURL = "" + group.consecutiveFailures = 0 + group.failed = false + for _, accountName := range group.accountNames { + s.accountClients[accountName] = s.directClient + } + delete(s.proxyGroups, oldClient) + replaceClientInOrder(s.accountClientOrder, oldClient, s.directClient) + return event +} + func replaceClientInOrder(order []*client.DouyuClient, oldClient, newClient *client.DouyuClient) { for i, cli := range order { if cli == oldClient { @@ -777,7 +865,7 @@ func (s *Scheduler) startProxyRefill() { } func (s *Scheduler) refillProxyStandbys(base *client.DouyuClient, cfg proxySettingsSnapshot, generation uint64, need int, excludedURLs map[string]struct{}) { - proxies, err := s.fetchAndValidateProxyPool(base, cfg, need, excludedURLs) + proxies, err := s.fetchAndValidateProxyPool(base, cfg, need, excludedURLs, proxyRefillTimeout) if err != nil { logger.LogEvent("代理", "warn", "备用代理补提取未完全成功: %v", err) } @@ -877,10 +965,17 @@ func copyStringSet(source map[string]struct{}) map[string]struct{} { func logProxySwitch(label string, event proxySwitchEvent) { logger.LogEvent("代理", "warn", "%s: 账号=%d %s -> %s IP=%s 归属=%s RTT=%s 来源=%s", - label, len(event.accountNames), client.MaskProxyURL(event.fromURL), client.MaskProxyURL(event.toURL), + label, len(event.accountNames), proxyDisplay(event.fromURL), proxyDisplay(event.toURL), event.toIP, event.toRegion, event.toRTT.Round(time.Millisecond), event.toSource) } +func proxyDisplay(raw string) string { + if strings.TrimSpace(raw) == "" { + return "直连" + } + return client.MaskProxyURL(raw) +} + func proxyPoolExpiresAt(apiURL string, now time.Time) time.Time { minutes := 10 if u, err := url.Parse(strings.TrimSpace(apiURL)); err == nil { @@ -896,13 +991,16 @@ func proxyPoolExpiresAt(apiURL string, now time.Time) time.Time { return now.Add(time.Duration(minutes) * time.Minute) } -func (s *Scheduler) validateProxy(base *client.DouyuClient, proxyURL, source string) (validatedProxy, error) { +func (s *Scheduler) validateProxy(base *client.DouyuClient, proxyURL, source string, timeout time.Duration) (validatedProxy, error) { cli, err := client.NewWithProxy(base.Activity, base.TimeAPIURL, base.Trace, proxyURL) if err != nil { return validatedProxy{}, err } - if cli.HTTPClient != nil && cli.HTTPClient.Timeout > proxyValidationTimeout { - cli.HTTPClient.Timeout = proxyValidationTimeout + if timeout <= 0 || timeout > proxyValidationTimeout { + timeout = proxyValidationTimeout + } + if cli.HTTPClient != nil { + cli.HTTPClient.Timeout = timeout } var lastErr error for attempt := 0; attempt < proxyValidateAttempts; attempt++ { @@ -929,7 +1027,7 @@ type proxyValidationResult struct { err error } -func (s *Scheduler) validateProxyBatch(base *client.DouyuClient, endpoints []proxyprovider.Endpoint) []proxyValidationResult { +func (s *Scheduler) validateProxyBatch(base *client.DouyuClient, endpoints []proxyprovider.Endpoint, deadline time.Time) []proxyValidationResult { if len(endpoints) == 0 { return nil } @@ -945,7 +1043,12 @@ func (s *Scheduler) validateProxyBatch(base *client.DouyuClient, endpoints []pro go func() { defer wg.Done() for endpoint := range jobs { - proxy, err := s.validateProxy(base, endpoint.URL, "API/"+endpoint.Provider) + remaining := time.Until(deadline) + if remaining <= 0 { + results <- proxyValidationResult{endpoint: endpoint, err: errors.New("代理校验总时长超时")} + continue + } + proxy, err := s.validateProxy(base, endpoint.URL, "API/"+endpoint.Provider, remaining) results <- proxyValidationResult{endpoint: endpoint, proxy: proxy, err: err} } }() diff --git a/internal/seckill/proxy_groups_test.go b/internal/seckill/proxy_groups_test.go index 008c005..e565da4 100644 --- a/internal/seckill/proxy_groups_test.go +++ b/internal/seckill/proxy_groups_test.go @@ -153,6 +153,71 @@ func TestPrepareProxyGroupsRoutesAccountsToDistinctClients(t *testing.T) { } } +func TestPrepareProxyGroupsFallsBackDirectAndSkipsRepeatedWait(t *testing.T) { + var requests int32 + apiServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + atomic.AddInt32(&requests, 1) + w.Header().Set("Content-Type", "application/json") + fmt.Fprint(w, `{"code":-1,"status":200,"message":"secret密匙错误"}`) + })) + defer apiServer.Close() + + act := *activity.Get("peace") + base := client.New(&act, "http://douyu.test/time", &trace.Recorder{}, "http://127.0.0.1:1") + scheduler := New(base, types.AppPaths{}, nil, 8, 1, nil, types.SeckillModeAggressive) + scheduler.UpdateProxySettings(types.Config{ + ProxyEnabled: true, + ProxyAPI: apiServer.URL, + AccountsPerProxy: 5, + ProxySparePercent: 25, + }) + accountProducts := map[string]string{"a": "goods-1"} + + if err := scheduler.prepareProxyGroups(accountProducts, false); err != nil { + t.Fatalf("prepareProxyGroups() error = %v", err) + } + if !scheduler.proxyFallbackSnapshot() { + t.Fatal("代理失败后应启用直连回退") + } + if scheduler.clientForAccount("a") != scheduler.directClient { + t.Fatal("代理失败后账号应路由到真正的直连客户端") + } + firstRequests := atomic.LoadInt32(&requests) + if firstRequests == 0 { + t.Fatal("首次代理准备应尝试提取") + } + if err := scheduler.prepareProxyGroups(accountProducts, false); err != nil { + t.Fatalf("second prepareProxyGroups() error = %v", err) + } + if got := atomic.LoadInt32(&requests); got != firstRequests { + t.Fatalf("直连回退后不应重复等待提取,requests=%d want %d", got, firstRequests) + } +} + +func TestProxyGroupSwitchesDirectWhenStandbyUnavailable(t *testing.T) { + act := *activity.Get("peace") + base := client.New(&act, "http://douyu.test/time", &trace.Recorder{}, "") + scheduler := New(base, types.AppPaths{}, nil, 8, 1, nil, types.SeckillModeAggressive) + groupClient := &client.DouyuClient{} + group := &proxyRuntimeGroup{ + accountNames: []string{"a"}, + activeURL: "http://user:pass@127.0.0.1:9000", + } + scheduler.replaceAccountClients(preparedProxyPool{ + accountClients: map[string]*client.DouyuClient{"a": groupClient}, + activeClients: []*client.DouyuClient{groupClient}, + groups: map[*client.DouyuClient]*proxyRuntimeGroup{groupClient: group}, + allClients: []*client.DouyuClient{groupClient}, + }) + + proxyErr := errors.New("read tcp: connection reset by peer") + scheduler.recordProxyResult(groupClient, proxyErr) + scheduler.recordProxyResult(groupClient, proxyErr) + if scheduler.clientForAccount("a") != scheduler.directClient { + t.Fatal("备用代理为空时,故障组应立即切换到直连") + } +} + func newTimeProxyServer(t *testing.T) *httptest.Server { t.Helper() server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { diff --git a/internal/seckill/scheduler.go b/internal/seckill/scheduler.go index 185031a..8d2d311 100644 --- a/internal/seckill/scheduler.go +++ b/internal/seckill/scheduler.go @@ -61,6 +61,7 @@ type Scheduler struct { clientMu sync.RWMutex proxyPrepareMu sync.Mutex client *client.DouyuClient + directClient *client.DouyuClient // accountClients 按账号名路由到独立的代理客户端;未命中的账号使用 client。 accountClients map[string]*client.DouyuClient accountClientOrder []*client.DouyuClient @@ -73,6 +74,7 @@ type Scheduler struct { proxyStandbyTarget int proxyPoolGeneration uint64 proxyRefillInFlight bool + proxyFallbackActive bool paths types.AppPaths font *truetype.Font @@ -162,8 +164,13 @@ func New(cli *client.DouyuClient, paths types.AppPaths, font *truetype.Font, con if attempts <= 0 { attempts = constants.DefaultAttempts } + var directClient *client.DouyuClient + if cli != nil { + directClient, _ = client.NewWithProxy(cli.Activity, cli.TimeAPIURL, cli.Trace, "") + } scheduler := &Scheduler{ client: cli, + directClient: directClient, accountClients: make(map[string]*client.DouyuClient), paths: paths, font: font, @@ -194,6 +201,18 @@ func New(cli *client.DouyuClient, paths types.AppPaths, font *truetype.Font, con // Close 关闭调度器的后台资源。 func (s *Scheduler) Close() { s.closeAccountClients() + s.clientMu.Lock() + directClient := s.directClient + s.directClient = nil + s.clientMu.Unlock() + if directClient != nil { + if directClient.HTTPClient != nil { + directClient.HTTPClient.CloseIdleConnections() + } + if directClient.TimeHTTPClient != nil { + directClient.TimeHTTPClient.CloseIdleConnections() + } + } if s.successImages != nil { s.successImages.Close() } @@ -214,6 +233,9 @@ func (s *Scheduler) clientSnapshot() *client.DouyuClient { func (s *Scheduler) clientForAccount(accountName string) *client.DouyuClient { s.clientMu.RLock() defer s.clientMu.RUnlock() + if s.proxyFallbackActive && s.directClient != nil { + return s.directClient + } if cli := s.accountClients[accountName]; cli != nil { return cli } @@ -239,18 +261,31 @@ func (s *Scheduler) UpdateClient(newClient *client.DouyuClient) bool { } func (s *Scheduler) replaceClient(newClient *client.DouyuClient) { + var newDirect *client.DouyuClient + if newClient != nil { + newDirect, _ = client.NewWithProxy(newClient.Activity, newClient.TimeAPIURL, newClient.Trace, "") + } s.clientMu.Lock() old := s.client + oldDirect := s.directClient oldGroups := s.accountClients s.client = newClient + s.directClient = newDirect s.accountClients = make(map[string]*client.DouyuClient) s.accountClientOrder = nil s.accountClientsDirty = true s.accountClientsExpireAt = time.Time{} + s.proxyFallbackActive = false s.clientMu.Unlock() if old != nil && old.HTTPClient != nil { old.HTTPClient.CloseIdleConnections() } + if oldDirect != nil && oldDirect.HTTPClient != nil { + oldDirect.HTTPClient.CloseIdleConnections() + } + if oldDirect != nil && oldDirect.TimeHTTPClient != nil { + oldDirect.TimeHTTPClient.CloseIdleConnections() + } closeDouyuClients(oldGroups) } diff --git a/wails.json b/wails.json index 5bcdf7b..9a55d17 100644 --- a/wails.json +++ b/wails.json @@ -2,7 +2,7 @@ "$schema": "https://wails.io/schemas/config.v2.json", "name": "douyu_go", "outputfilename": "douyu_go", - "version": "0.5.2", + "version": "0.5.3", "frontend:dir": "frontend", "frontend:install": "npm install", "frontend:build": "npm run build", @@ -15,6 +15,6 @@ "email": "yml@example.com" }, "info": { - "productVersion": "0.5.2" + "productVersion": "0.5.3" } }