package seckill import ( "bufio" "bytes" "errors" "fmt" "math/rand" "os" "path/filepath" "strings" "sync" "sync/atomic" "time" "github.com/golang/freetype/truetype" "douyu_go/internal/client" "douyu_go/internal/constants" "douyu_go/internal/image" "douyu_go/internal/logger" "douyu_go/internal/types" "douyu_go/internal/utils" ) const ( warmupBeforeTrigger = 2 * time.Second warmupMaxAge = 30 * time.Second qualifiedMaxAge = 30 * time.Second timeCalibrateRounds = 3 timeCalibrateWait = 1200 * time.Millisecond resyncBeforeTrigger = 10 * time.Second seckillMaxDuration = 75 * time.Second behaviorCooldown = 5 * time.Second clickFastCooldown = 3 * time.Second internalAdvance = 50 * time.Millisecond maxCooldownCount = 5 ) type roundOutcome struct { successAccounts map[string]bool stoppedAccounts map[string]string stoppedProducts map[string]string cooldownAccounts map[string]time.Time attempts int } type runSettings struct { concurrency int attempts int retryStages []types.RetryStage seckillMode types.SeckillMode } // Scheduler 抢购调度器。 type Scheduler struct { client *client.DouyuClient paths types.AppPaths font *truetype.Font successImages *image.SuccessImageSaver settingsMu sync.RWMutex concurrency int // 抢购并发数 attempts int // 单号重试次数 retryStages []types.RetryStage // 重试间隔阶段配置 seckillMode types.SeckillMode // 抢购模式 accountsMu sync.RWMutex accounts []types.Account resultsMu sync.RWMutex results map[string]string runMu sync.Mutex running bool scheduleMu sync.Mutex schedule *time.Timer warmupSchedule *time.Timer resyncSchedule *time.Timer warmupGen int64 warmupsMu sync.RWMutex warmups map[string]types.WarmupData warmupRunMu sync.Mutex attemptCacheMu sync.RWMutex attemptCache map[string]*types.AttemptCache // 激进模式缓存 productsMu sync.RWMutex products map[string]types.Product } // New 创建抢购调度器。 func New(cli *client.DouyuClient, paths types.AppPaths, font *truetype.Font, concurrency, attempts int, retryStages []types.RetryStage, seckillMode types.SeckillMode) *Scheduler { if concurrency <= 0 { concurrency = constants.DefaultConcurrency } if attempts <= 0 { attempts = constants.DefaultAttempts } return &Scheduler{ client: cli, paths: paths, font: font, successImages: image.NewSuccessImageSaver( font, paths.SuccessDir, 1, 256, ), concurrency: concurrency, attempts: attempts, retryStages: cloneRetryStages(retryStages), seckillMode: normalizeSeckillMode(seckillMode), results: make(map[string]string), attemptCache: make(map[string]*types.AttemptCache), products: make(map[string]types.Product), } } // Close 关闭调度器的后台资源。 func (s *Scheduler) Close() { if s.successImages != nil { s.successImages.Close() } } // UpdateProducts 更新商品缓存,抢购成功图片会优先使用中文商品名。 func (s *Scheduler) UpdateProducts(products []types.Product) { next := make(map[string]types.Product, len(products)) for _, product := range products { if product.CommodityID == "" { continue } if product.CommodityName == "" { product.CommodityName = product.CommodityID } next[product.CommodityID] = product } s.productsMu.Lock() s.products = next s.productsMu.Unlock() } // UpdateSettings 运行时更新并发数、重试次数、重试间隔和抢购模式。 func (s *Scheduler) UpdateSettings(concurrency, attempts int, retryStages []types.RetryStage, seckillMode types.SeckillMode) { s.settingsMu.Lock() defer s.settingsMu.Unlock() if concurrency > 0 { s.concurrency = concurrency } if attempts > 0 { s.attempts = attempts } if len(retryStages) > 0 { s.retryStages = cloneRetryStages(retryStages) } s.seckillMode = normalizeSeckillMode(seckillMode) } func (s *Scheduler) settingsSnapshot() runSettings { s.settingsMu.RLock() settings := runSettings{ concurrency: s.concurrency, attempts: s.attempts, retryStages: cloneRetryStages(s.retryStages), seckillMode: normalizeSeckillMode(s.seckillMode), } s.settingsMu.RUnlock() if settings.concurrency <= 0 { settings.concurrency = constants.DefaultConcurrency } if settings.attempts <= 0 { settings.attempts = constants.DefaultAttempts } return settings } func cloneRetryStages(stages []types.RetryStage) []types.RetryStage { if len(stages) == 0 { return nil } out := make([]types.RetryStage, len(stages)) copy(out, stages) return out } func normalizeSeckillMode(mode types.SeckillMode) types.SeckillMode { switch mode { case types.SeckillModeNormal, types.SeckillModeAggressive: return mode default: return types.SeckillModeAggressive } } // LoadAccounts 从账号文件加载账号。 func (s *Scheduler) LoadAccounts() { path := s.paths.AccountFile if path == "" { path = constants.DefaultAccountFile } // 文件不存在时自动创建目录和空文件,方便用户直接粘贴 Cookie if _, err := os.Stat(path); os.IsNotExist(err) { if dir := filepath.Dir(path); dir != "" && dir != "." { if mkErr := os.MkdirAll(dir, 0755); mkErr != nil { logger.LogEvent("账号", "warn", "账号目录创建失败: %s: %v", dir, mkErr) } } // 使用 Windows 换行格式 \r\n hint := "# 格式: 账号名----密码----Cookie\r\n# 每行一个账号,粘贴后保存即可\r\n" if wrErr := os.WriteFile(path, []byte(hint), 0644); wrErr != nil { logger.LogEvent("账号", "warn", "账号文件创建失败: %s: %v", path, wrErr) } else { logger.LogEvent("账号", "info", "已创建空账号文件: %s,请粘贴 Cookie 后重新加载", path) } } // 读取文件内容,自动转换换行格式为 Windows 格式 content, err := os.ReadFile(path) if err != nil { logger.LogEvent("账号", "error", "读取账号文件失败: %s: %v", path, err) s.accountsMu.Lock() s.accounts = nil s.accountsMu.Unlock() return } // 检测并转换换行格式 normalized, converted := s.normalizeLineEndings(path, content) if converted { // 保存转换后的内容 if err := os.WriteFile(path, normalized, 0644); err != nil { logger.LogEvent("账号", "warn", "账号文件换行格式转换失败: %s: %v", path, err) } else { logger.LogEvent("账号", "info", "账号文件已自动转换为 Windows 换行格式: %s", path) } content = normalized } var list []types.Account scanner := bufio.NewScanner(bytes.NewReader(content)) scanner.Buffer(make([]byte, 1024), 1024*1024) for scanner.Scan() { line := strings.TrimSpace(scanner.Text()) if line == "" || strings.HasPrefix(line, "#") { continue } parts := strings.SplitN(line, "----", 3) if len(parts) != 3 { logger.LogEvent("账号", "warn", "账号行格式错误,已跳过: %s", line) continue } list = append(list, types.Account{ Name: strings.TrimSpace(parts[0]), Password: strings.TrimSpace(parts[1]), Cookie: strings.TrimSpace(parts[2]), }) } if err := scanner.Err(); err != nil { logger.LogEvent("账号", "error", "读取账号文件中断: %v", err) } s.accountsMu.Lock() s.accounts = list s.accountsMu.Unlock() logger.LogEvent("账号", "success", "账号加载完成: %d 个,来源=%s", len(list), path) } // AccountCount 返回当前账号数。 func (s *Scheduler) AccountCount() int { s.accountsMu.RLock() defer s.accountsMu.RUnlock() return len(s.accounts) } // normalizeLineEndings 检测并转换换行格式为 Windows 格式(\r\n)。 // 返回转换后的内容和是否进行了转换。 func (s *Scheduler) normalizeLineEndings(path string, content []byte) ([]byte, bool) { // 检查是否已经是 Windows 格式(包含 \r\n) if bytes.Contains(content, []byte("\r\n")) { // 已经是 Windows 格式,检查是否还有单独的 \n // 先将所有 \r\n 替换为占位符,检查是否还有单独的 \n temp := bytes.ReplaceAll(content, []byte("\r\n"), []byte("__RN_PLACEHOLDER__")) if !bytes.Contains(temp, []byte("\n")) && !bytes.Contains(temp, []byte("\r")) { // 完全是 Windows 格式,不需要转换 return content, false } // 混合格式,需要统一转换 } // 转换逻辑:先统一为 \n,再转换为 \r\n normalized := content // 1. 将 \r\n 替换为 \n normalized = bytes.ReplaceAll(normalized, []byte("\r\n"), []byte("\n")) // 2. 将单独的 \r 替换为 \n normalized = bytes.ReplaceAll(normalized, []byte("\r"), []byte("\n")) // 3. 将 \n 替换为 \r\n normalized = bytes.ReplaceAll(normalized, []byte("\n"), []byte("\r\n")) return normalized, true } // AccountFilePath 返回账号文件路径。 func (s *Scheduler) AccountFilePath() string { return s.paths.AccountFile } // AccountSnapshot 复制一份账号列表。 func (s *Scheduler) AccountSnapshot() []types.Account { s.accountsMu.RLock() defer s.accountsMu.RUnlock() list := make([]types.Account, len(s.accounts)) copy(list, s.accounts) return list } // AccountCookieByName 按账号名查找 Cookie。 func (s *Scheduler) AccountCookieByName(name string) (string, bool) { s.accountsMu.RLock() defer s.accountsMu.RUnlock() for _, account := range s.accounts { if account.Name == name { return account.Cookie, true } } return "", false } // Results 返回当前抢购结果快照。 func (s *Scheduler) Results() map[string]string { s.resultsMu.RLock() defer s.resultsMu.RUnlock() out := make(map[string]string, len(s.results)) for k, v := range s.results { out[k] = v } return out } // ClearResults 清空抢购结果。 func (s *Scheduler) ClearResults() { s.resultsMu.Lock() defer s.resultsMu.Unlock() s.results = make(map[string]string) } func (s *Scheduler) setResult(key, value string) { s.resultsMu.Lock() defer s.resultsMu.Unlock() s.results[key] = value } // TryStartRun 尝试开始抢购,返回 false 表示已有任务在运行。 func (s *Scheduler) TryStartRun() bool { s.runMu.Lock() defer s.runMu.Unlock() if s.running { return false } s.running = true return true } func (s *Scheduler) finishRun() { s.runMu.Lock() defer s.runMu.Unlock() s.running = false } // RunNow 立即执行抢购任务,持续循环直到超时或全部成功。 func (s *Scheduler) RunNow(accountProducts map[string]string) { defer s.finishRun() s.ClearResults() settings := s.settingsSnapshot() allAttempts := s.buildAttempts(accountProducts, settings.attempts) if len(allAttempts) == 0 { logger.LogEvent("抢购", "warn", "没有可执行的抢购任务") return } successAccounts := make(map[string]bool) stoppedAccounts := make(map[string]string) stoppedProducts := make(map[string]string) cooldownAccounts := make(map[string]time.Time) cooldownCount := make(map[string]int) totalAccounts := uniqueAttemptAccounts(allAttempts) totalAttempts := 0 startTime := time.Now() round := 0 s.clearAttemptCache() if settings.seckillMode == types.SeckillModeAggressive { s.initCacheFromWarmup(allAttempts) } logger.LogEvent("抢购", "info", "开始抢购: %d 个账号,窗口=%v,预检通过后直兑,前段高频后段降速", totalAccounts, seckillMaxDuration) for { elapsed := time.Since(startTime) if elapsed >= seckillMaxDuration { logger.LogEvent("抢购", "info", "已达到抢购窗口 %v,停止抢购", seckillMaxDuration) break } round++ remaining := seckillMaxDuration - elapsed pendingAttempts := s.filterPendingAttempts(allAttempts, stoppedAccounts, stoppedProducts) if len(pendingAttempts) == 0 { logger.LogEvent("抢购", "info", "所有账号都已成功或遇到终止条件,停止抢购") break } roundAttempts := pickRoundAttempts(pendingAttempts, round, settings.attempts) if len(roundAttempts) == 0 { logger.LogEvent("抢购", "info", "第%d轮无可执行账号,停止抢购", round) break } now := time.Now() roundAttempts, nextReady := filterCooldownAttempts(roundAttempts, cooldownAccounts, now) if len(roundAttempts) == 0 { sleepFor := nextReady.Sub(now) if sleepFor <= 0 { sleepFor = retryIntervalFor(settings.retryStages, time.Since(startTime)) } if sleepFor > remaining { sleepFor = remaining } if sleepFor > 0 { logger.LogEvent("抢购", "info", "第%d轮账号冷却中,等待=%v", round, utils.RoundDuration(sleepFor)) time.Sleep(sleepFor) } continue } logger.LogEvent("抢购", "info", "第%d轮: 待抢购 %d 个账号,本轮执行=%d,剩余时间=%v,模式=%s", round, uniqueAttemptAccounts(pendingAttempts), len(roundAttempts), utils.RoundDuration(remaining), modeName(settings.seckillMode)) outcome := s.executeRound(roundAttempts, settings) totalAttempts += outcome.attempts for account := range outcome.successAccounts { successAccounts[account] = true stoppedAccounts[account] = "已抢到" } for account, reason := range outcome.stoppedAccounts { if stoppedAccounts[account] == "" { stoppedAccounts[account] = reason logger.LogAccountEvent("抢购", "warn", account, "账号停止重试: 账号=%s 原因=%s", account, reason) } } for product, reason := range outcome.stoppedProducts { if stoppedProducts[product] == "" { stoppedProducts[product] = reason logger.LogEvent("抢购", "warn", "商品停止重试: %s,原因=%s", product, reason) } } for account, until := range outcome.cooldownAccounts { if until.After(cooldownAccounts[account]) { cooldownAccounts[account] = until cooldownCount[account]++ logger.LogAccountEvent("抢购", "warn", account, "账号临时降频: 账号=%s 冷却至=%s (第%d次)", account, until.In(constants.CST).Format("15:04:05.000"), cooldownCount[account]) if cooldownCount[account] >= maxCooldownCount { stoppedAccounts[account] = "冷却次数过多" logger.LogAccountEvent("抢购", "warn", account, "账号停止重试: 账号=%s 原因=冷却次数过多(%d次)", account, cooldownCount[account]) } } } if len(outcome.successAccounts) > 0 { logger.LogEvent("抢购", "success", "第%d轮成功: %d 个账号", round, len(outcome.successAccounts)) } if len(stoppedAccounts) >= totalAccounts { logger.LogEvent("抢购", "info", "所有账号都已成功或停止重试,停止抢购") break } retryInterval := retryIntervalFor(settings.retryStages, time.Since(startTime)) if retryInterval > 0 && time.Since(startTime)+retryInterval < seckillMaxDuration { time.Sleep(jitterDuration(retryInterval)) } } logger.LogEvent("抢购", "info", "抢购任务结束: 成功=%d/%d,停止=%d,账号尝试=%d,耗时=%v", len(successAccounts), totalAccounts, len(stoppedAccounts)-len(successAccounts), totalAttempts, utils.RoundDuration(time.Since(startTime))) } // filterPendingAttempts 过滤掉已终止账号和已确认无库存的商品。 func (s *Scheduler) filterPendingAttempts(allAttempts []types.ExchangeAttempt, stoppedAccounts, stoppedProducts map[string]string) []types.ExchangeAttempt { var pending []types.ExchangeAttempt for _, attempt := range allAttempts { if stoppedAccounts[attempt.Account.Name] != "" { continue } if stoppedProducts[attempt.Product.CommodityID] != "" { continue } pending = append(pending, attempt) } return pending } func filterCooldownAttempts(attempts []types.ExchangeAttempt, cooldownAccounts map[string]time.Time, now time.Time) ([]types.ExchangeAttempt, time.Time) { out := make([]types.ExchangeAttempt, 0, len(attempts)) var nextReady time.Time for _, attempt := range attempts { until := cooldownAccounts[attempt.Account.Name] if until.After(now) { if nextReady.IsZero() || until.Before(nextReady) { nextReady = until } continue } out = append(out, attempt) } return out, nextReady } // pickRoundAttempts 每轮每个账号最多执行一次,避免同账号并发过猛触发频控。 func pickRoundAttempts(attempts []types.ExchangeAttempt, round, attemptsPerAccount int) []types.ExchangeAttempt { if len(attempts) == 0 { return nil } preferredIndex := 1 if attemptsPerAccount > 0 { preferredIndex = ((round - 1) % attemptsPerAccount) + 1 } byAccount := make(map[string]types.ExchangeAttempt) fallback := make(map[string]types.ExchangeAttempt) order := make([]string, 0, len(attempts)) for _, attempt := range attempts { name := attempt.Account.Name if _, ok := fallback[name]; !ok { fallback[name] = attempt order = append(order, name) } if attempt.Index == preferredIndex { byAccount[name] = attempt } } out := make([]types.ExchangeAttempt, 0, len(order)) for _, name := range order { if attempt, ok := byAccount[name]; ok { out = append(out, attempt) } else { out = append(out, fallback[name]) } } return out } // executeRound 执行一轮抢购,并返回成功和终止重试的账号。 func (s *Scheduler) executeRound(attempts []types.ExchangeAttempt, settings runSettings) roundOutcome { outcome := roundOutcome{ successAccounts: make(map[string]bool), stoppedAccounts: make(map[string]string), stoppedProducts: make(map[string]string), cooldownAccounts: make(map[string]time.Time), } var mu sync.Mutex limit := make(chan struct{}, settings.concurrency) var wg sync.WaitGroup for _, attempt := range attempts { wg.Add(1) go func(attempt types.ExchangeAttempt) { defer wg.Done() limit <- struct{}{} defer func() { <-limit }() // 根据模式选择执行方法 var result types.ExchangeResult if settings.seckillMode == types.SeckillModeAggressive { result = s.runAttemptFast(attempt) } else { result = s.runAttempt(attempt) } key := fmt.Sprintf("%s_第%d包", result.Account, result.Attempt) s.setResult(key, result.Message) if result.OK { logger.LogAccountEvent("抢购", "success", result.Account, "成功: 账号=%s 商品=%s 第%d包 %s", result.Account, result.Product, result.Attempt, result.Message) s.enqueueSuccessImage(attempt.Account, attempt.Product, result.RoleName) } else { logger.LogAccountEvent("抢购", "info", result.Account, "尝试: 账号=%s 商品=%s 第%d包 %s", result.Account, result.Product, result.Attempt, result.Message) } mu.Lock() outcome.attempts++ if result.OK { outcome.successAccounts[attempt.Account.Name] = true } else { if cooldown := retryCooldownDuration(result.Message); cooldown > 0 { outcome.cooldownAccounts[attempt.Account.Name] = time.Now().Add(jitterDuration(cooldown)) } terminalAccount, terminalProduct, reason := classifyRetryStop(result.Message) if terminalAccount { outcome.stoppedAccounts[attempt.Account.Name] = reason } if terminalProduct { outcome.stoppedProducts[attempt.Product.CommodityID] = reason } } mu.Unlock() }(attempt) } wg.Wait() return outcome } // modeName 返回抢购模式名称。 func modeName(mode types.SeckillMode) string { if mode == types.SeckillModeAggressive { return "激进" } return "标准" } // retryIntervalFor 根据配置的重试阶段计算当前应该使用的重试间隔。 func retryIntervalFor(retryStages []types.RetryStage, elapsed time.Duration) time.Duration { elapsedSec := int(elapsed.Seconds()) // 使用配置的阶段 for _, stage := range retryStages { if stage.MaxElapsed > 0 && elapsedSec < stage.MaxElapsed && stage.Interval > 0 { return time.Duration(stage.Interval) * time.Millisecond } } // 默认值(如果没有配置或配置无效) return 900 * time.Millisecond } func jitterDuration(base time.Duration) time.Duration { if base <= 0 { return 0 } jitter := time.Duration(rand.Int63n(int64(base / 10))) return base + jitter } func retryCooldownDuration(message string) time.Duration { switch { case strings.Contains(message, "用户行为异常"): return behaviorCooldown case strings.Contains(message, "点击太快"): return clickFastCooldown case strings.Contains(message, "操作频繁"): return behaviorCooldown case strings.Contains(message, "请求过多"): return behaviorCooldown case strings.Contains(message, "请求太频繁"): return behaviorCooldown default: return 0 } } func classifyRetryStop(message string) (account bool, product bool, reason string) { switch { case strings.Contains(message, "商品本次活动库存已耗完"): // 库存耗尽不停止,继续重试(斗鱼可能会补货) return false, false, "" case strings.Contains(message, "您已达本次活动兑换上限"): return true, false, "已达兑换上限" case strings.Contains(message, "未绑定账号"): return true, false, "账号未绑定角色" case strings.Contains(message, "需要开通精英手册"): return true, false, "账号不满足精英手册条件" default: return false, false, "" } } func uniqueAttemptAccounts(attempts []types.ExchangeAttempt) int { seen := make(map[string]struct{}, len(attempts)) for _, attempt := range attempts { seen[attempt.Account.Name] = struct{}{} } return len(seen) } func (s *Scheduler) buildAttempts(accountProducts map[string]string, attemptsPerAccount int) []types.ExchangeAttempt { if attemptsPerAccount <= 0 { attemptsPerAccount = constants.DefaultAttempts } accounts := s.AccountSnapshot() var attempts []types.ExchangeAttempt for _, account := range accounts { commodityID := accountProducts[account.Name] if commodityID == "" { continue } product := s.productForCommodityID(commodityID) for i := 1; i <= attemptsPerAccount; i++ { attempts = append(attempts, types.ExchangeAttempt{ Account: account, Product: product, Index: i, }) } } return attempts } func (s *Scheduler) productForCommodityID(commodityID string) types.Product { s.productsMu.RLock() product, ok := s.products[commodityID] s.productsMu.RUnlock() if ok { if product.CommodityName == "" { product.CommodityName = commodityID } return product } return types.Product{CommodityID: commodityID, CommodityName: commodityID} } func (s *Scheduler) enqueueSuccessImage(account types.Account, product types.Product, roleName string) { if s.successImages == nil { return } s.successImages.Enqueue(account, product, roleName) } func warmupKey(attempt types.ExchangeAttempt) string { return fmt.Sprintf("%s|%s", attempt.Account.Name, attempt.Product.CommodityID) } func (s *Scheduler) setWarmup(key string, data types.WarmupData) { s.warmupsMu.Lock() defer s.warmupsMu.Unlock() if s.warmups == nil { s.warmups = make(map[string]types.WarmupData) } s.warmups[key] = data } func (s *Scheduler) warmupFor(attempt types.ExchangeAttempt) (types.WarmupData, bool) { s.warmupsMu.RLock() data, ok := s.warmups[warmupKey(attempt)] s.warmupsMu.RUnlock() if !ok || data.CreatedAt.IsZero() || time.Since(data.CreatedAt) > warmupMaxAge { return types.WarmupData{}, false } return data, true } func (s *Scheduler) clearWarmups() { s.warmupsMu.Lock() defer s.warmupsMu.Unlock() s.warmups = make(map[string]types.WarmupData) } // ========== 激进模式缓存管理 ========== func (s *Scheduler) getAttemptCache(accountName string) *types.AttemptCache { s.attemptCacheMu.RLock() defer s.attemptCacheMu.RUnlock() return s.attemptCache[accountName] } // initCacheFromWarmup 从预热数据初始化激进模式缓存。 func (s *Scheduler) initCacheFromWarmup(attempts []types.ExchangeAttempt) { for _, attempt := range attempts { if warmup, ok := s.warmupFor(attempt); ok { s.setAttemptCache(attempt.Account.Name, &types.AttemptCache{ CSRF: warmup.CSRF, RoleName: warmup.RoleName, Qualified: warmup.Qualified, LastCheck: time.Now(), }) logger.LogAccountEvent("抢购", "info", attempt.Account.Name, "从预热初始化缓存: 账号=%s", attempt.Account.Name) } } } func (s *Scheduler) setAttemptCache(accountName string, cache *types.AttemptCache) { s.attemptCacheMu.Lock() defer s.attemptCacheMu.Unlock() if cache == nil { delete(s.attemptCache, accountName) return } s.attemptCache[accountName] = cache } func (s *Scheduler) clearAttemptCache() { s.attemptCacheMu.Lock() defer s.attemptCacheMu.Unlock() s.attemptCache = make(map[string]*types.AttemptCache) } func (s *Scheduler) warmupAttempts(attempts []types.ExchangeAttempt) { s.warmupRunMu.Lock() defer s.warmupRunMu.Unlock() attempts = uniqueWarmupAttempts(attempts) if len(attempts) == 0 { return } s.clearWarmups() logger.LogEvent("预热", "info", "开始预热: %d 个请求", len(attempts)) settings := s.settingsSnapshot() limit := make(chan struct{}, settings.concurrency) var wg sync.WaitGroup for _, attempt := range attempts { wg.Add(1) go func(attempt types.ExchangeAttempt) { defer wg.Done() limit <- struct{}{} defer func() { <-limit }() start := time.Now() csrf, err := s.client.GenerateCSRF(attempt.Account.Cookie) if err != nil { logger.LogAccountEvent("预热", "warn", attempt.Account.Name, "CSRF预热失败: 账号=%s 商品=%s err=%v", attempt.Account.Name, attempt.Product.CommodityName, err) return } roleName, err := s.client.RoleName(attempt.Account.Cookie) if err != nil { logger.LogAccountEvent("预热", "warn", attempt.Account.Name, "角色预热失败: 账号=%s err=%v", attempt.Account.Name, err) } s.setWarmup(warmupKey(attempt), types.WarmupData{ CSRF: csrf, RoleName: roleName, Qualified: true, CreatedAt: time.Now(), }) logger.LogAccountEvent("预热", "success", attempt.Account.Name, "预热完成: 账号=%s 商品=%s 耗时=%s", attempt.Account.Name, attempt.Product.CommodityName, utils.RoundDuration(time.Since(start))) }(attempt) } wg.Wait() logger.LogEvent("预热", "info", "预热任务结束") } func uniqueWarmupAttempts(attempts []types.ExchangeAttempt) []types.ExchangeAttempt { if len(attempts) <= 1 { return attempts } seen := make(map[string]struct{}, len(attempts)) out := make([]types.ExchangeAttempt, 0, len(attempts)) for _, attempt := range attempts { key := warmupKey(attempt) if _, ok := seen[key]; ok { continue } seen[key] = struct{}{} out = append(out, attempt) } return out } func (s *Scheduler) calibrateDouyuTime(label string) types.TimeCalibration { calibration, err := s.client.BestServerTimeCalibration(timeCalibrateRounds, timeCalibrateWait) if err != nil { logger.LogEvent("时间", "warn", "%s校准降级: %v", label, err) } logger.SetDouyuOffset(calibration.Offset) logger.LogEvent("时间", "success", "%s校准完成: 斗鱼估算=%s 偏移=%dms 误差<=%dms RTT=%dms 采样=%d 来源=%s", label, calibration.EstimatedServerNow().In(constants.CST).Format("2006-01-02 15:04:05.000"), calibration.Offset.Milliseconds(), calibration.ErrorBound.Milliseconds(), calibration.RTT.Milliseconds(), calibration.Samples, calibration.Source) return calibration } func (s *Scheduler) replaceTimerLocked(timer **time.Timer, d time.Duration, fn func()) { if *timer != nil { (*timer).Stop() } *timer = time.AfterFunc(d, fn) } func (s *Scheduler) stopSchedulesLocked() { if s.schedule != nil { s.schedule.Stop() s.schedule = nil } if s.warmupSchedule != nil { s.warmupSchedule.Stop() s.warmupSchedule = nil } if s.resyncSchedule != nil { s.resyncSchedule.Stop() s.resyncSchedule = nil } } func (s *Scheduler) runAttempt(attempt types.ExchangeAttempt) types.ExchangeResult { result := types.ExchangeResult{ Account: attempt.Account.Name, Product: attempt.Product.CommodityName, Attempt: attempt.Index, } logger.LogAccountEvent("抢购", "info", attempt.Account.Name, "执行资格预检链路: 账号=%s 商品=%s 第%d包", attempt.Account.Name, attempt.Product.CommodityName, attempt.Index) var roleName string csrf := "" if warmup, ok := s.warmupFor(attempt); ok { csrf = warmup.CSRF roleName = warmup.RoleName logger.LogAccountEvent("抢购", "info", attempt.Account.Name, "使用预热CSRF: 账号=%s 商品=%s 预热距今=%s", attempt.Account.Name, attempt.Product.CommodityName, utils.RoundDuration(time.Since(warmup.CreatedAt))) } if csrf == "" { var err error csrf, err = s.client.GenerateCSRF(attempt.Account.Cookie) if err != nil { result.Message = "失败|生成CSRF失败: " + err.Error() return result } logger.LogAccountEvent("抢购", "info", attempt.Account.Name, "CSRF已生成,本次兑换链路复用同一个 token: 账号=%s 商品=%s", attempt.Account.Name, attempt.Product.CommodityName) } limit, err := s.client.BatchExchangeLimit(attempt.Account.Cookie, attempt.Product.CommodityID, &csrf) if err != nil { result.Message = "失败|批量限制检查失败: " + err.Error() return result } if limit <= 0 { result.Message = "失败|当前商品限制兑换" return result } logger.LogAccountEvent("抢购", "info", attempt.Account.Name, "批量限制通过: 账号=%s 商品=%s limit=%d", attempt.Account.Name, attempt.Product.CommodityName, limit) if err := s.client.PreExchange(attempt.Account.Cookie, attempt.Product.CommodityID, &csrf); err != nil { result.Message = "失败|预兑换失败: " + err.Error() return result } s.setAttemptCache(attempt.Account.Name, &types.AttemptCache{ CSRF: csrf, RoleName: roleName, Qualified: true, LastCheck: time.Now(), }) logger.LogAccountEvent("抢购", "info", attempt.Account.Name, "资格预检通过: 账号=%s 商品=%s,后续可直兑", attempt.Account.Name, attempt.Product.CommodityName) exchangeInfo, err := s.client.Exchange(attempt.Account.Cookie, attempt.Product.CommodityID, &csrf) if err != nil { s.setAttemptCache(attempt.Account.Name, &types.AttemptCache{ CSRF: csrf, RoleName: roleName, Qualified: true, LastCheck: time.Now(), }) result.RoleName = roleName result.Message = "失败|" + err.Error() return result } if roleName == "" { roleName, err = s.client.RoleName(attempt.Account.Cookie) if err != nil { logger.LogAccountEvent("抢购", "warn", attempt.Account.Name, "角色名查询失败: 账号=%s err=%v", attempt.Account.Name, err) } } result.OK = true result.RoleName = roleName if roleName != "" { result.Message = "成功|" + roleName + "|" + exchangeInfo } else { result.Message = "成功|" + exchangeInfo } // 缓存 CSRF 和角色名(激进模式使用) s.setAttemptCache(attempt.Account.Name, &types.AttemptCache{ CSRF: csrf, RoleName: roleName, Qualified: true, LastCheck: time.Now(), }) return result } // runAttemptFast 激进模式的兑换逻辑,复用缓存的 CSRF,跳过 BatchExchangeLimit 和 PreExchange。 func (s *Scheduler) runAttemptFast(attempt types.ExchangeAttempt) types.ExchangeResult { result := types.ExchangeResult{ Account: attempt.Account.Name, Product: attempt.Product.CommodityName, Attempt: attempt.Index, } cache := s.getAttemptCache(attempt.Account.Name) if cache == nil || cache.CSRF == "" || time.Since(cache.LastCheck) >= qualifiedMaxAge { logger.LogAccountEvent("抢购", "info", attempt.Account.Name, "激进模式执行资格预检: 账号=%s 原因=无缓存CSRF", attempt.Account.Name) return s.runAttempt(attempt) } if !cache.Qualified { logger.LogAccountEvent("抢购", "info", attempt.Account.Name, "激进模式执行资格预检: 账号=%s 原因=未完成资格预检", attempt.Account.Name) return s.runAttempt(attempt) } csrf := cache.CSRF logger.LogAccountEvent("抢购", "info", attempt.Account.Name, "激进模式直兑: 账号=%s 商品=%s 第%d包", attempt.Account.Name, attempt.Product.CommodityName, attempt.Index) // 直接调用 Exchange exchangeInfo, err := s.client.Exchange(attempt.Account.Cookie, attempt.Product.CommodityID, &csrf) if err != nil { s.setAttemptCache(attempt.Account.Name, &types.AttemptCache{ CSRF: csrf, RoleName: cache.RoleName, Qualified: true, LastCheck: time.Now(), }) result.RoleName = cache.RoleName errMsg := err.Error() if shouldFallbackStandard(errMsg) { logger.LogAccountEvent("抢购", "warn", attempt.Account.Name, "激进模式回退标准: 账号=%s 原因=%s", attempt.Account.Name, utils.TrimForLog(errMsg, 80)) s.setAttemptCache(attempt.Account.Name, nil) // 清空缓存 return s.runAttempt(attempt) } result.Message = "失败|" + errMsg return result } // 获取角色名 roleName := "" if cache != nil { roleName = cache.RoleName } if roleName == "" { var err error roleName, err = s.client.RoleName(attempt.Account.Cookie) if err != nil { logger.LogAccountEvent("抢购", "warn", attempt.Account.Name, "角色名查询失败: 账号=%s err=%v", attempt.Account.Name, err) } } s.setAttemptCache(attempt.Account.Name, &types.AttemptCache{ CSRF: csrf, RoleName: roleName, Qualified: true, LastCheck: time.Now(), }) result.OK = true result.RoleName = roleName if roleName != "" { result.Message = "成功|" + roleName + "|" + exchangeInfo } else { result.Message = "成功|" + exchangeInfo } return result } func shouldFallbackStandard(errMsg string) bool { lower := strings.ToLower(errMsg) switch { case strings.Contains(lower, "csrf"): return true case strings.Contains(lower, "cvl_csrf_token"): return true case strings.Contains(lower, "preexchange"): return true case strings.Contains(lower, "limit"): return true case strings.Contains(errMsg, "预兑换"): return true case strings.Contains(errMsg, "限制检查"): return true default: return false } } // ScheduleRun 注册一次定时抢购。 func (s *Scheduler) ScheduleRun(req types.SeckillRequest) (map[string]any, error) { if len(req.AccountProducts) == 0 { return nil, errors.New("请选择账号和商品") } if strings.TrimSpace(req.TargetTime) == "" { return nil, errors.New("请设置目标时间") } targetLocal, err := time.ParseInLocation("2006-01-02 15:04:05", req.TargetTime, constants.CST) if err != nil { return nil, fmt.Errorf("时间格式错误: %w", err) } targetTime := targetLocal.UTC() calibration := s.calibrateDouyuTime("定时") serverTime := calibration.EstimatedServerNow() triggerTime := targetTime.Add(-internalAdvance) remain := triggerTime.Sub(serverTime) if remain <= 0 { return nil, errors.New("目标时间已过") } ap := utils.CloneStringMap(req.AccountProducts) s.scheduleMu.Lock() s.stopSchedulesLocked() s.clearWarmups() s.scheduleMu.Unlock() s.scheduleTimers(ap, targetTime, triggerTime, calibration, false) resyncRemain := triggerTime.Sub(serverTime) - resyncBeforeTrigger if resyncRemain < 0 { resyncRemain = 0 } s.scheduleMu.Lock() s.replaceTimerLocked(&s.resyncSchedule, resyncRemain, func() { newCalibration := s.calibrateDouyuTime("临近") s.scheduleTimers(ap, targetTime, triggerTime, newCalibration, true) }) s.scheduleMu.Unlock() warmupRemain := remain - warmupBeforeTrigger if warmupRemain < 0 { warmupRemain = 0 } logger.LogEvent("定时", "success", "定时已设置: 目标=%s 触发=%s 提前=%dms 斗鱼估算=%s 本地偏移=%dms 误差<=%dms RTT=%dms 预热=%s 复校=%s", targetTime.In(constants.CST).Format("2006-01-02 15:04:05.000"), triggerTime.In(constants.CST).Format("2006-01-02 15:04:05.000"), internalAdvance.Milliseconds(), serverTime.In(constants.CST).Format("2006-01-02 15:04:05.000"), calibration.Offset.Milliseconds(), calibration.ErrorBound.Milliseconds(), calibration.RTT.Milliseconds(), time.Now().Add(warmupRemain).In(constants.CST).Format("15:04:05.000"), time.Now().Add(resyncRemain).In(constants.CST).Format("15:04:05.000"), ) return map[string]any{ "success": true, "targetTime": targetTime.In(constants.CST).Format("2006-01-02 15:04:05"), "triggerTime": triggerTime.In(constants.CST).Format("2006-01-02 15:04:05"), "offsetMs": calibration.Offset.Milliseconds(), "errorBoundMs": calibration.ErrorBound.Milliseconds(), "rttMs": calibration.RTT.Milliseconds(), }, nil } func (s *Scheduler) scheduleTimers(accountProducts map[string]string, targetTime, triggerTime time.Time, calibration types.TimeCalibration, resync bool) { serverTime := calibration.EstimatedServerNow() remain := triggerTime.Sub(serverTime) if remain < 0 { remain = 0 } warmupRemain := remain - warmupBeforeTrigger if warmupRemain < 0 { warmupRemain = 0 } s.scheduleMu.Lock() defer s.scheduleMu.Unlock() gen := atomic.AddInt64(&s.warmupGen, 1) s.replaceTimerLocked(&s.warmupSchedule, warmupRemain, func() { if atomic.LoadInt64(&s.warmupGen) != gen { return } logger.LogEvent("预热", "success", "预热触发: 本地=%s", time.Now().In(constants.CST).Format("15:04:05.000")) settings := s.settingsSnapshot() attempts := s.buildAttempts(accountProducts, settings.attempts) s.warmupAttempts(attempts) }) s.replaceTimerLocked(&s.schedule, remain, func() { now := time.Now() estimatedServer := now.Add(calibration.Offset) logger.LogEvent("定时", "success", "定时触发: 本地=%s 斗鱼估算=%s 偏移=%dms 误差<=%dms", now.In(constants.CST).Format("15:04:05.000"), estimatedServer.In(constants.CST).Format("15:04:05.000"), calibration.Offset.Milliseconds(), calibration.ErrorBound.Milliseconds()) if !s.TryStartRun() { logger.LogEvent("抢购", "warn", "已有抢购任务正在运行,本次定时触发已跳过") return } s.RunNow(accountProducts) }) if resync { logger.LogEvent("定时", "success", "临近复校已应用: 目标=%s 触发=%s 斗鱼估算=%s 本地偏移=%dms 误差<=%dms RTT=%dms 预热=%s", targetTime.In(constants.CST).Format("2006-01-02 15:04:05.000"), triggerTime.In(constants.CST).Format("2006-01-02 15:04:05.000"), serverTime.In(constants.CST).Format("2006-01-02 15:04:05.000"), calibration.Offset.Milliseconds(), calibration.ErrorBound.Milliseconds(), calibration.RTT.Milliseconds(), time.Now().Add(warmupRemain).In(constants.CST).Format("15:04:05.000")) } } // CancelSchedule 停止尚未触发的定时任务。 func (s *Scheduler) CancelSchedule() bool { s.scheduleMu.Lock() defer s.scheduleMu.Unlock() stopped := false if s.schedule != nil { stopped = s.schedule.Stop() } s.stopSchedulesLocked() s.clearWarmups() return stopped }